Revert "Merge GrOpList and GrRTOpList and rename to GrOpsTask."
This reverts commit 2a5954140b49d18e5161a30a4ae2c7ac28bc1993.
Reason for revert: breaking everything
Original change's description:
> Merge GrOpList and GrRTOpList and rename to GrOpsTask.
>
> Change-Id: I8f4f2218a30fd0541a8f79f7bb9850f9500cd243
> Reviewed-on: https://skia-review.googlesource.com/c/skia/+/236343
> Commit-Queue: Greg Daniel <egdaniel@google.com>
> Reviewed-by: Brian Salomon <bsalomon@google.com>
TBR=egdaniel@google.com,bsalomon@google.com,robertphillips@google.com
Change-Id: I27840ea0343e8e6b388556afb7bd2e76386d611d
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/236349
Reviewed-by: Greg Daniel <egdaniel@google.com>
Commit-Queue: Greg Daniel <egdaniel@google.com>
diff --git a/gn/gpu.gni b/gn/gpu.gni
index bb4210d..b37ab4f 100644
--- a/gn/gpu.gni
+++ b/gn/gpu.gni
@@ -121,8 +121,8 @@
"$_src/gpu/GrNonAtomicRef.h",
"$_src/gpu/GrOpFlushState.cpp",
"$_src/gpu/GrOpFlushState.h",
- "$_src/gpu/GrOpsTask.cpp",
- "$_src/gpu/GrOpsTask.h",
+ "$_src/gpu/GrOpList.cpp",
+ "$_src/gpu/GrOpList.h",
"$_src/gpu/GrPaint.cpp",
"$_src/gpu/GrPaint.h",
"$_src/gpu/GrPathRendererChain.cpp",
@@ -167,6 +167,8 @@
"$_src/gpu/GrRenderTargetContext.cpp",
"$_src/gpu/GrRenderTargetContext.h",
"$_src/gpu/GrRenderTargetContextPriv.h",
+ "$_src/gpu/GrRenderTargetOpList.cpp",
+ "$_src/gpu/GrRenderTargetOpList.h",
"$_src/gpu/GrResourceAllocator.cpp",
"$_src/gpu/GrResourceAllocator.h",
"$_src/gpu/GrResourceCache.cpp",
@@ -574,7 +576,7 @@
"$_src/gpu/ccpr/GrCCPathProcessor.h",
"$_src/gpu/ccpr/GrCCPerFlushResources.cpp",
"$_src/gpu/ccpr/GrCCPerFlushResources.h",
- "$_src/gpu/ccpr/GrCCPerOpsTaskPaths.h",
+ "$_src/gpu/ccpr/GrCCPerOpListPaths.h",
"$_src/gpu/ccpr/GrCCQuadraticShader.cpp",
"$_src/gpu/ccpr/GrCCQuadraticShader.h",
"$_src/gpu/ccpr/GrCCStrokeGeometry.cpp",
diff --git a/include/gpu/GrGpuResource.h b/include/gpu/GrGpuResource.h
index 3e4c6c6..ce74d74 100644
--- a/include/gpu/GrGpuResource.h
+++ b/include/gpu/GrGpuResource.h
@@ -24,7 +24,7 @@
*
* Gpu resources can have three types of refs:
* 1) Normal ref (+ by ref(), - by unref()): These are used by code that is issuing draw calls
- * that read and write the resource via GrOpsTask and by any object that must own a
+ * that read and write the resource via GrOpList and by any object that must own a
* GrGpuResource and is itself owned (directly or indirectly) by Skia-client code.
* 2) Pending read (+ by addPendingRead(), - by completedRead()): GrContext has scheduled a read
* of the resource by the GPU as a result of a skia API call but hasn't executed it yet.
diff --git a/include/private/GrRecordingContext.h b/include/private/GrRecordingContext.h
index 1f44bee..447d87f 100644
--- a/include/private/GrRecordingContext.h
+++ b/include/private/GrRecordingContext.h
@@ -40,7 +40,7 @@
GrRecordingContext(GrBackendApi, const GrContextOptions&, uint32_t contextID);
bool init(sk_sp<const GrCaps>, sk_sp<GrSkSLFPFactoryCache>) override;
- void setupDrawingManager(bool sortOpsTasks, bool reduceOpsTaskSplitting);
+ void setupDrawingManager(bool sortOpLists, bool reduceOpListSplitting);
void abandonContext() override;
diff --git a/include/private/GrTypesPriv.h b/include/private/GrTypesPriv.h
index 99da2eb..1c5b2b7 100644
--- a/include/private/GrTypesPriv.h
+++ b/include/private/GrTypesPriv.h
@@ -219,7 +219,7 @@
};
/**
- * This enum is used to specify the load operation to be used when an opsTask/GrGpuCommandBuffer
+ * This enum is used to specify the load operation to be used when an opList/GrGpuCommandBuffer
* begins execution.
*/
enum class GrLoadOp {
@@ -229,7 +229,7 @@
};
/**
- * This enum is used to specify the store operation to be used when an opsTask/GrGpuCommandBuffer
+ * This enum is used to specify the store operation to be used when an opList/GrGpuCommandBuffer
* ends execution.
*/
enum class GrStoreOp {
diff --git a/include/private/SkDeferredDisplayList.h b/include/private/SkDeferredDisplayList.h
index e8fc35b..9ae29d0 100644
--- a/include/private/SkDeferredDisplayList.h
+++ b/include/private/SkDeferredDisplayList.h
@@ -19,7 +19,7 @@
#include <map>
class GrRenderTask;
class GrRenderTargetProxy;
-struct GrCCPerOpsTaskPaths;
+struct GrCCPerOpListPaths;
#endif
/*
@@ -67,7 +67,7 @@
#if SK_SUPPORT_GPU
// This needs to match the same type in GrCoverageCountingPathRenderer.h
- using PendingPathsMap = std::map<uint32_t, sk_sp<GrCCPerOpsTaskPaths>>;
+ using PendingPathsMap = std::map<uint32_t, sk_sp<GrCCPerOpListPaths>>;
SkTArray<sk_sp<GrRenderTask>> fRenderTasks;
PendingPathsMap fPendingPaths; // This is the path data from CCPR.
diff --git a/src/core/SkDeferredDisplayList.cpp b/src/core/SkDeferredDisplayList.cpp
index c89cd99..7d2b971 100644
--- a/src/core/SkDeferredDisplayList.cpp
+++ b/src/core/SkDeferredDisplayList.cpp
@@ -13,7 +13,7 @@
#if SK_SUPPORT_GPU
#include "src/gpu/GrRenderTask.h"
-#include "src/gpu/ccpr/GrCCPerOpsTaskPaths.h"
+#include "src/gpu/ccpr/GrCCPerOpListPaths.h"
#endif
SkDeferredDisplayList::SkDeferredDisplayList(const SkSurfaceCharacterization& characterization,
diff --git a/src/core/SkTTopoSort.h b/src/core/SkTTopoSort.h
index bc1b07e..9df95ee 100644
--- a/src/core/SkTTopoSort.h
+++ b/src/core/SkTTopoSort.h
@@ -77,7 +77,7 @@
//
// TODO: potentially add a version that takes a seed node and just outputs that
// node and all the nodes on which it depends. This could be used to partially
-// flush a GrRenderTask DAG.
+// flush a GrOpList DAG.
template <typename T, typename Traits = T>
bool SkTTopoSort(SkTArray<sk_sp<T>>* graph) {
SkTArray<sk_sp<T>> result;
diff --git a/src/gpu/GrAuditTrail.cpp b/src/gpu/GrAuditTrail.cpp
index 9c72acf..609fe84 100644
--- a/src/gpu/GrAuditTrail.cpp
+++ b/src/gpu/GrAuditTrail.cpp
@@ -18,7 +18,7 @@
auditOp->fName = op->name();
auditOp->fBounds = op->bounds();
auditOp->fClientID = kGrAuditTrailInvalidID;
- auditOp->fOpsTaskID = kGrAuditTrailInvalidID;
+ auditOp->fOpListID = kGrAuditTrailInvalidID;
auditOp->fChildID = kGrAuditTrailInvalidID;
// consume the current stack trace if any
@@ -40,15 +40,15 @@
}
// Our algorithm doesn't bother to reorder inside of an OpNode so the ChildID will start at 0
- auditOp->fOpsTaskID = fOpsTask.count();
+ auditOp->fOpListID = fOpList.count();
auditOp->fChildID = 0;
// We use the op pointer as a key to find the OpNode we are 'glomming' ops onto
- fIDLookup.set(op->uniqueID(), auditOp->fOpsTaskID);
+ fIDLookup.set(op->uniqueID(), auditOp->fOpListID);
OpNode* opNode = new OpNode(proxyID);
opNode->fBounds = op->bounds();
opNode->fChildren.push_back(auditOp);
- fOpsTask.emplace_back(opNode);
+ fOpList.emplace_back(opNode);
}
void GrAuditTrail::opsCombined(const GrOp* consumer, const GrOp* consumed) {
@@ -56,22 +56,22 @@
int* indexPtr = fIDLookup.find(consumer->uniqueID());
SkASSERT(indexPtr);
int index = *indexPtr;
- SkASSERT(index < fOpsTask.count() && fOpsTask[index]);
- OpNode& consumerOp = *fOpsTask[index];
+ SkASSERT(index < fOpList.count() && fOpList[index]);
+ OpNode& consumerOp = *fOpList[index];
// Look up the op which will be glommed
int* consumedPtr = fIDLookup.find(consumed->uniqueID());
SkASSERT(consumedPtr);
int consumedIndex = *consumedPtr;
- SkASSERT(consumedIndex < fOpsTask.count() && fOpsTask[consumedIndex]);
- OpNode& consumedOp = *fOpsTask[consumedIndex];
+ SkASSERT(consumedIndex < fOpList.count() && fOpList[consumedIndex]);
+ OpNode& consumedOp = *fOpList[consumedIndex];
// steal all of consumed's ops
for (int i = 0; i < consumedOp.fChildren.count(); i++) {
Op* childOp = consumedOp.fChildren[i];
// set the ids for the child op
- childOp->fOpsTaskID = index;
+ childOp->fOpListID = index;
childOp->fChildID = consumerOp.fChildren.count();
consumerOp.fChildren.push_back(childOp);
}
@@ -79,15 +79,15 @@
// Update the bounds for the combineWith node
consumerOp.fBounds = consumer->bounds();
- // remove the old node from our opsTask and clear the combinee's lookup
+ // remove the old node from our opList and clear the combinee's lookup
// NOTE: because we can't change the shape of the oplist, we use a sentinel
- fOpsTask[consumedIndex].reset(nullptr);
+ fOpList[consumedIndex].reset(nullptr);
fIDLookup.remove(consumed->uniqueID());
}
-void GrAuditTrail::copyOutFromOpsTask(OpInfo* outOpInfo, int opsTaskID) {
- SkASSERT(opsTaskID < fOpsTask.count());
- const OpNode* bn = fOpsTask[opsTaskID].get();
+void GrAuditTrail::copyOutFromOpList(OpInfo* outOpInfo, int opListID) {
+ SkASSERT(opListID < fOpList.count());
+ const OpNode* bn = fOpList[opListID].get();
SkASSERT(bn);
outOpInfo->fBounds = bn->fBounds;
outOpInfo->fProxyUniqueID = bn->fProxyUniqueID;
@@ -105,30 +105,30 @@
// We track which oplistID we're currently looking at. If it changes, then we need to push
// back a new op info struct. We happen to know that ops are in sequential order in the
// oplist, otherwise we'd have to do more bookkeeping
- int currentOpsTaskID = kGrAuditTrailInvalidID;
+ int currentOpListID = kGrAuditTrailInvalidID;
for (int i = 0; i < (*opsLookup)->count(); i++) {
const Op* op = (**opsLookup)[i];
// Because we will copy out all of the ops associated with a given op list id everytime
// the id changes, we only have to update our struct when the id changes.
- if (kGrAuditTrailInvalidID == currentOpsTaskID || op->fOpsTaskID != currentOpsTaskID) {
+ if (kGrAuditTrailInvalidID == currentOpListID || op->fOpListID != currentOpListID) {
OpInfo& outOpInfo = outInfo->push_back();
// copy out all of the ops so the client can display them even if they have a
// different clientID
- this->copyOutFromOpsTask(&outOpInfo, op->fOpsTaskID);
+ this->copyOutFromOpList(&outOpInfo, op->fOpListID);
}
}
}
}
-void GrAuditTrail::getBoundsByOpsTaskID(OpInfo* outInfo, int opsTaskID) {
- this->copyOutFromOpsTask(outInfo, opsTaskID);
+void GrAuditTrail::getBoundsByOpListID(OpInfo* outInfo, int opListID) {
+ this->copyOutFromOpList(outInfo, opListID);
}
void GrAuditTrail::fullReset() {
SkASSERT(fEnabled);
- fOpsTask.reset();
+ fOpList.reset();
fIDLookup.reset();
// free all client ops
fClientIDLookup.foreach ([](const int&, Ops** ops) { delete *ops; });
@@ -152,7 +152,7 @@
void GrAuditTrail::toJson(SkJSONWriter& writer) const {
writer.beginObject();
- JsonifyTArray(writer, "Ops", fOpsTask);
+ JsonifyTArray(writer, "Ops", fOpList);
writer.endObject();
}
@@ -178,7 +178,7 @@
writer.beginObject();
writer.appendString("Name", fName.c_str());
writer.appendS32("ClientID", fClientID);
- writer.appendS32("OpsTaskID", fOpsTaskID);
+ writer.appendS32("OpListID", fOpListID);
writer.appendS32("ChildID", fChildID);
skrect_to_json(writer, "Bounds", fBounds);
if (fStackTrace.count()) {
diff --git a/src/gpu/GrAuditTrail.h b/src/gpu/GrAuditTrail.h
index dd6549e..74f47d3 100644
--- a/src/gpu/GrAuditTrail.h
+++ b/src/gpu/GrAuditTrail.h
@@ -51,12 +51,12 @@
GrAuditTrail* fAuditTrail;
};
- class AutoManageOpsTask {
+ class AutoManageOpList {
public:
- AutoManageOpsTask(GrAuditTrail* auditTrail)
+ AutoManageOpList(GrAuditTrail* auditTrail)
: fAutoEnable(auditTrail), fAuditTrail(auditTrail) {}
- ~AutoManageOpsTask() { fAuditTrail->fullReset(); }
+ ~AutoManageOpList() { fAuditTrail->fullReset(); }
private:
AutoEnable fAutoEnable;
@@ -116,7 +116,7 @@
};
void getBoundsByClientID(SkTArray<OpInfo>* outInfo, int clientID);
- void getBoundsByOpsTaskID(OpInfo* outInfo, int opsTaskID);
+ void getBoundsByOpListID(OpInfo* outInfo, int opListID);
void fullReset();
@@ -130,7 +130,7 @@
SkTArray<SkString> fStackTrace;
SkRect fBounds;
int fClientID;
- int fOpsTaskID;
+ int fOpListID;
int fChildID;
};
typedef SkTArray<std::unique_ptr<Op>, true> OpPool;
@@ -145,9 +145,9 @@
Ops fChildren;
const GrSurfaceProxy::UniqueID fProxyUniqueID;
};
- typedef SkTArray<std::unique_ptr<OpNode>, true> OpsTask;
+ typedef SkTArray<std::unique_ptr<OpNode>, true> OpList;
- void copyOutFromOpsTask(OpInfo* outOpInfo, int opsTask);
+ void copyOutFromOpList(OpInfo* outOpInfo, int opListID);
template <typename T>
static void JsonifyTArray(SkJSONWriter& writer, const char* name, const T& array);
@@ -155,7 +155,7 @@
OpPool fOpPool;
SkTHashMap<uint32_t, int> fIDLookup;
SkTHashMap<int, Ops*> fClientIDLookup;
- OpsTask fOpsTask;
+ OpList fOpList;
SkTArray<SkString> fCurrentStackTrace;
// The client can pass in an optional client ID which we will use to mark the ops
diff --git a/src/gpu/GrClipStackClip.cpp b/src/gpu/GrClipStackClip.cpp
index 5d862d4..07470ce 100644
--- a/src/gpu/GrClipStackClip.cpp
+++ b/src/gpu/GrClipStackClip.cpp
@@ -245,10 +245,10 @@
}
}
- // The opsTask ID must not be looked up until AFTER producing the clip mask (if any). That step
- // can cause a flush or otherwise change which opstask our draw is going into.
- uint32_t opsTaskID = renderTargetContext->getOpsTask()->uniqueID();
- if (auto clipFPs = reducedClip.finishAndDetachAnalyticFPs(ccpr, opsTaskID)) {
+ // The opList ID must not be looked up until AFTER producing the clip mask (if any). That step
+ // can cause a flush or otherwise change which opList our draw is going into.
+ uint32_t opListID = renderTargetContext->getOpList()->uniqueID();
+ if (auto clipFPs = reducedClip.finishAndDetachAnalyticFPs(ccpr, opListID)) {
out->addCoverageFP(std::move(clipFPs));
}
diff --git a/src/gpu/GrCopyRenderTask.cpp b/src/gpu/GrCopyRenderTask.cpp
index 34af9a1..6c41370 100644
--- a/src/gpu/GrCopyRenderTask.cpp
+++ b/src/gpu/GrCopyRenderTask.cpp
@@ -54,7 +54,7 @@
void GrCopyRenderTask::gatherProxyIntervals(GrResourceAllocator* alloc) const {
// This renderTask doesn't have "normal" ops. In this case we still need to add an interval (so
- // fEndOfOpsTaskOpIndices will remain in sync), so we create a fake op# to capture the fact that
+ // fEndOfOpListOpIndices will remain in sync), so we create a fake op# to capture the fact that
// we read fSrcProxy and copy to fTarget.
alloc->addInterval(fSrcProxy.get(), alloc->curOp(), alloc->curOp(),
GrResourceAllocator::ActualUse::kYes);
diff --git a/src/gpu/GrDDLContext.cpp b/src/gpu/GrDDLContext.cpp
index 4d14504..4cfdad4 100644
--- a/src/gpu/GrDDLContext.cpp
+++ b/src/gpu/GrDDLContext.cpp
@@ -52,7 +52,7 @@
return false;
}
- // DDL contexts/drawing managers always sort the oplists and attempt to reduce opsTask
+ // DDL contexts/drawing managers always sort the oplists and attempt to reduce opList
// splitting.
this->setupDrawingManager(true, true);
diff --git a/src/gpu/GrDrawingManager.cpp b/src/gpu/GrDrawingManager.cpp
index 75abb7f..3a5e750 100644
--- a/src/gpu/GrDrawingManager.cpp
+++ b/src/gpu/GrDrawingManager.cpp
@@ -95,13 +95,13 @@
return (fRenderTasks[fRenderTasks.count() - 2] = std::move(renderTask)).get();
}
-void GrDrawingManager::RenderTaskDAG::add(const SkTArray<sk_sp<GrRenderTask>>& renderTasks) {
- fRenderTasks.push_back_n(renderTasks.count(), renderTasks.begin());
+void GrDrawingManager::RenderTaskDAG::add(const SkTArray<sk_sp<GrRenderTask>>& opLists) {
+ fRenderTasks.push_back_n(opLists.count(), opLists.begin());
}
-void GrDrawingManager::RenderTaskDAG::swap(SkTArray<sk_sp<GrRenderTask>>* renderTasks) {
- SkASSERT(renderTasks->empty());
- renderTasks->swap(fRenderTasks);
+void GrDrawingManager::RenderTaskDAG::swap(SkTArray<sk_sp<GrRenderTask>>* opLists) {
+ SkASSERT(opLists->empty());
+ opLists->swap(fRenderTasks);
}
void GrDrawingManager::RenderTaskDAG::prepForFlush() {
@@ -112,18 +112,18 @@
}
#ifdef SK_DEBUG
- // This block checks for any unnecessary splits in the opsTasks. If two sequential opsTasks
- // share the same backing GrSurfaceProxy it means the opsTask was artificially split.
+ // This block checks for any unnecessary splits in the opLists. If two sequential opLists
+ // share the same backing GrSurfaceProxy it means the opList was artificially split.
if (fRenderTasks.count()) {
- GrOpsTask* prevOpsTask = fRenderTasks[0]->asOpsTask();
+ GrRenderTargetOpList* prevOpList = fRenderTasks[0]->asRenderTargetOpList();
for (int i = 1; i < fRenderTasks.count(); ++i) {
- GrOpsTask* curOpsTask = fRenderTasks[i]->asOpsTask();
+ GrRenderTargetOpList* curOpList = fRenderTasks[i]->asRenderTargetOpList();
- if (prevOpsTask && curOpsTask) {
- SkASSERT(prevOpsTask->fTarget.get() != curOpsTask->fTarget.get());
+ if (prevOpList && curOpList) {
+ SkASSERT(prevOpList->fTarget.get() != curOpList->fTarget.get());
}
- prevOpsTask = curOpsTask;
+ prevOpList = curOpList;
}
}
#endif
@@ -146,7 +146,7 @@
// no renderTask should receive a dependency
fRenderTasks[i]->makeClosed(*caps);
- // We shouldn't need to do this, but it turns out some clients still hold onto opsTasks
+ // We shouldn't need to do this, but it turns out some clients still hold onto opLists
// after a cleanup.
// MDB TODO: is this still true?
if (!fRenderTasks[i]->unique()) {
@@ -164,7 +164,7 @@
const GrPathRendererChain::Options& optionsForPathRendererChain,
const GrTextContext::Options& optionsForTextContext,
bool sortRenderTasks,
- bool reduceOpsTaskSplitting)
+ bool reduceOpListSplitting)
: fContext(context)
, fOptionsForPathRendererChain(optionsForPathRendererChain)
, fOptionsForTextContext(optionsForTextContext)
@@ -173,7 +173,7 @@
, fPathRendererChain(nullptr)
, fSoftwarePathRenderer(nullptr)
, fFlushing(false)
- , fReduceOpsTaskSplitting(reduceOpsTaskSplitting) {
+ , fReduceOpListSplitting(reduceOpListSplitting) {
}
void GrDrawingManager::cleanup() {
@@ -256,11 +256,11 @@
auto resourceCache = direct->priv().getResourceCache();
// Semi-usually the GrRenderTasks are already closed at this point, but sometimes Ganesh needs
- // to flush mid-draw. In that case, the SkGpuDevice's opsTasks won't be closed but need to be
- // flushed anyway. Closing such opsTasks here will mean new ones will be created to replace them
+ // to flush mid-draw. In that case, the SkGpuDevice's opLists won't be closed but need to be
+ // flushed anyway. Closing such opLists here will mean new ones will be created to replace them
// if the SkGpuDevice(s) write to them again.
fDAG.closeAll(fContext->priv().caps());
- fActiveOpsTask = nullptr;
+ fActiveOpList = nullptr;
fDAG.prepForFlush();
if (!fCpuBufferCache) {
@@ -286,21 +286,21 @@
onFlushCBObject->preFlush(&onFlushProvider, fFlushingRenderTaskIDs.begin(),
fFlushingRenderTaskIDs.count(), &renderTargetContexts);
for (const auto& rtc : renderTargetContexts) {
- sk_sp<GrOpsTask> onFlushOpsTask = sk_ref_sp(rtc->getOpsTask());
- if (!onFlushOpsTask) {
+ sk_sp<GrRenderTargetOpList> onFlushOpList = sk_ref_sp(rtc->getRTOpList());
+ if (!onFlushOpList) {
continue; // Odd - but not a big deal
}
#ifdef SK_DEBUG
// OnFlush callbacks are already invoked during flush, and are therefore expected to
// handle resource allocation & usage on their own. (No deferred or lazy proxies!)
- onFlushOpsTask->visitProxies_debugOnly([](GrSurfaceProxy* p, GrMipMapped) {
+ onFlushOpList->visitProxies_debugOnly([](GrSurfaceProxy* p, GrMipMapped) {
SkASSERT(!p->asTextureProxy() || !p->asTextureProxy()->texPriv().isDeferred());
SkASSERT(GrSurfaceProxy::LazyState::kNot == p->lazyInstantiationState());
});
#endif
- onFlushOpsTask->makeClosed(*fContext->priv().caps());
- onFlushOpsTask->prepare(&flushState);
- fOnFlushCBOpsTasks.push_back(std::move(onFlushOpsTask));
+ onFlushOpList->makeClosed(*fContext->priv().caps());
+ onFlushOpList->prepare(&flushState);
+ fOnFlushCBOpLists.push_back(std::move(onFlushOpList));
}
renderTargetContexts.reset();
}
@@ -323,7 +323,7 @@
if (fDAG.renderTask(i)) {
fDAG.renderTask(i)->gatherProxyIntervals(&alloc);
}
- alloc.markEndOfOpsTask(i);
+ alloc.markEndOfOpList(i);
}
alloc.determineRecyclability();
@@ -354,7 +354,7 @@
#ifdef SK_DEBUG
for (int i = 0; i < fDAG.numRenderTasks(); ++i) {
- // If there are any remaining opsTaskss at this point, make sure they will not survive the
+ // If there are any remaining opLists at this point, make sure they will not survive the
// flush. Otherwise we need to call endFlush() on them.
// http://skbug.com/7111
SkASSERT(!fDAG.renderTask(i) || fDAG.renderTask(i)->unique());
@@ -366,7 +366,7 @@
#ifdef SK_DEBUG
// In non-DDL mode this checks that all the flushed ops have been freed from the memory pool.
// When we move to partial flushes this assert will no longer be valid.
- // In DDL mode this check is somewhat superfluous since the memory for most of the ops/opsTasks
+ // In DDL mode this check is somewhat superfluous since the memory for most of the ops/opLists
// will be stored in the DDL's GrOpMemoryPools.
GrOpMemoryPool* opMemoryPool = fContext->priv().opMemoryPool();
opMemoryPool->isEmpty();
@@ -401,7 +401,7 @@
SkASSERT(startIndex <= stopIndex && stopIndex <= fDAG.numRenderTasks());
#if GR_FLUSH_TIME_OP_SPEW
- SkDebugf("Flushing opsTask: %d to %d out of [%d, %d]\n",
+ SkDebugf("Flushing opLists: %d to %d out of [%d, %d]\n",
startIndex, stopIndex, 0, fDAG.numRenderTasks());
for (int i = startIndex; i < stopIndex; ++i) {
if (fDAG.renderTask(i)) {
@@ -435,12 +435,12 @@
static constexpr int kMaxRenderTasksBeforeFlush = 100;
// Execute the onFlush op lists first, if any.
- for (sk_sp<GrOpsTask>& onFlushOpsTask : fOnFlushCBOpsTasks) {
- if (!onFlushOpsTask->execute(flushState)) {
- SkDebugf("WARNING: onFlushOpsTask failed to execute.\n");
+ for (sk_sp<GrOpList>& onFlushOpList : fOnFlushCBOpLists) {
+ if (!onFlushOpList->execute(flushState)) {
+ SkDebugf("WARNING: onFlushOpList failed to execute.\n");
}
- SkASSERT(onFlushOpsTask->unique());
- onFlushOpsTask = nullptr;
+ SkASSERT(onFlushOpList->unique());
+ onFlushOpList = nullptr;
(*numRenderTasksExecuted)++;
if (*numRenderTasksExecuted >= kMaxRenderTasksBeforeFlush) {
flushState->gpu()->finishFlush(nullptr, 0, SkSurface::BackendSurfaceAccess::kNoAccess,
@@ -448,7 +448,7 @@
*numRenderTasksExecuted = 0;
}
}
- fOnFlushCBOpsTasks.reset();
+ fOnFlushCBOpLists.reset();
// Execute the normal op lists.
for (int i = startIndex; i < stopIndex; ++i) {
@@ -547,7 +547,7 @@
// no renderTask should receive a new command after this
fDAG.closeAll(fContext->priv().caps());
- fActiveOpsTask = nullptr;
+ fActiveOpList = nullptr;
fDAG.swap(&ddl->fRenderTasks);
@@ -564,19 +564,19 @@
GrRenderTargetProxy* newDest) {
SkDEBUGCODE(this->validate());
- if (fActiveOpsTask) {
+ if (fActiveOpList) {
// This is a temporary fix for the partial-MDB world. In that world we're not
- // reordering so ops that (in the single opsTask world) would've just glommed onto the
- // end of the single opsTask but referred to a far earlier RT need to appear in their
- // own opsTask.
- fActiveOpsTask->makeClosed(*fContext->priv().caps());
- fActiveOpsTask = nullptr;
+ // reordering so ops that (in the single opList world) would've just glommed onto the
+ // end of the single opList but referred to a far earlier RT need to appear in their
+ // own opList.
+ fActiveOpList->makeClosed(*fContext->priv().caps());
+ fActiveOpList = nullptr;
}
this->addDDLTarget(newDest);
// Here we jam the proxy that backs the current replay SkSurface into the LazyProxyData.
- // The lazy proxy that references it (in the copied opsTasks) will steal its GrTexture.
+ // The lazy proxy that references it (in the copied opLists) will steal its GrTexture.
ddl->fLazyProxyData->fReplayDest = newDest;
if (ddl->fPendingPaths.size()) {
@@ -592,30 +592,30 @@
#ifdef SK_DEBUG
void GrDrawingManager::validate() const {
- if (fDAG.sortingRenderTasks() && fReduceOpsTaskSplitting) {
- SkASSERT(!fActiveOpsTask);
+ if (fDAG.sortingRenderTasks() && fReduceOpListSplitting) {
+ SkASSERT(!fActiveOpList);
} else {
- if (fActiveOpsTask) {
+ if (fActiveOpList) {
SkASSERT(!fDAG.empty());
- SkASSERT(!fActiveOpsTask->isClosed());
- SkASSERT(fActiveOpsTask == fDAG.back());
+ SkASSERT(!fActiveOpList->isClosed());
+ SkASSERT(fActiveOpList == fDAG.back());
}
for (int i = 0; i < fDAG.numRenderTasks(); ++i) {
- if (fActiveOpsTask != fDAG.renderTask(i)) {
+ if (fActiveOpList != fDAG.renderTask(i)) {
SkASSERT(fDAG.renderTask(i)->isClosed());
}
}
if (!fDAG.empty() && !fDAG.back()->isClosed()) {
- SkASSERT(fActiveOpsTask == fDAG.back());
+ SkASSERT(fActiveOpList == fDAG.back());
}
}
}
#endif
void GrDrawingManager::closeRenderTasksForNewRenderTask(GrSurfaceProxy* target) {
- if (target && fDAG.sortingRenderTasks() && fReduceOpsTaskSplitting) {
+ if (target && fDAG.sortingRenderTasks() && fReduceOpListSplitting) {
// In this case we need to close all the renderTasks that rely on the current contents of
// 'target'. That is bc we're going to update the content of the proxy so they need to be
// split in case they use both the old and new content. (This is a bit of an overkill: they
@@ -624,43 +624,46 @@
if (GrRenderTask* lastRenderTask = target->getLastRenderTask()) {
lastRenderTask->closeThoseWhoDependOnMe(*fContext->priv().caps());
}
- } else if (fActiveOpsTask) {
+ } else if (fActiveOpList) {
// This is a temporary fix for the partial-MDB world. In that world we're not
- // reordering so ops that (in the single opsTask world) would've just glommed onto the
- // end of the single opsTask but referred to a far earlier RT need to appear in their
- // own opsTask.
- fActiveOpsTask->makeClosed(*fContext->priv().caps());
- fActiveOpsTask = nullptr;
+ // reordering so ops that (in the single opList world) would've just glommed onto the
+ // end of the single opList but referred to a far earlier RT need to appear in their
+ // own opList.
+ fActiveOpList->makeClosed(*fContext->priv().caps());
+ fActiveOpList = nullptr;
}
}
-sk_sp<GrOpsTask> GrDrawingManager::newOpsTask(sk_sp<GrRenderTargetProxy> rtp, bool managedOpsTask) {
+sk_sp<GrRenderTargetOpList> GrDrawingManager::newRTOpList(sk_sp<GrRenderTargetProxy> rtp,
+ bool managedOpList) {
SkDEBUGCODE(this->validate());
SkASSERT(fContext);
this->closeRenderTasksForNewRenderTask(rtp.get());
- sk_sp<GrOpsTask> opsTask(new GrOpsTask(fContext->priv().refOpMemoryPool(), rtp,
- fContext->priv().auditTrail()));
- SkASSERT(rtp->getLastRenderTask() == opsTask.get());
+ sk_sp<GrRenderTargetOpList> opList(new GrRenderTargetOpList(
+ fContext->priv().refOpMemoryPool(),
+ rtp,
+ fContext->priv().auditTrail()));
+ SkASSERT(rtp->getLastRenderTask() == opList.get());
- if (managedOpsTask) {
- fDAG.add(opsTask);
+ if (managedOpList) {
+ fDAG.add(opList);
- if (!fDAG.sortingRenderTasks() || !fReduceOpsTaskSplitting) {
- fActiveOpsTask = opsTask.get();
+ if (!fDAG.sortingRenderTasks() || !fReduceOpListSplitting) {
+ fActiveOpList = opList.get();
}
}
SkDEBUGCODE(this->validate());
- return opsTask;
+ return opList;
}
GrRenderTask* GrDrawingManager::newTextureResolveRenderTask(
sk_sp<GrTextureProxy> textureProxy, GrTextureResolveFlags flags, const GrCaps& caps) {
- // Unlike in the "new opsTask" cases, we do not want to close the active opsTask, nor (if we are
- // in sorting and opsTask reduction mode) the render tasks that depend on the proxy's current
- // state. This is because those opsTasks can still receive new ops and because if they refer to
+ // Unlike in the "new opList" cases, we do not want to close the active opList, nor (if we are
+ // in sorting and opList reduction mode) the render tasks that depend on the proxy's current
+ // state. This is because those opLists can still receive new ops and because if they refer to
// the mipmapped version of 'textureProxy', they will then come to depend on the render task
// being created here.
// NOTE: In either case, 'textureProxy' should already be closed at this point (i.e., its state
@@ -671,8 +674,8 @@
SkASSERT(!previousTaskBeforeMipsResolve || previousTaskBeforeMipsResolve->isClosed());
SkASSERT(textureProxy->getLastRenderTask() == textureResolveTask.get());
- // Add the new textureResolveTask before the fActiveOpsTask (if not in
- // sorting/opsTask-splitting-reduction mode) because it will depend upon this resolve task.
+ // Add the new textureResolveTask before the fActiveOpList (if not in
+ // sorting/opList-splitting-reduction mode) because it will depend upon this resolve task.
// NOTE: Putting it here will also reduce the amount of work required by the topological sort.
return fDAG.addBeforeLast(std::move(textureResolveTask));
}
@@ -702,7 +705,7 @@
fDAG.add(std::move(task));
// We have closed the previous active oplist but since a new oplist isn't being added there
// shouldn't be an active one.
- SkASSERT(!fActiveOpsTask);
+ SkASSERT(!fActiveOpList);
SkDEBUGCODE(this->validate());
}
@@ -729,7 +732,7 @@
fDAG.add(std::move(task));
// We have closed the previous active oplist but since a new oplist isn't being added there
// shouldn't be an active one.
- SkASSERT(!fActiveOpsTask);
+ SkASSERT(!fActiveOpList);
SkDEBUGCODE(this->validate());
return true;
}
@@ -803,7 +806,7 @@
GrColorType colorType,
sk_sp<SkColorSpace> colorSpace,
const SkSurfaceProps* surfaceProps,
- bool managedOpsTask) {
+ bool managedOpList) {
if (this->wasAbandoned() || !sProxy->asRenderTargetProxy()) {
return nullptr;
}
@@ -823,7 +826,7 @@
colorType,
std::move(colorSpace),
surfaceProps,
- managedOpsTask));
+ managedOpList));
}
std::unique_ptr<GrTextureContext> GrDrawingManager::makeTextureContext(
diff --git a/src/gpu/GrDrawingManager.h b/src/gpu/GrDrawingManager.h
index 25b0343..6b5fc1d 100644
--- a/src/gpu/GrDrawingManager.h
+++ b/src/gpu/GrDrawingManager.h
@@ -21,10 +21,11 @@
class GrCoverageCountingPathRenderer;
class GrOnFlushCallbackObject;
class GrOpFlushState;
-class GrOpsTask;
+class GrOpList;
class GrRecordingContext;
class GrRenderTargetContext;
class GrRenderTargetProxy;
+class GrRenderTargetOpList;
class GrSoftwarePathRenderer;
class GrTextureContext;
class SkDeferredDisplayList;
@@ -39,15 +40,15 @@
GrColorType,
sk_sp<SkColorSpace>,
const SkSurfaceProps*,
- bool managedOpsTask = true);
+ bool managedOpList = true);
std::unique_ptr<GrTextureContext> makeTextureContext(sk_sp<GrSurfaceProxy>,
GrColorType,
SkAlphaType,
sk_sp<SkColorSpace>);
- // A managed opsTask is controlled by the drawing manager (i.e., sorted & flushed with the
+ // A managed opList is controlled by the drawing manager (i.e., sorted & flushed with the
// others). An unmanaged one is created and used by the onFlushCallback.
- sk_sp<GrOpsTask> newOpsTask(sk_sp<GrRenderTargetProxy>, bool managedOpsTask);
+ sk_sp<GrRenderTargetOpList> newRTOpList(sk_sp<GrRenderTargetProxy>, bool managedOpList);
// Create a new, specialized, render task that will regenerate mipmap levels and/or resolve
// MSAA (depending on GrTextureResolveFlags). This method will add the new render task to the
@@ -121,8 +122,8 @@
~RenderTaskDAG();
// Currently, when explicitly allocating resources, this call will topologically sort the
- // GrRenderTasks.
- // MDB TODO: remove once incremental GrRenderTask sorting is enabled
+ // opLists.
+ // MDB TODO: remove once incremental opList sorting is enabled
void prepForFlush();
void closeAll(const GrCaps* caps);
@@ -134,10 +135,10 @@
void reset();
- // These calls forceably remove a GrRenderTask from the DAG. They are problematic bc they
- // just remove the GrRenderTask but don't cleanup any refering pointers (i.e., dependency
- // pointers in the DAG). They work right now bc they are only called at flush time, after
- // the topological sort is complete (so the dangling pointers aren't used).
+ // These calls forceably remove an opList from the DAG. They are problematic bc they just
+ // remove the opList but don't cleanup any refering pointers (i.e., dependency pointers
+ // in the DAG). They work right now bc they are only called at flush time, after the
+ // topological sort is complete (so the dangling pointers aren't used).
void removeRenderTask(int index);
void removeRenderTasks(int startIndex, int stopIndex);
@@ -168,18 +169,18 @@
GrDrawingManager(GrRecordingContext*, const GrPathRendererChain::Options&,
const GrTextContext::Options&,
bool sortRenderTasks,
- bool reduceOpsTaskSplitting);
+ bool reduceOpListSplitting);
bool wasAbandoned() const;
void cleanup();
- // Closes the target's dependent render tasks (or, if not in sorting/opsTask-splitting-reduction
- // mode, closes fActiveOpsTask) in preparation for us opening a new opsTask that will write to
+ // Closes the target's dependent render tasks (or, if not in sorting/opList-splitting-reduction
+ // mode, closes fActiveOpList) in preparation for us opening a new opList that will write to
// 'target'.
void closeRenderTasksForNewRenderTask(GrSurfaceProxy* target);
- // return true if any GrRenderTasks were actually executed; false otherwise
+ // return true if any opLists were actually executed; false otherwise
bool executeRenderTasks(int startIndex, int stopIndex, GrOpFlushState*,
int* numRenderTasksExecuted);
@@ -208,11 +209,11 @@
sk_sp<GrBufferAllocPool::CpuBufferCache> fCpuBufferCache;
RenderTaskDAG fDAG;
- GrOpsTask* fActiveOpsTask = nullptr;
- // These are the IDs of the opsTask currently being flushed (in internalFlush)
+ GrOpList* fActiveOpList = nullptr;
+ // These are the IDs of the opLists currently being flushed (in internalFlush)
SkSTArray<8, uint32_t, true> fFlushingRenderTaskIDs;
- // These are the new opsTask generated by the onFlush CBs
- SkSTArray<8, sk_sp<GrOpsTask>> fOnFlushCBOpsTasks;
+ // These are the new opLists generated by the onFlush CBs
+ SkSTArray<8, sk_sp<GrOpList>> fOnFlushCBOpLists;
std::unique_ptr<GrTextContext> fTextContext;
@@ -221,7 +222,7 @@
GrTokenTracker fTokenTracker;
bool fFlushing;
- bool fReduceOpsTaskSplitting;
+ bool fReduceOpListSplitting;
SkTArray<GrOnFlushCallbackObject*> fOnFlushCBObjects;
diff --git a/src/gpu/GrGpu.h b/src/gpu/GrGpu.h
index 71e1557..84d9c41 100644
--- a/src/gpu/GrGpu.h
+++ b/src/gpu/GrGpu.h
@@ -289,7 +289,7 @@
GrGpuBuffer* transferBuffer, size_t offset);
// Called to perform a surface to surface copy. Fallbacks to issuing a draw from the src to dst
- // take place at higher levels and this function implement faster copy paths. The rect
+ // take place at the GrOpList level and this function implement faster copy paths. The rect
// and point are pre-clipped. The src rect and implied dst rect are guaranteed to be within the
// src/dst bounds and non-empty. They must also be in their exact device space coords, including
// already being transformed for origin if need be. If canDiscardOutsideDstRect is set to true
@@ -310,14 +310,14 @@
return fSamplePatternDictionary.retrieveSampleLocations(samplePatternKey);
}
- // Returns a GrGpuRTCommandBuffer which GrOpsTasks send draw commands to instead of directly
+ // Returns a GrGpuRTCommandBuffer which GrOpLists send draw commands to instead of directly
// to the Gpu object. The 'bounds' rect is the content rect of the destination.
virtual GrGpuRTCommandBuffer* getCommandBuffer(
GrRenderTarget*, GrSurfaceOrigin, const SkRect& bounds,
const GrGpuRTCommandBuffer::LoadAndStoreInfo&,
const GrGpuRTCommandBuffer::StencilLoadAndStoreInfo&) = 0;
- // Returns a GrGpuTextureCommandBuffer which GrOpsTasks send texture commands to instead of
+ // Returns a GrGpuTextureCommandBuffer which GrOpLists send texture commands to instead of
// directly to the Gpu object.
virtual GrGpuTextureCommandBuffer* getCommandBuffer(GrTexture*, GrSurfaceOrigin) = 0;
diff --git a/src/gpu/GrLegacyDirectContext.cpp b/src/gpu/GrLegacyDirectContext.cpp
index dbdcd5c..ffd224d 100644
--- a/src/gpu/GrLegacyDirectContext.cpp
+++ b/src/gpu/GrLegacyDirectContext.cpp
@@ -28,9 +28,9 @@
#endif
#ifdef SK_DISABLE_REDUCE_OPLIST_SPLITTING
-static const bool kDefaultReduceOpsTaskSplitting = false;
+static const bool kDefaultReduceOpListSplitting = false;
#else
-static const bool kDefaultReduceOpsTaskSplitting = false;
+static const bool kDefaultReduceOpListSplitting = false;
#endif
class GrLegacyDirectContext : public GrContext {
@@ -82,14 +82,14 @@
return false;
}
- bool reduceOpsTaskSplitting = kDefaultReduceOpsTaskSplitting;
+ bool reduceOpListSplitting = kDefaultReduceOpListSplitting;
if (GrContextOptions::Enable::kNo == this->options().fReduceOpListSplitting) {
- reduceOpsTaskSplitting = false;
+ reduceOpListSplitting = false;
} else if (GrContextOptions::Enable::kYes == this->options().fReduceOpListSplitting) {
- reduceOpsTaskSplitting = true;
+ reduceOpListSplitting = true;
}
- this->setupDrawingManager(true, reduceOpsTaskSplitting);
+ this->setupDrawingManager(true, reduceOpListSplitting);
SkASSERT(this->caps());
diff --git a/src/gpu/GrOnFlushResourceProvider.h b/src/gpu/GrOnFlushResourceProvider.h
index f26f8d3..cc36c10 100644
--- a/src/gpu/GrOnFlushResourceProvider.h
+++ b/src/gpu/GrOnFlushResourceProvider.h
@@ -15,7 +15,9 @@
#include "src/gpu/GrResourceProvider.h"
class GrDrawingManager;
+class GrOpList;
class GrOnFlushResourceProvider;
+class GrRenderTargetOpList;
class GrRenderTargetContext;
class GrSurfaceProxy;
class SkColorSpace;
@@ -31,11 +33,11 @@
/*
* The onFlush callback allows subsystems (e.g., text, path renderers) to create atlases
- * for a specific flush. All the GrOpsTask IDs required for the flush are passed into the
+ * for a specific flush. All the GrOpList IDs required for the flush are passed into the
* callback. The callback should return the render target contexts used to render the atlases
* in 'results'.
*/
- virtual void preFlush(GrOnFlushResourceProvider*, const uint32_t* opsTaskIDs, int numOpsTaskIDs,
+ virtual void preFlush(GrOnFlushResourceProvider*, const uint32_t* opListIDs, int numOpListIDs,
SkTArray<std::unique_ptr<GrRenderTargetContext>>* results) = 0;
/**
@@ -43,7 +45,7 @@
* released. startTokenForNextFlush can be used to track resources used in the current flush.
*/
virtual void postFlush(GrDeferredUploadToken startTokenForNextFlush,
- const uint32_t* opsTaskIDs, int numOpsTaskIDs) {}
+ const uint32_t* opListIDs, int numOpListIDs) {}
/**
* Tells the callback owner to hold onto this object when freeing GPU resources
diff --git a/src/gpu/GrOpFlushState.h b/src/gpu/GrOpFlushState.h
index c9178e2..fa3778b 100644
--- a/src/gpu/GrOpFlushState.h
+++ b/src/gpu/GrOpFlushState.h
@@ -23,7 +23,7 @@
class GrGpuRTCommandBuffer;
class GrResourceProvider;
-/** Tracks the state across all the GrOps (really just the GrDrawOps) in a GrOpsTask flush. */
+/** Tracks the state across all the GrOps (really just the GrDrawOps) in a GrOpList flush. */
class GrOpFlushState final : public GrDeferredUploadTarget, public GrMeshDrawOp::Target {
public:
// vertexSpace and indexSpace may either be null or an alloation of size
@@ -47,7 +47,7 @@
const GrUserStencilSettings* = &GrUserStencilSettings::kUnused);
GrGpuCommandBuffer* commandBuffer() { return fCommandBuffer; }
- // Helper function used by Ops that are only called via OpsTasks
+ // Helper function used by Ops that are only called via RenderTargetOpLists
GrGpuRTCommandBuffer* rtCommandBuffer();
void setCommandBuffer(GrGpuCommandBuffer* buffer) { fCommandBuffer = buffer; }
diff --git a/src/gpu/GrOpList.cpp b/src/gpu/GrOpList.cpp
new file mode 100644
index 0000000..2035dd5
--- /dev/null
+++ b/src/gpu/GrOpList.cpp
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "src/gpu/GrMemoryPool.h"
+#include "src/gpu/GrOpList.h"
+
+GrOpList::GrOpList(sk_sp<GrOpMemoryPool> opMemoryPool,
+ sk_sp<GrSurfaceProxy> surfaceProxy,
+ GrAuditTrail* auditTrail)
+ : GrRenderTask(std::move(surfaceProxy))
+ , fOpMemoryPool(std::move(opMemoryPool))
+ , fAuditTrail(auditTrail) {
+ SkASSERT(fOpMemoryPool);
+}
+
+GrOpList::~GrOpList() {
+}
+
+void GrOpList::endFlush() {
+ if (fTarget && this == fTarget->getLastRenderTask()) {
+ fTarget->setLastRenderTask(nullptr);
+ }
+
+ fTarget.reset();
+ fDeferredProxies.reset();
+ fAuditTrail = nullptr;
+}
diff --git a/src/gpu/GrOpList.h b/src/gpu/GrOpList.h
new file mode 100644
index 0000000..a4ee09e
--- /dev/null
+++ b/src/gpu/GrOpList.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrOpList_DEFINED
+#define GrOpList_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/private/SkColorData.h"
+#include "include/private/SkTDArray.h"
+#include "src/gpu/GrRenderTask.h"
+#include "src/gpu/GrTextureProxy.h"
+
+class GrAuditTrail;
+class GrOpMemoryPool;
+class GrGpuBuffer;
+
+class GrOpList : public GrRenderTask {
+public:
+ GrOpList(sk_sp<GrOpMemoryPool>, sk_sp<GrSurfaceProxy>, GrAuditTrail*);
+ ~GrOpList() override;
+
+ void endFlush() override;
+
+protected:
+ // This is a backpointer to the GrOpMemoryPool that holds the memory for this opLists' ops.
+ // In the DDL case, these back pointers keep the DDL's GrOpMemoryPool alive as long as its
+ // constituent opLists survive.
+ sk_sp<GrOpMemoryPool> fOpMemoryPool;
+ GrAuditTrail* fAuditTrail;
+};
+
+#endif
diff --git a/src/gpu/GrPathRenderer.h b/src/gpu/GrPathRenderer.h
index a1d0741..26f7c7f 100644
--- a/src/gpu/GrPathRenderer.h
+++ b/src/gpu/GrPathRenderer.h
@@ -28,7 +28,7 @@
class SkPath;
/**
- * Base class for drawing paths into a GrOpsTask.
+ * Base class for drawing paths into a GrOpList.
*/
class GrPathRenderer : public SkRefCnt {
public:
diff --git a/src/gpu/GrPipeline.cpp b/src/gpu/GrPipeline.cpp
index 3e5e18d..1de2199 100644
--- a/src/gpu/GrPipeline.cpp
+++ b/src/gpu/GrPipeline.cpp
@@ -11,6 +11,7 @@
#include "src/gpu/GrCaps.h"
#include "src/gpu/GrGpu.h"
#include "src/gpu/GrRenderTargetContext.h"
+#include "src/gpu/GrRenderTargetOpList.h"
#include "src/gpu/GrXferProcessor.h"
#include "src/gpu/ops/GrOp.h"
diff --git a/src/gpu/GrRecordingContext.cpp b/src/gpu/GrRecordingContext.cpp
index 9043f6a..58544ed 100644
--- a/src/gpu/GrRecordingContext.cpp
+++ b/src/gpu/GrRecordingContext.cpp
@@ -66,7 +66,7 @@
return true;
}
-void GrRecordingContext::setupDrawingManager(bool sortOpsTasks, bool reduceOpsTaskSplitting) {
+void GrRecordingContext::setupDrawingManager(bool sortOpLists, bool reduceOpListSplitting) {
GrPathRendererChain::Options prcOptions;
prcOptions.fAllowPathMaskCaching = this->options().fAllowPathMaskCaching;
#if GR_TEST_UTILS
@@ -83,7 +83,7 @@
if (!this->proxyProvider()->renderingDirectly()) {
// DDL TODO: remove this crippling of the path renderer chain
// Disable the small path renderer bc of the proxies in the atlas. They need to be
- // unified when the opsTasks are added back to the destination drawing manager.
+ // unified when the opLists are added back to the destination drawing manager.
prcOptions.fGpuPathRenderers &= ~GpuPathRenderers::kSmall;
}
@@ -100,8 +100,8 @@
fDrawingManager.reset(new GrDrawingManager(this,
prcOptions,
textContextOptions,
- sortOpsTasks,
- reduceOpsTaskSplitting));
+ sortOpLists,
+ reduceOpListSplitting));
}
void GrRecordingContext::abandonContext() {
diff --git a/src/gpu/GrReducedClip.cpp b/src/gpu/GrReducedClip.cpp
index 9224e00..e485992 100644
--- a/src/gpu/GrReducedClip.cpp
+++ b/src/gpu/GrReducedClip.cpp
@@ -656,7 +656,7 @@
if (fCCPRClipPaths.count() < fMaxCCPRClipPaths && GrAA::kYes == aa) {
// Set aside CCPR paths for later. We will create their clip FPs once we know the ID of the
- // opsTask they will operate in.
+ // opList they will operate in.
SkPath& ccprClipPath = fCCPRClipPaths.push_back(deviceSpacePath);
if (Invert::kYes == invert) {
ccprClipPath.toggleInverseFillType();
@@ -972,7 +972,7 @@
}
std::unique_ptr<GrFragmentProcessor> GrReducedClip::finishAndDetachAnalyticFPs(
- GrCoverageCountingPathRenderer* ccpr, uint32_t opsTaskID) {
+ GrCoverageCountingPathRenderer* ccpr, uint32_t opListID) {
// Make sure finishAndDetachAnalyticFPs hasn't been called already.
SkDEBUGCODE(for (const auto& fp : fAnalyticFPs) { SkASSERT(fp); })
@@ -981,7 +981,7 @@
for (const SkPath& ccprClipPath : fCCPRClipPaths) {
SkASSERT(ccpr);
SkASSERT(fHasScissor);
- auto fp = ccpr->makeClipProcessor(opsTaskID, ccprClipPath, fScissor, *fCaps);
+ auto fp = ccpr->makeClipProcessor(opListID, ccprClipPath, fScissor, *fCaps);
fAnalyticFPs.push_back(std::move(fp));
}
fCCPRClipPaths.reset();
diff --git a/src/gpu/GrReducedClip.h b/src/gpu/GrReducedClip.h
index ca95bd0..25b05df 100644
--- a/src/gpu/GrReducedClip.h
+++ b/src/gpu/GrReducedClip.h
@@ -88,16 +88,16 @@
int numAnalyticFPs() const { return fAnalyticFPs.count() + fCCPRClipPaths.count(); }
/**
- * Called once the client knows the ID of the opsTask that the clip FPs will operate in. This
- * method finishes any outstanding work that was waiting for the opsTask ID, then detaches and
+ * Called once the client knows the ID of the opList that the clip FPs will operate in. This
+ * method finishes any outstanding work that was waiting for the opList ID, then detaches and
* returns this class's list of FPs that complete the clip.
*
* NOTE: this must be called AFTER producing the clip mask (if any) because draw calls on
* the render target context, surface allocations, and even switching render targets (pre MDB)
- * may cause flushes or otherwise change which opsTask the actual draw is going into.
+ * may cause flushes or otherwise change which opList the actual draw is going into.
*/
std::unique_ptr<GrFragmentProcessor> finishAndDetachAnalyticFPs(
- GrCoverageCountingPathRenderer*, uint32_t opsTaskID);
+ GrCoverageCountingPathRenderer*, uint32_t opListID);
private:
void walkStack(const SkClipStack&, const SkRect& queryBounds);
@@ -145,7 +145,7 @@
uint32_t fMaskGenID;
bool fMaskRequiresAA;
SkSTArray<4, std::unique_ptr<GrFragmentProcessor>> fAnalyticFPs;
- SkSTArray<4, SkPath> fCCPRClipPaths; // Will convert to FPs once we have an opsTask ID for CCPR.
+ SkSTArray<4, SkPath> fCCPRClipPaths; // Will convert to FPs once we have an opList ID for CCPR.
};
#endif
diff --git a/src/gpu/GrRenderTarget.cpp b/src/gpu/GrRenderTarget.cpp
index 9f915e5..2942427 100644
--- a/src/gpu/GrRenderTarget.cpp
+++ b/src/gpu/GrRenderTarget.cpp
@@ -13,6 +13,7 @@
#include "src/gpu/GrContextPriv.h"
#include "src/gpu/GrGpu.h"
#include "src/gpu/GrRenderTargetContext.h"
+#include "src/gpu/GrRenderTargetOpList.h"
#include "src/gpu/GrRenderTargetPriv.h"
#include "src/gpu/GrSamplePatternDictionary.h"
#include "src/gpu/GrStencilAttachment.h"
diff --git a/src/gpu/GrRenderTarget.h b/src/gpu/GrRenderTarget.h
index 4e59422..7a6f44c 100644
--- a/src/gpu/GrRenderTarget.h
+++ b/src/gpu/GrRenderTarget.h
@@ -12,6 +12,7 @@
#include "include/gpu/GrSurface.h"
class GrCaps;
+class GrRenderTargetOpList;
class GrRenderTargetPriv;
class GrStencilAttachment;
class GrBackendRenderTarget;
diff --git a/src/gpu/GrRenderTargetContext.cpp b/src/gpu/GrRenderTargetContext.cpp
index 862b79c..ff9cf20 100644
--- a/src/gpu/GrRenderTargetContext.cpp
+++ b/src/gpu/GrRenderTargetContext.cpp
@@ -29,6 +29,7 @@
#include "src/gpu/GrFixedClip.h"
#include "src/gpu/GrGpuResourcePriv.h"
#include "src/gpu/GrMemoryPool.h"
+#include "src/gpu/GrOpList.h"
#include "src/gpu/GrPathRenderer.h"
#include "src/gpu/GrRecordingContextPriv.h"
#include "src/gpu/GrRenderTarget.h"
@@ -135,21 +136,21 @@
GrDrawingManager* fDrawingManager;
};
-// In MDB mode the reffing of the 'getLastOpsTask' call's result allows in-progress
-// GrOpsTask to be picked up and added to by renderTargetContexts lower in the call
-// stack. When this occurs with a closed GrOpsTask, a new one will be allocated
-// when the renderTargetContext attempts to use it (via getOpsTask).
+// In MDB mode the reffing of the 'getLastOpList' call's result allows in-progress
+// GrOpLists to be picked up and added to by renderTargetContexts lower in the call
+// stack. When this occurs with a closed GrOpList, a new one will be allocated
+// when the renderTargetContext attempts to use it (via getOpList).
GrRenderTargetContext::GrRenderTargetContext(GrRecordingContext* context,
sk_sp<GrRenderTargetProxy> rtp,
GrColorType colorType,
sk_sp<SkColorSpace> colorSpace,
const SkSurfaceProps* surfaceProps,
- bool managedOpsTask)
+ bool managedOpList)
: GrSurfaceContext(context, colorType, kPremul_SkAlphaType, std::move(colorSpace))
, fRenderTargetProxy(std::move(rtp))
- , fOpsTask(sk_ref_sp(fRenderTargetProxy->getLastOpsTask()))
+ , fOpList(sk_ref_sp(fRenderTargetProxy->getLastRenderTargetOpList()))
, fSurfaceProps(SkSurfacePropsCopyOrDefault(surfaceProps))
- , fManagedOpsTask(managedOpsTask) {
+ , fManagedOpList(managedOpList) {
fTextTarget.reset(new TextTarget(this));
SkDEBUGCODE(this->validate();)
}
@@ -159,8 +160,8 @@
SkASSERT(fRenderTargetProxy);
fRenderTargetProxy->validate(fContext);
- if (fOpsTask && !fOpsTask->isClosed()) {
- SkASSERT(fRenderTargetProxy->getLastRenderTask() == fOpsTask.get());
+ if (fOpList && !fOpList->isClosed()) {
+ SkASSERT(fRenderTargetProxy->getLastRenderTask() == fOpList.get());
}
}
#endif
@@ -200,15 +201,19 @@
return GrMipMapped::kNo;
}
-GrOpsTask* GrRenderTargetContext::getOpsTask() {
+GrRenderTargetOpList* GrRenderTargetContext::getRTOpList() {
ASSERT_SINGLE_OWNER
SkDEBUGCODE(this->validate();)
- if (!fOpsTask || fOpsTask->isClosed()) {
- fOpsTask = this->drawingManager()->newOpsTask(fRenderTargetProxy, fManagedOpsTask);
+ if (!fOpList || fOpList->isClosed()) {
+ fOpList = this->drawingManager()->newRTOpList(fRenderTargetProxy, fManagedOpList);
}
- return fOpsTask.get();
+ return fOpList.get();
+}
+
+GrOpList* GrRenderTargetContext::getOpList() {
+ return this->getRTOpList();
}
void GrRenderTargetContext::drawGlyphRunList(
@@ -239,7 +244,7 @@
AutoCheckFlush acf(this->drawingManager());
- this->getOpsTask()->discard();
+ this->getRTOpList()->discard();
}
void GrRenderTargetContext::clear(const SkIRect* rect,
@@ -295,16 +300,16 @@
}
if (isFull) {
- GrOpsTask* opsTask = this->getOpsTask();
- if (opsTask->resetForFullscreenClear(this->canDiscardPreviousOpsOnFullClear()) &&
+ GrRenderTargetOpList* opList = this->getRTOpList();
+ if (opList->resetForFullscreenClear(this->canDiscardPreviousOpsOnFullClear()) &&
!this->caps()->performColorClearsAsDraws()) {
// The op list was emptied and native clears are allowed, so just use the load op
- opsTask->setColorLoadOp(GrLoadOp::kClear, color);
+ opList->setColorLoadOp(GrLoadOp::kClear, color);
return;
} else {
// Will use an op for the clear, reset the load op to discard since the op will
// blow away the color buffer contents
- opsTask->setColorLoadOp(GrLoadOp::kDiscard);
+ opList->setColorLoadOp(GrLoadOp::kDiscard);
}
// Must add an op to the list (either because we couldn't use a load op, or because the
@@ -364,7 +369,7 @@
}
}
- // TODO: in a post-MDB world this should be handled at the OpsTask level.
+ // TODO: in a post-MDB world this should be handled at the OpList level.
// This makes sure to always add an op to the list, instead of marking the clear as a load op.
// This code follows very similar logic to internalClear() below, but critical differences are
// highlighted in line related to absClear()'s unique behavior.
@@ -389,9 +394,9 @@
}
} else {
// Reset the oplist like in internalClear(), but do not rely on a load op for the clear
- fRenderTargetContext->getOpsTask()->resetForFullscreenClear(
+ fRenderTargetContext->getRTOpList()->resetForFullscreenClear(
fRenderTargetContext->canDiscardPreviousOpsOnFullClear());
- fRenderTargetContext->getOpsTask()->setColorLoadOp(GrLoadOp::kDiscard);
+ fRenderTargetContext->getRTOpList()->setColorLoadOp(GrLoadOp::kDiscard);
if (fRenderTargetContext->caps()->performColorClearsAsDraws()) {
// This draws a quad covering the worst case dimensions instead of just the logical
@@ -784,11 +789,11 @@
*fRenderTargetContext->caps());
}
-GrOpsTask::CanDiscardPreviousOps GrRenderTargetContext::canDiscardPreviousOpsOnFullClear(
+GrRenderTargetOpList::CanDiscardPreviousOps GrRenderTargetContext::canDiscardPreviousOpsOnFullClear(
) const {
#if GR_TEST_UTILS
if (fPreserveOpsOnFullClear_TestingOnly) {
- return GrOpsTask::CanDiscardPreviousOps::kNo;
+ return GrRenderTargetOpList::CanDiscardPreviousOps::kNo;
}
#endif
// Regardless of how the clear is implemented (native clear or a fullscreen quad), all prior ops
@@ -797,7 +802,7 @@
// Although the clear will ignore the stencil buffer, following draw ops may not so we can't get
// rid of all the preceding ops. Beware! If we ever add any ops that have a side effect beyond
// modifying the stencil buffer we will need a more elaborate tracking system (skbug.com/7002).
- return GrOpsTask::CanDiscardPreviousOps(!fNumStencilSamples);
+ return GrRenderTargetOpList::CanDiscardPreviousOps(!fNumStencilSamples);
}
void GrRenderTargetContext::setNeedsStencil(bool multisampled) {
@@ -830,7 +835,7 @@
// code note when the instantiated stencil buffer is already clear and skip the clear
// altogether. And on tilers, loading the stencil buffer cleared is even faster than
// preserving the previous contents.
- this->getOpsTask()->setStencilLoadOp(GrLoadOp::kClear);
+ this->getRTOpList()->setStencilLoadOp(GrLoadOp::kClear);
}
}
}
@@ -2002,7 +2007,7 @@
kAdopt_GrWrapOwnership);
std::unique_ptr<GrOp> waitOp(GrSemaphoreOp::MakeWait(fContext, std::move(sema),
fRenderTargetProxy.get()));
- this->getOpsTask()->addWaitOp(
+ this->getRTOpList()->addWaitOp(
std::move(waitOp), GrTextureResolveManager(this->drawingManager()), *this->caps());
}
return true;
@@ -2279,7 +2284,7 @@
}
void GrRenderTargetContext::addOp(std::unique_ptr<GrOp> op) {
- this->getOpsTask()->addOp(
+ this->getRTOpList()->addOp(
std::move(op), GrTextureResolveManager(this->drawingManager()), *this->caps());
}
@@ -2335,12 +2340,12 @@
}
op->setClippedBounds(bounds);
- auto opsTask = this->getOpsTask();
+ auto opList = this->getRTOpList();
if (willAddFn) {
- willAddFn(op.get(), opsTask->uniqueID());
+ willAddFn(op.get(), opList->uniqueID());
}
- opsTask->addDrawOp(std::move(op), analysis, std::move(appliedClip), dstProxy,
- GrTextureResolveManager(this->drawingManager()), *this->caps());
+ opList->addDrawOp(std::move(op), analysis, std::move(appliedClip), dstProxy,
+ GrTextureResolveManager(this->drawingManager()), *this->caps());
}
bool GrRenderTargetContext::setupDstProxy(const GrClip& clip, const GrOp& op,
diff --git a/src/gpu/GrRenderTargetContext.h b/src/gpu/GrRenderTargetContext.h
index 10094ec..aa3281d 100644
--- a/src/gpu/GrRenderTargetContext.h
+++ b/src/gpu/GrRenderTargetContext.h
@@ -14,8 +14,8 @@
#include "include/core/SkSurface.h"
#include "include/core/SkSurfaceProps.h"
#include "include/private/GrTypesPriv.h"
-#include "src/gpu/GrOpsTask.h"
#include "src/gpu/GrPaint.h"
+#include "src/gpu/GrRenderTargetOpList.h"
#include "src/gpu/GrRenderTargetProxy.h"
#include "src/gpu/GrSurfaceContext.h"
#include "src/gpu/GrXferProcessor.h"
@@ -502,12 +502,12 @@
#if GR_TEST_UTILS
bool testingOnly_IsInstantiated() const { return fRenderTargetProxy->isInstantiated(); }
void testingOnly_SetPreserveOpsOnFullClear() { fPreserveOpsOnFullClear_TestingOnly = true; }
- GrOpsTask* testingOnly_PeekLastOpsTask() { return fOpsTask.get(); }
+ GrRenderTargetOpList* testingOnly_PeekLastOpList() { return fOpList.get(); }
#endif
protected:
GrRenderTargetContext(GrRecordingContext*, sk_sp<GrRenderTargetProxy>, GrColorType,
- sk_sp<SkColorSpace>, const SkSurfaceProps*, bool managedOpsTask = true);
+ sk_sp<SkColorSpace>, const SkSurfaceProps*, bool managedOpList = true);
SkDEBUGCODE(void validate() const override;)
@@ -518,7 +518,7 @@
GrAAType chooseAAType(GrAA);
friend class GrAtlasTextBlob; // for access to add[Mesh]DrawOp
- friend class GrClipStackClip; // for access to getOpsTask
+ friend class GrClipStackClip; // for access to getOpList
friend class GrDrawingManager; // for ctor
friend class GrRenderTargetContextPriv;
@@ -541,7 +541,7 @@
std::unique_ptr<GrFragmentProcessor>,
sk_sp<GrTextureProxy>);
- GrOpsTask::CanDiscardPreviousOps canDiscardPreviousOpsOnFullClear() const;
+ GrRenderTargetOpList::CanDiscardPreviousOps canDiscardPreviousOpsOnFullClear() const;
void setNeedsStencil(bool multisampled);
void internalClear(const GrFixedClip&, const SkPMColor4f&, CanClearFullscreen);
@@ -603,7 +603,7 @@
void addOp(std::unique_ptr<GrOp>);
// Allows caller of addDrawOp to know which op list an op will be added to.
- using WillAddOpFn = void(GrOp*, uint32_t opsTaskID);
+ using WillAddOpFn = void(GrOp*, uint32_t opListID);
// These perform processing specific to GrDrawOp-derived ops before recording them into an
// op list. Before adding the op to an op list the WillAddOpFn is called. Note that it
// will not be called in the event that the op is discarded. Moreover, the op may merge into
@@ -621,17 +621,18 @@
void asyncReadPixels(const SkIRect& rect, SkColorType colorType, ReadPixelsCallback callback,
ReadPixelsContext context);
- GrOpsTask* getOpsTask();
+ GrRenderTargetOpList* getRTOpList();
+ GrOpList* getOpList();
std::unique_ptr<GrTextTarget> fTextTarget;
sk_sp<GrRenderTargetProxy> fRenderTargetProxy;
- // In MDB-mode the GrOpsTask can be closed by some other renderTargetContext that has picked
- // it up. For this reason, the GrOpsTask should only ever be accessed via 'getOpsTask'.
- sk_sp<GrOpsTask> fOpsTask;
+ // In MDB-mode the GrOpList can be closed by some other renderTargetContext that has picked
+ // it up. For this reason, the GrOpList should only ever be accessed via 'getOpList'.
+ sk_sp<GrRenderTargetOpList> fOpList;
SkSurfaceProps fSurfaceProps;
- bool fManagedOpsTask;
+ bool fManagedOpList;
int fNumStencilSamples = 0;
#if GR_TEST_UTILS
diff --git a/src/gpu/GrRenderTargetContextPriv.h b/src/gpu/GrRenderTargetContextPriv.h
index 1440ec2..f816ea7 100644
--- a/src/gpu/GrRenderTargetContextPriv.h
+++ b/src/gpu/GrRenderTargetContextPriv.h
@@ -8,9 +8,9 @@
#ifndef GrRenderTargetContextPriv_DEFINED
#define GrRenderTargetContextPriv_DEFINED
-#include "src/gpu/GrOpsTask.h"
#include "src/gpu/GrPathRendering.h"
#include "src/gpu/GrRenderTargetContext.h"
+#include "src/gpu/GrRenderTargetOpList.h"
class GrFixedClip;
class GrHardClip;
@@ -27,20 +27,20 @@
// TODO: remove after clipping overhaul.
void setLastClip(uint32_t clipStackGenID, const SkIRect& devClipBounds,
int numClipAnalyticFPs) {
- GrOpsTask* opsTask = fRenderTargetContext->getOpsTask();
- opsTask->fLastClipStackGenID = clipStackGenID;
- opsTask->fLastDevClipBounds = devClipBounds;
- opsTask->fLastClipNumAnalyticFPs = numClipAnalyticFPs;
+ GrRenderTargetOpList* opList = fRenderTargetContext->getRTOpList();
+ opList->fLastClipStackGenID = clipStackGenID;
+ opList->fLastDevClipBounds = devClipBounds;
+ opList->fLastClipNumAnalyticFPs = numClipAnalyticFPs;
}
// called to determine if we have to render the clip into SB.
// TODO: remove after clipping overhaul.
bool mustRenderClip(uint32_t clipStackGenID, const SkIRect& devClipBounds,
int numClipAnalyticFPs) const {
- GrOpsTask* opsTask = fRenderTargetContext->getOpsTask();
- return opsTask->fLastClipStackGenID != clipStackGenID ||
- !opsTask->fLastDevClipBounds.contains(devClipBounds) ||
- opsTask->fLastClipNumAnalyticFPs != numClipAnalyticFPs;
+ GrRenderTargetOpList* opList = fRenderTargetContext->getRTOpList();
+ return opList->fLastClipStackGenID != clipStackGenID ||
+ !opList->fLastDevClipBounds.contains(devClipBounds) ||
+ opList->fLastClipNumAnalyticFPs != numClipAnalyticFPs;
}
using CanClearFullscreen = GrRenderTargetContext::CanClearFullscreen;
@@ -104,7 +104,7 @@
return fRenderTargetContext->fRenderTargetProxy->uniqueID();
}
- uint32_t testingOnly_getOpsTaskID();
+ uint32_t testingOnly_getOpListID();
using WillAddOpFn = GrRenderTargetContext::WillAddOpFn;
void testingOnly_addDrawOp(std::unique_ptr<GrDrawOp>);
diff --git a/src/gpu/GrOpsTask.cpp b/src/gpu/GrRenderTargetOpList.cpp
similarity index 87%
rename from src/gpu/GrOpsTask.cpp
rename to src/gpu/GrRenderTargetOpList.cpp
index bcf0034..2d7c2c9 100644
--- a/src/gpu/GrOpsTask.cpp
+++ b/src/gpu/GrRenderTargetOpList.cpp
@@ -1,11 +1,11 @@
/*
- * Copyright 2019 Google Inc.
+ * Copyright 2010 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
-#include "src/gpu/GrOpsTask.h"
+#include "src/gpu/GrRenderTargetOpList.h"
#include "include/private/GrRecordingContext.h"
#include "src/core/SkExchange.h"
@@ -40,14 +40,15 @@
////////////////////////////////////////////////////////////////////////////////
-inline GrOpsTask::OpChain::List::List(std::unique_ptr<GrOp> op)
+inline GrRenderTargetOpList::OpChain::List::List(std::unique_ptr<GrOp> op)
: fHead(std::move(op)), fTail(fHead.get()) {
this->validate();
}
-inline GrOpsTask::OpChain::List::List(List&& that) { *this = std::move(that); }
+inline GrRenderTargetOpList::OpChain::List::List(List&& that) { *this = std::move(that); }
-inline GrOpsTask::OpChain::List& GrOpsTask::OpChain::List::operator=(List&& that) {
+inline GrRenderTargetOpList::OpChain::List& GrRenderTargetOpList::OpChain::List::operator=(
+ List&& that) {
fHead = std::move(that.fHead);
fTail = that.fTail;
that.fTail = nullptr;
@@ -55,7 +56,7 @@
return *this;
}
-inline std::unique_ptr<GrOp> GrOpsTask::OpChain::List::popHead() {
+inline std::unique_ptr<GrOp> GrRenderTargetOpList::OpChain::List::popHead() {
SkASSERT(fHead);
auto temp = fHead->cutChain();
std::swap(temp, fHead);
@@ -66,7 +67,7 @@
return temp;
}
-inline std::unique_ptr<GrOp> GrOpsTask::OpChain::List::removeOp(GrOp* op) {
+inline std::unique_ptr<GrOp> GrRenderTargetOpList::OpChain::List::removeOp(GrOp* op) {
#ifdef SK_DEBUG
auto head = op;
while (head->prevInChain()) { head = head->prevInChain(); }
@@ -88,7 +89,7 @@
return temp;
}
-inline void GrOpsTask::OpChain::List::pushHead(std::unique_ptr<GrOp> op) {
+inline void GrRenderTargetOpList::OpChain::List::pushHead(std::unique_ptr<GrOp> op) {
SkASSERT(op);
SkASSERT(op->isChainHead());
SkASSERT(op->isChainTail());
@@ -101,13 +102,13 @@
}
}
-inline void GrOpsTask::OpChain::List::pushTail(std::unique_ptr<GrOp> op) {
+inline void GrRenderTargetOpList::OpChain::List::pushTail(std::unique_ptr<GrOp> op) {
SkASSERT(op->isChainTail());
fTail->chainConcat(std::move(op));
fTail = fTail->nextInChain();
}
-inline void GrOpsTask::OpChain::List::validate() const {
+inline void GrRenderTargetOpList::OpChain::List::validate() const {
#ifdef SK_DEBUG
if (fHead) {
SkASSERT(fTail);
@@ -118,9 +119,9 @@
////////////////////////////////////////////////////////////////////////////////
-GrOpsTask::OpChain::OpChain(std::unique_ptr<GrOp> op,
- GrProcessorSet::Analysis processorAnalysis,
- GrAppliedClip* appliedClip, const DstProxy* dstProxy)
+GrRenderTargetOpList::OpChain::OpChain(std::unique_ptr<GrOp> op,
+ GrProcessorSet::Analysis processorAnalysis,
+ GrAppliedClip* appliedClip, const DstProxy* dstProxy)
: fList{std::move(op)}
, fProcessorAnalysis(processorAnalysis)
, fAppliedClip(appliedClip) {
@@ -131,7 +132,7 @@
fBounds = fList.head()->bounds();
}
-void GrOpsTask::OpChain::visitProxies(const GrOp::VisitProxyFunc& func) const {
+void GrRenderTargetOpList::OpChain::visitProxies(const GrOp::VisitProxyFunc& func) const {
if (fList.empty()) {
return;
}
@@ -146,7 +147,7 @@
}
}
-void GrOpsTask::OpChain::deleteOps(GrOpMemoryPool* pool) {
+void GrRenderTargetOpList::OpChain::deleteOps(GrOpMemoryPool* pool) {
while (!fList.empty()) {
pool->release(fList.popHead());
}
@@ -154,7 +155,7 @@
// Concatenates two op chains and attempts to merge ops across the chains. Assumes that we know that
// the two chains are chainable. Returns the new chain.
-GrOpsTask::OpChain::List GrOpsTask::OpChain::DoConcat(
+GrRenderTargetOpList::OpChain::List GrRenderTargetOpList::OpChain::DoConcat(
List chainA, List chainB, const GrCaps& caps, GrOpMemoryPool* pool,
GrAuditTrail* auditTrail) {
// We process ops in chain b from head to tail. We attempt to merge with nodes in a, starting
@@ -230,7 +231,7 @@
// Attempts to concatenate the given chain onto our own and merge ops across the chains. Returns
// whether the operation succeeded. On success, the provided list will be returned empty.
-bool GrOpsTask::OpChain::tryConcat(
+bool GrRenderTargetOpList::OpChain::tryConcat(
List* list, GrProcessorSet::Analysis processorAnalysis, const DstProxy& dstProxy,
const GrAppliedClip* appliedClip, const SkRect& bounds, const GrCaps& caps,
GrOpMemoryPool* pool, GrAuditTrail* auditTrail) {
@@ -288,8 +289,8 @@
return true;
}
-bool GrOpsTask::OpChain::prependChain(OpChain* that, const GrCaps& caps, GrOpMemoryPool* pool,
- GrAuditTrail* auditTrail) {
+bool GrRenderTargetOpList::OpChain::prependChain(OpChain* that, const GrCaps& caps,
+ GrOpMemoryPool* pool, GrAuditTrail* auditTrail) {
if (!that->tryConcat(
&fList, fProcessorAnalysis, fDstProxy, fAppliedClip, fBounds, caps, pool, auditTrail)) {
this->validate();
@@ -312,7 +313,7 @@
return true;
}
-std::unique_ptr<GrOp> GrOpsTask::OpChain::appendOp(
+std::unique_ptr<GrOp> GrRenderTargetOpList::OpChain::appendOp(
std::unique_ptr<GrOp> op, GrProcessorSet::Analysis processorAnalysis,
const DstProxy* dstProxy, const GrAppliedClip* appliedClip, const GrCaps& caps,
GrOpMemoryPool* pool, GrAuditTrail* auditTrail) {
@@ -335,7 +336,7 @@
return nullptr;
}
-inline void GrOpsTask::OpChain::validate() const {
+inline void GrRenderTargetOpList::OpChain::validate() const {
#ifdef SK_DEBUG
fList.validate();
for (const auto& op : GrOp::ChainRange<>(fList.head())) {
@@ -348,46 +349,71 @@
////////////////////////////////////////////////////////////////////////////////
-GrOpsTask::GrOpsTask(sk_sp<GrOpMemoryPool> opMemoryPool,
- sk_sp<GrRenderTargetProxy> rtProxy,
- GrAuditTrail* auditTrail)
- : GrRenderTask(std::move(rtProxy))
- , fOpMemoryPool(std::move(opMemoryPool))
- , fAuditTrail(auditTrail)
+GrRenderTargetOpList::GrRenderTargetOpList(sk_sp<GrOpMemoryPool> opMemoryPool,
+ sk_sp<GrRenderTargetProxy> proxy,
+ GrAuditTrail* auditTrail)
+ : INHERITED(std::move(opMemoryPool), std::move(proxy), auditTrail)
, fLastClipStackGenID(SK_InvalidUniqueID)
SkDEBUGCODE(, fNumClips(0)) {
- SkASSERT(fOpMemoryPool);
fTarget->setLastRenderTask(this);
}
-void GrOpsTask::deleteOps() {
+void GrRenderTargetOpList::deleteOps() {
for (auto& chain : fOpChains) {
chain.deleteOps(fOpMemoryPool.get());
}
fOpChains.reset();
}
-GrOpsTask::~GrOpsTask() {
+GrRenderTargetOpList::~GrRenderTargetOpList() {
this->deleteOps();
}
////////////////////////////////////////////////////////////////////////////////
-void GrOpsTask::endFlush() {
- fLastClipStackGenID = SK_InvalidUniqueID;
- this->deleteOps();
- fClipAllocator.reset();
-
- if (fTarget && this == fTarget->getLastRenderTask()) {
- fTarget->setLastRenderTask(nullptr);
- }
-
- fTarget.reset();
- fDeferredProxies.reset();
- fAuditTrail = nullptr;
+#ifdef SK_DEBUG
+static const char* load_op_to_name(GrLoadOp op) {
+ return GrLoadOp::kLoad == op ? "load" : GrLoadOp::kClear == op ? "clear" : "discard";
}
-void GrOpsTask::onPrepare(GrOpFlushState* flushState) {
+void GrRenderTargetOpList::dump(bool printDependencies) const {
+ INHERITED::dump(printDependencies);
+
+ SkDebugf("ColorLoadOp: %s %x StencilLoadOp: %s\n",
+ load_op_to_name(fColorLoadOp),
+ GrLoadOp::kClear == fColorLoadOp ? fLoadClearColor.toBytes_RGBA() : 0x0,
+ load_op_to_name(fStencilLoadOp));
+
+ SkDebugf("ops (%d):\n", fOpChains.count());
+ for (int i = 0; i < fOpChains.count(); ++i) {
+ SkDebugf("*******************************\n");
+ if (!fOpChains[i].head()) {
+ SkDebugf("%d: <combined forward or failed instantiation>\n", i);
+ } else {
+ SkDebugf("%d: %s\n", i, fOpChains[i].head()->name());
+ SkRect bounds = fOpChains[i].bounds();
+ SkDebugf("ClippedBounds: [L: %.2f, T: %.2f, R: %.2f, B: %.2f]\n", bounds.fLeft,
+ bounds.fTop, bounds.fRight, bounds.fBottom);
+ for (const auto& op : GrOp::ChainRange<>(fOpChains[i].head())) {
+ SkString info = SkTabString(op.dumpInfo(), 1);
+ SkDebugf("%s\n", info.c_str());
+ bounds = op.bounds();
+ SkDebugf("\tClippedBounds: [L: %.2f, T: %.2f, R: %.2f, B: %.2f]\n", bounds.fLeft,
+ bounds.fTop, bounds.fRight, bounds.fBottom);
+ }
+ }
+ }
+}
+
+void GrRenderTargetOpList::visitProxies_debugOnly(const GrOp::VisitProxyFunc& func) const {
+ for (const OpChain& chain : fOpChains) {
+ chain.visitProxies(func);
+ }
+}
+
+#endif
+
+void GrRenderTargetOpList::onPrepare(GrOpFlushState* flushState) {
SkASSERT(fTarget->peekRenderTarget());
SkASSERT(this->isClosed());
#ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
@@ -429,7 +455,7 @@
// TODO:
// We would like to (at this level) only ever clear & discard. We would need
- // to stop splitting up higher level OpsTasks for copyOps to achieve that.
+ // to stop splitting up higher level opLists for copyOps to achieve that.
// Note: we would still need SB loads and stores but they would happen at a
// lower level (inside the VK command buffer).
const GrGpuRTCommandBuffer::StencilLoadAndStoreInfo stencilLoadAndStoreInfo {
@@ -443,7 +469,7 @@
// TODO: this is where GrOp::renderTarget is used (which is fine since it
// is at flush time). However, we need to store the RenderTargetProxy in the
// Ops and instantiate them here.
-bool GrOpsTask::onExecute(GrOpFlushState* flushState) {
+bool GrRenderTargetOpList::onExecute(GrOpFlushState* flushState) {
if (this->isNoOp()) {
return false;
}
@@ -499,15 +525,31 @@
return true;
}
-void GrOpsTask::setColorLoadOp(GrLoadOp op, const SkPMColor4f& color) {
+void GrRenderTargetOpList::endFlush() {
+ fLastClipStackGenID = SK_InvalidUniqueID;
+ this->deleteOps();
+ fClipAllocator.reset();
+ INHERITED::endFlush();
+}
+
+void GrRenderTargetOpList::discard() {
+ // Discard calls to in-progress opLists are ignored. Calls at the start update the
+ // opLists' color & stencil load ops.
+ if (this->isEmpty()) {
+ fColorLoadOp = GrLoadOp::kDiscard;
+ fStencilLoadOp = GrLoadOp::kDiscard;
+ }
+}
+
+void GrRenderTargetOpList::setColorLoadOp(GrLoadOp op, const SkPMColor4f& color) {
fColorLoadOp = op;
fLoadClearColor = color;
}
-bool GrOpsTask::resetForFullscreenClear(CanDiscardPreviousOps canDiscardPreviousOps) {
+bool GrRenderTargetOpList::resetForFullscreenClear(CanDiscardPreviousOps canDiscardPreviousOps) {
// Mark the color load op as discard (this may be followed by a clearColorOnLoad call to make
// the load op kClear, or it may be followed by an explicit op). In the event of an absClear()
- // after a regular clear(), we could end up with a clear load op and a real clear op in the task
+ // after a regular clear(), we could end up with a clear load op and a real clear op in the list
// if the load op were not reset here.
fColorLoadOp = GrLoadOp::kDiscard;
@@ -521,87 +563,19 @@
this->deleteOps();
fDeferredProxies.reset();
- // If the opsTask is using a render target which wraps a vulkan command buffer, we can't do
- // a clear load since we cannot change the render pass that we are using. Thus we fall back
- // to making a clear op in this case.
+ // If the opList is using a render target which wraps a vulkan command buffer, we can't do a
+ // clear load since we cannot change the render pass that we are using. Thus we fall back to
+ // making a clear op in this case.
return !fTarget->asRenderTargetProxy()->wrapsVkSecondaryCB();
}
- // Could not empty the task, so an op must be added to handle the clear
+ // Could not empty the list, so an op must be added to handle the clear
return false;
}
-void GrOpsTask::discard() {
- // Discard calls to in-progress opsTasks are ignored. Calls at the start update the
- // opsTasks' color & stencil load ops.
- if (this->isEmpty()) {
- fColorLoadOp = GrLoadOp::kDiscard;
- fStencilLoadOp = GrLoadOp::kDiscard;
- }
-}
-
////////////////////////////////////////////////////////////////////////////////
-#ifdef SK_DEBUG
-static const char* load_op_to_name(GrLoadOp op) {
- return GrLoadOp::kLoad == op ? "load" : GrLoadOp::kClear == op ? "clear" : "discard";
-}
-
-void GrOpsTask::dump(bool printDependencies) const {
- GrRenderTask::dump(printDependencies);
-
- SkDebugf("ColorLoadOp: %s %x StencilLoadOp: %s\n",
- load_op_to_name(fColorLoadOp),
- GrLoadOp::kClear == fColorLoadOp ? fLoadClearColor.toBytes_RGBA() : 0x0,
- load_op_to_name(fStencilLoadOp));
-
- SkDebugf("ops (%d):\n", fOpChains.count());
- for (int i = 0; i < fOpChains.count(); ++i) {
- SkDebugf("*******************************\n");
- if (!fOpChains[i].head()) {
- SkDebugf("%d: <combined forward or failed instantiation>\n", i);
- } else {
- SkDebugf("%d: %s\n", i, fOpChains[i].head()->name());
- SkRect bounds = fOpChains[i].bounds();
- SkDebugf("ClippedBounds: [L: %.2f, T: %.2f, R: %.2f, B: %.2f]\n", bounds.fLeft,
- bounds.fTop, bounds.fRight, bounds.fBottom);
- for (const auto& op : GrOp::ChainRange<>(fOpChains[i].head())) {
- SkString info = SkTabString(op.dumpInfo(), 1);
- SkDebugf("%s\n", info.c_str());
- bounds = op.bounds();
- SkDebugf("\tClippedBounds: [L: %.2f, T: %.2f, R: %.2f, B: %.2f]\n", bounds.fLeft,
- bounds.fTop, bounds.fRight, bounds.fBottom);
- }
- }
- }
-}
-
-void GrOpsTask::visitProxies_debugOnly(const GrOp::VisitProxyFunc& func) const {
- for (const OpChain& chain : fOpChains) {
- chain.visitProxies(func);
- }
-}
-
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-
-bool GrOpsTask::onIsUsed(GrSurfaceProxy* proxyToCheck) const {
- bool used = false;
-
- auto visit = [ proxyToCheck, &used ] (GrSurfaceProxy* p, GrMipMapped) {
- if (p == proxyToCheck) {
- used = true;
- }
- };
- for (const OpChain& recordedOp : fOpChains) {
- recordedOp.visitProxies(visit);
- }
-
- return used;
-}
-
-void GrOpsTask::handleInternalAllocationFailure() {
+void GrRenderTargetOpList::handleInternalAllocationFailure() {
bool hasUninstantiatedProxy = false;
auto checkInstantiation = [&hasUninstantiatedProxy](GrSurfaceProxy* p, GrMipMapped) {
if (!p->isInstantiated()) {
@@ -618,7 +592,23 @@
}
}
-void GrOpsTask::gatherProxyIntervals(GrResourceAllocator* alloc) const {
+bool GrRenderTargetOpList::onIsUsed(GrSurfaceProxy* proxyToCheck) const {
+ bool used = false;
+
+ auto visit = [ proxyToCheck, &used ] (GrSurfaceProxy* p, GrMipMapped) {
+ if (p == proxyToCheck) {
+ used = true;
+ }
+ };
+ for (const OpChain& recordedOp : fOpChains) {
+ recordedOp.visitProxies(visit);
+ }
+
+ return used;
+}
+
+void GrRenderTargetOpList::gatherProxyIntervals(GrResourceAllocator* alloc) const {
+
for (int i = 0; i < fDeferredProxies.count(); ++i) {
SkASSERT(!fDeferredProxies[i]->isInstantiated());
// We give all the deferred proxies a write usage at the very start of flushing. This
@@ -629,7 +619,7 @@
alloc->addInterval(fDeferredProxies[i], 0, 0, GrResourceAllocator::ActualUse::kNo);
}
- // Add the interval for all the writes to this GrOpsTasks's target
+ // Add the interval for all the writes to this opList's target
if (fOpChains.count()) {
unsigned int cur = alloc->curOp();
@@ -657,14 +647,14 @@
}
}
-void GrOpsTask::recordOp(
+void GrRenderTargetOpList::recordOp(
std::unique_ptr<GrOp> op, GrProcessorSet::Analysis processorAnalysis, GrAppliedClip* clip,
const DstProxy* dstProxy, const GrCaps& caps) {
SkDEBUGCODE(op->validate();)
SkASSERT(processorAnalysis.requiresDstTexture() == (dstProxy && dstProxy->proxy()));
SkASSERT(fTarget);
- // A closed GrOpsTask should never receive new/more ops
+ // A closed GrOpList should never receive new/more ops
SkASSERT(!this->isClosed());
if (!op->bounds().isFinite()) {
fOpMemoryPool->release(std::move(op));
@@ -676,7 +666,7 @@
// 2) intersect with something
// 3) find a 'blocker'
GR_AUDIT_TRAIL_ADD_OP(fAuditTrail, op.get(), fTarget->uniqueID());
- GrOP_INFO("opsTask: %d Recording (%s, opID: %u)\n"
+ GrOP_INFO("opList: %d Recording (%s, opID: %u)\n"
"\tBounds [L: %.2f, T: %.2f R: %.2f B: %.2f]\n",
this->uniqueID(),
op->name(),
@@ -716,9 +706,9 @@
fOpChains.emplace_back(std::move(op), processorAnalysis, clip, dstProxy);
}
-void GrOpsTask::forwardCombine(const GrCaps& caps) {
+void GrRenderTargetOpList::forwardCombine(const GrCaps& caps) {
SkASSERT(!this->isClosed());
- GrOP_INFO("opsTask: %d ForwardCombine %d ops:\n", this->uniqueID(), fOpChains.count());
+ GrOP_INFO("opList: %d ForwardCombine %d ops:\n", this->uniqueID(), fOpChains.count());
for (int i = 0; i < fOpChains.count() - 1; ++i) {
OpChain& chain = fOpChains[i];
diff --git a/src/gpu/GrOpsTask.h b/src/gpu/GrRenderTargetOpList.h
similarity index 86%
rename from src/gpu/GrOpsTask.h
rename to src/gpu/GrRenderTargetOpList.h
index a89b22c..fc675e3 100644
--- a/src/gpu/GrOpsTask.h
+++ b/src/gpu/GrRenderTargetOpList.h
@@ -1,47 +1,41 @@
/*
- * Copyright 2019 Google Inc.
+ * Copyright 2010 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
-#ifndef GrOpsTask_DEFINED
-#define GrOpsTask_DEFINED
+#ifndef GrRenderTargetOpList_DEFINED
+#define GrRenderTargetOpList_DEFINED
#include "include/core/SkMatrix.h"
-#include "include/core/SkRefCnt.h"
#include "include/core/SkStrokeRec.h"
#include "include/core/SkTypes.h"
-#include "include/private/SkColorData.h"
#include "include/private/SkTArray.h"
-#include "include/private/SkTDArray.h"
#include "src/core/SkArenaAlloc.h"
#include "src/core/SkClipStack.h"
#include "src/core/SkStringUtils.h"
#include "src/core/SkTLazy.h"
#include "src/gpu/GrAppliedClip.h"
+#include "src/gpu/GrOpList.h"
#include "src/gpu/GrPathRendering.h"
#include "src/gpu/GrPrimitiveProcessor.h"
-#include "src/gpu/GrRenderTask.h"
#include "src/gpu/ops/GrDrawOp.h"
#include "src/gpu/ops/GrOp.h"
class GrAuditTrail;
-class GrCaps;
class GrClearOp;
-class GrGpuBuffer;
-class GrOpMemoryPool;
+class GrCaps;
class GrRenderTargetProxy;
-class GrOpsTask : public GrRenderTask {
+class GrRenderTargetOpList final : public GrOpList {
private:
using DstProxy = GrXferProcessor::DstProxy;
public:
- GrOpsTask(sk_sp<GrOpMemoryPool>, sk_sp<GrRenderTargetProxy>, GrAuditTrail*);
- ~GrOpsTask() override;
+ GrRenderTargetOpList(sk_sp<GrOpMemoryPool>, sk_sp<GrRenderTargetProxy>, GrAuditTrail*);
- GrOpsTask* asOpsTask() override { return this; }
+ ~GrRenderTargetOpList() override;
bool isEmpty() const { return fOpChains.empty(); }
@@ -95,13 +89,23 @@
void discard();
+ GrRenderTargetOpList* asRenderTargetOpList() override { return this; }
+
SkDEBUGCODE(void dump(bool printDependencies) const override;)
SkDEBUGCODE(int numClips() const override { return fNumClips; })
SkDEBUGCODE(void visitProxies_debugOnly(const GrOp::VisitProxyFunc&) const;)
private:
+ friend class GrRenderTargetContextPriv; // for stencil clip state. TODO: this is invasive
+
+ // The RTC and RTOpList have to work together to handle buffer clears. In most cases, buffer
+ // clearing can be done natively, in which case the op list's load ops are sufficient. In other
+ // cases, draw ops must be used, which makes the RTC the best place for those decisions. This,
+ // however, requires that the RTC be able to coordinate with the op list to achieve similar ends
+ friend class GrRenderTargetContext;
+
bool isNoOp() const {
- // TODO: GrLoadOp::kDiscard -> [empty OpsTask] -> GrStoreOp::kStore should also be a no-op.
+ // TODO: GrLoadOp::kDiscard -> [empty opList] -> GrStoreOp::kStore should also be a no-op.
// We don't count it as a no-op right now because of Vulkan. There are real cases where we
// store a discard, and if we skip that render pass, then the next time we load the render
// target, Vulkan detects loading of uninitialized memory and complains. If we don't skip
@@ -114,7 +118,7 @@
GrLoadOp::kDiscard != fColorLoadOp;
}
- void deleteOps();
+ bool onIsUsed(GrSurfaceProxy*) const override;
// Must only be called if native stencil buffer clearing is enabled
void setStencilLoadOp(GrLoadOp op) { fStencilLoadOp = op; }
@@ -136,6 +140,8 @@
// Returns true if the clear can be converted into a load op (barring device caps).
bool resetForFullscreenClear(CanDiscardPreviousOps);
+ void deleteOps();
+
class OpChain {
public:
OpChain(const OpChain&) = delete;
@@ -207,9 +213,6 @@
SkRect fBounds;
};
-
- bool onIsUsed(GrSurfaceProxy*) const override;
-
void handleInternalAllocationFailure() override;
void gatherProxyIntervals(GrResourceAllocator*) const override;
@@ -224,39 +227,26 @@
return (this->isNoOp()) ? ExpectedOutcome::kTargetUnchanged : ExpectedOutcome::kTargetDirty;
}
- friend class GrRenderTargetContextPriv; // for stencil clip state. TODO: this is invasive
+ GrLoadOp fColorLoadOp = GrLoadOp::kLoad;
+ SkPMColor4f fLoadClearColor = SK_PMColor4fTRANSPARENT;
+ GrLoadOp fStencilLoadOp = GrLoadOp::kLoad;
- // The RTC and OpsTask have to work together to handle buffer clears. In most cases, buffer
- // clearing can be done natively, in which case the op list's load ops are sufficient. In other
- // cases, draw ops must be used, which makes the RTC the best place for those decisions. This,
- // however, requires that the RTC be able to coordinate with the op list to achieve similar ends
- friend class GrRenderTargetContext;
-
- // This is a backpointer to the GrOpMemoryPool that holds the memory for this GrOpsTask's ops.
- // In the DDL case, these back pointers keep the DDL's GrOpMemoryPool alive as long as its
- // constituent GrOpsTask survives.
- sk_sp<GrOpMemoryPool> fOpMemoryPool;
- GrAuditTrail* fAuditTrail;
-
- GrLoadOp fColorLoadOp = GrLoadOp::kLoad;
- SkPMColor4f fLoadClearColor = SK_PMColor4fTRANSPARENT;
- GrLoadOp fStencilLoadOp = GrLoadOp::kLoad;
-
- uint32_t fLastClipStackGenID;
- SkIRect fLastDevClipBounds;
- int fLastClipNumAnalyticFPs;
+ uint32_t fLastClipStackGenID;
+ SkIRect fLastDevClipBounds;
+ int fLastClipNumAnalyticFPs;
// We must track if we have a wait op so that we don't delete the op when we have a full clear.
bool fHasWaitOp = false;;
- // For ops/opsTask we have mean: 5 stdDev: 28
- SkSTArray<25, OpChain, true> fOpChains;
+ // For ops/opList we have mean: 5 stdDev: 28
+ SkSTArray<25, OpChain, true> fOpChains;
// MDB TODO: 4096 for the first allocation of the clip space will be huge overkill.
// Gather statistics to determine the correct size.
- SkArenaAlloc fClipAllocator{4096};
- SkDEBUGCODE(int fNumClips;)
+ SkArenaAlloc fClipAllocator{4096};
+ SkDEBUGCODE(int fNumClips;)
+ typedef GrOpList INHERITED;
};
#endif
diff --git a/src/gpu/GrRenderTargetProxy.cpp b/src/gpu/GrRenderTargetProxy.cpp
index 8faa0a4..6d831fa 100644
--- a/src/gpu/GrRenderTargetProxy.cpp
+++ b/src/gpu/GrRenderTargetProxy.cpp
@@ -12,7 +12,7 @@
#include "src/gpu/GrCaps.h"
#include "src/gpu/GrContextPriv.h"
#include "src/gpu/GrGpuResourcePriv.h"
-#include "src/gpu/GrOpsTask.h"
+#include "src/gpu/GrRenderTargetOpList.h"
#include "src/gpu/GrRenderTargetPriv.h"
#include "src/gpu/GrResourceProvider.h"
#include "src/gpu/GrSurfacePriv.h"
diff --git a/src/gpu/GrRenderTask.cpp b/src/gpu/GrRenderTask.cpp
index 639f4cf..0d54208 100644
--- a/src/gpu/GrRenderTask.cpp
+++ b/src/gpu/GrRenderTask.cpp
@@ -119,7 +119,7 @@
// Does this proxy have mipmaps that need to be regenerated?
if (GrMipMapped::kYes == mipMapped && textureProxy->mipMapsAreDirty()) {
- // Create a renderTask that resolves the texture's mipmap data.
+ // Create an opList that resolves the texture's mipmap data.
GrRenderTask* textureResolveTask = textureResolveManager.newTextureResolveRenderTask(
sk_ref_sp(textureProxy), GrTextureResolveFlags::kMipMaps, caps);
@@ -130,7 +130,7 @@
textureResolveTask->fDeferredProxies.back() == textureProxy);
// The GrTextureResolveRenderTask factory should have also marked the mipmaps clean, set the
- // last renderTask on the textureProxy to textureResolveTask, and closed textureResolveTask.
+ // last opList on the textureProxy to textureResolveTask, and closed textureResolveTask.
SkASSERT(!textureProxy->mipMapsAreDirty());
SkASSERT(textureProxy->getLastRenderTask() == textureResolveTask);
SkASSERT(textureResolveTask->isClosed());
diff --git a/src/gpu/GrRenderTask.h b/src/gpu/GrRenderTask.h
index f13a0de..7b2c776 100644
--- a/src/gpu/GrRenderTask.h
+++ b/src/gpu/GrRenderTask.h
@@ -15,12 +15,13 @@
#include "src/gpu/GrTextureResolveManager.h"
class GrOpFlushState;
-class GrOpsTask;
+class GrOpList;
+class GrRenderTargetOpList;
class GrResourceAllocator;
// This class abstracts a task that targets a single GrSurfaceProxy, participates in the
// GrDrawingManager's DAG, and implements the onExecute method to modify its target proxy's
-// contents. (e.g., an opsTask that executes a command buffer, a task to regenerate mipmaps, etc.)
+// contents. (e.g., an opList that executes a command buffer, a task to regenerate mipmaps, etc.)
class GrRenderTask : public SkRefCnt {
public:
GrRenderTask(sk_sp<GrSurfaceProxy> target);
@@ -53,9 +54,9 @@
uint32_t uniqueID() const { return fUniqueID; }
/*
- * Safely cast this GrRenderTask to a GrOpsTask (if possible).
+ * Safely cast this GrRenderTask to a GrRenderTargetOpList (if possible).
*/
- virtual GrOpsTask* asOpsTask() { return nullptr; }
+ virtual GrRenderTargetOpList* asRenderTargetOpList() { return nullptr; }
/*
* Dump out the GrRenderTask dependency DAG
@@ -164,9 +165,9 @@
const uint32_t fUniqueID;
uint32_t fFlags;
- // 'this' GrRenderTask relies on the output of the GrRenderTasks in 'fDependencies'
+ // 'this' GrOpList relies on the output of the GrOpLists in 'fDependencies'
SkSTArray<1, GrRenderTask*, true> fDependencies;
- // 'this' GrRenderTask's output is relied on by the GrRenderTasks in 'fDependents'
+ // 'this' GrOpList's output is relied on by the GrOpLists in 'fDependents'
SkSTArray<1, GrRenderTask*, true> fDependents;
};
diff --git a/src/gpu/GrResourceAllocator.cpp b/src/gpu/GrResourceAllocator.cpp
index ecc9a42..f73f5be 100644
--- a/src/gpu/GrResourceAllocator.cpp
+++ b/src/gpu/GrResourceAllocator.cpp
@@ -9,7 +9,7 @@
#include "src/gpu/GrDeinstantiateProxyTracker.h"
#include "src/gpu/GrGpuResourcePriv.h"
-#include "src/gpu/GrOpsTask.h"
+#include "src/gpu/GrOpList.h"
#include "src/gpu/GrRenderTargetProxy.h"
#include "src/gpu/GrResourceCache.h"
#include "src/gpu/GrResourceProvider.h"
@@ -53,17 +53,16 @@
}
}
-void GrResourceAllocator::markEndOfOpsTask(int opsTaskIndex) {
- SkASSERT(!fAssigned); // We shouldn't be adding any opsTasks after (or during) assignment
+void GrResourceAllocator::markEndOfOpList(int opListIndex) {
+ SkASSERT(!fAssigned); // We shouldn't be adding any opLists after (or during) assignment
- SkASSERT(fEndOfOpsTaskOpIndices.count() == opsTaskIndex);
- if (!fEndOfOpsTaskOpIndices.empty()) {
- SkASSERT(fEndOfOpsTaskOpIndices.back() < this->curOp());
+ SkASSERT(fEndOfOpListOpIndices.count() == opListIndex);
+ if (!fEndOfOpListOpIndices.empty()) {
+ SkASSERT(fEndOfOpListOpIndices.back() < this->curOp());
}
- // This is the first op index of the next opsTask
- fEndOfOpsTaskOpIndices.push_back(this->curOp());
- SkASSERT(fEndOfOpsTaskOpIndices.count() <= fNumOpsTasks);
+ fEndOfOpListOpIndices.push_back(this->curOp()); // This is the first op index of the next opList
+ SkASSERT(fEndOfOpListOpIndices.count() <= fNumOpLists);
}
GrResourceAllocator::~GrResourceAllocator() {
@@ -114,7 +113,7 @@
if (0 == start && 0 == end) {
// This interval is for the initial upload to a deferred proxy. Due to the vagaries
// of how deferred proxies are collected they can appear as uploads multiple times
- // in a single opsTasks' list and as uploads in several opsTasks.
+ // in a single opLists' list and as uploads in several opLists.
SkASSERT(0 == intvl->start());
} else if (isDirectDstRead) {
// Direct reads from the render target itself should occur w/in the existing
@@ -353,30 +352,30 @@
}
}
-bool GrResourceAllocator::onOpsTaskBoundary() const {
+bool GrResourceAllocator::onOpListBoundary() const {
if (fIntvlList.empty()) {
- SkASSERT(fCurOpsTaskIndex+1 <= fNumOpsTasks);
- // Although technically on an opsTask boundary there is no need to force an
+ SkASSERT(fCurOpListIndex+1 <= fNumOpLists);
+ // Although technically on an opList boundary there is no need to force an
// intermediate flush here
return false;
}
const Interval* tmp = fIntvlList.peekHead();
- return fEndOfOpsTaskOpIndices[fCurOpsTaskIndex] <= tmp->start();
+ return fEndOfOpListOpIndices[fCurOpListIndex] <= tmp->start();
}
void GrResourceAllocator::forceIntermediateFlush(int* stopIndex) {
- *stopIndex = fCurOpsTaskIndex+1;
+ *stopIndex = fCurOpListIndex+1;
// This is interrupting the allocation of resources for this flush. We need to
// proactively clear the active interval list of any intervals that aren't
// guaranteed to survive the partial flush lest they become zombies (i.e.,
// holding a deleted surface proxy).
const Interval* tmp = fIntvlList.peekHead();
- SkASSERT(fEndOfOpsTaskOpIndices[fCurOpsTaskIndex] <= tmp->start());
+ SkASSERT(fEndOfOpListOpIndices[fCurOpListIndex] <= tmp->start());
- fCurOpsTaskIndex++;
- SkASSERT(fCurOpsTaskIndex < fNumOpsTasks);
+ fCurOpListIndex++;
+ SkASSERT(fCurOpListIndex < fNumOpLists);
this->expire(tmp->start());
}
@@ -386,28 +385,28 @@
*outError = fLazyInstantiationError ? AssignError::kFailedProxyInstantiation
: AssignError::kNoError;
- SkASSERT(fNumOpsTasks == fEndOfOpsTaskOpIndices.count());
+ SkASSERT(fNumOpLists == fEndOfOpListOpIndices.count());
fIntvlHash.reset(); // we don't need the interval hash anymore
- if (fCurOpsTaskIndex >= fEndOfOpsTaskOpIndices.count()) {
+ if (fCurOpListIndex >= fEndOfOpListOpIndices.count()) {
return false; // nothing to render
}
- *startIndex = fCurOpsTaskIndex;
- *stopIndex = fEndOfOpsTaskOpIndices.count();
+ *startIndex = fCurOpListIndex;
+ *stopIndex = fEndOfOpListOpIndices.count();
if (fIntvlList.empty()) {
- fCurOpsTaskIndex = fEndOfOpsTaskOpIndices.count();
+ fCurOpListIndex = fEndOfOpListOpIndices.count();
return true; // no resources to assign
}
#if GR_ALLOCATION_SPEW
- SkDebugf("assigning opsTasks %d through %d out of %d numOpsTasks\n",
- *startIndex, *stopIndex, fNumOpsTasks);
- SkDebugf("EndOfOpsTaskIndices: ");
- for (int i = 0; i < fEndOfOpsTaskOpIndices.count(); ++i) {
- SkDebugf("%d ", fEndOfOpsTaskOpIndices[i]);
+ SkDebugf("assigning opLists %d through %d out of %d numOpLists\n",
+ *startIndex, *stopIndex, fNumOpLists);
+ SkDebugf("EndOfOpListIndices: ");
+ for (int i = 0; i < fEndOfOpListOpIndices.count(); ++i) {
+ SkDebugf("%d ", fEndOfOpListOpIndices[i]);
}
SkDebugf("\n");
#endif
@@ -418,9 +417,9 @@
this->dumpIntervals();
#endif
while (Interval* cur = fIntvlList.popHead()) {
- if (fEndOfOpsTaskOpIndices[fCurOpsTaskIndex] <= cur->start()) {
- fCurOpsTaskIndex++;
- SkASSERT(fCurOpsTaskIndex < fNumOpsTasks);
+ if (fEndOfOpListOpIndices[fCurOpListIndex] <= cur->start()) {
+ fCurOpListIndex++;
+ SkASSERT(fCurOpListIndex < fNumOpLists);
}
this->expire(cur->start());
@@ -438,8 +437,8 @@
fActiveIntvls.insertByIncreasingEnd(cur);
if (fResourceProvider->overBudget()) {
- // Only force intermediate draws on opsTask boundaries
- if (this->onOpsTaskBoundary()) {
+ // Only force intermediate draws on opList boundaries
+ if (this->onOpListBoundary()) {
this->forceIntermediateFlush(stopIndex);
return true;
}
@@ -485,8 +484,8 @@
fActiveIntvls.insertByIncreasingEnd(cur);
if (fResourceProvider->overBudget()) {
- // Only force intermediate draws on opsTask boundaries
- if (this->onOpsTaskBoundary()) {
+ // Only force intermediate draws on opList boundaries
+ if (this->onOpListBoundary()) {
this->forceIntermediateFlush(stopIndex);
return true;
}
diff --git a/src/gpu/GrResourceAllocator.h b/src/gpu/GrResourceAllocator.h
index 0dc7b46..b448c2d 100644
--- a/src/gpu/GrResourceAllocator.h
+++ b/src/gpu/GrResourceAllocator.h
@@ -38,24 +38,24 @@
* adds the new interval to the active list (that is sorted by increasing end index)
*
* Note: the op indices (used in the usage intervals) come from the order of the ops in
- * their opsTasks after the opsTask DAG has been linearized.
+ * their opLists after the opList DAG has been linearized.
*
*************************************************************************************************
* How does instantiation failure handling work when explicitly allocating?
*
* In the gather usage intervals pass all the GrSurfaceProxies used in the flush should be
- * gathered (i.e., in GrOpsTask::gatherProxyIntervals).
+ * gathered (i.e., in GrOpList::gatherProxyIntervals).
*
* The allocator will churn through this list but could fail anywhere.
*
* Allocation failure handling occurs at two levels:
*
- * 1) If the GrSurface backing an opsTask fails to allocate then the entire opsTask is dropped.
+ * 1) If the GrSurface backing an opList fails to allocate then the entire opList is dropped.
*
* 2) If an individual GrSurfaceProxy fails to allocate then any ops that use it are dropped
- * (via GrOpsTask::purgeOpsWithUninstantiatedProxies)
+ * (via GrOpList::purgeOpsWithUninstantiatedProxies)
*
- * The pass to determine which ops to drop is a bit laborious so we only check the opsTasks and
+ * The pass to determine which ops to drop is a bit laborious so we only check the opLists and
* individual ops when something goes wrong in allocation (i.e., when the return code from
* GrResourceAllocator::assign is bad)
*
@@ -70,10 +70,10 @@
public:
GrResourceAllocator(GrResourceProvider* resourceProvider,
GrDeinstantiateProxyTracker* tracker
- SkDEBUGCODE(, int numOpsTasks))
+ SkDEBUGCODE(, int numOpLists))
: fResourceProvider(resourceProvider)
, fDeinstantiateTracker(tracker)
- SkDEBUGCODE(, fNumOpsTasks(numOpsTasks)) {
+ SkDEBUGCODE(, fNumOpLists(numOpLists)) {
}
~GrResourceAllocator();
@@ -82,7 +82,7 @@
void incOps() { fNumOps++; }
/** Indicates whether a given call to addInterval represents an actual usage of the
- * provided proxy. This is mainly here to accomodate deferred proxies attached to opsTasks.
+ * provided proxy. This is mainly here to accomodate deferred proxies attached to opLists.
* In that case we need to create an extra long interval for them (due to the upload) but
* don't want to count that usage/reference towards the proxy's recyclability.
*/
@@ -101,16 +101,16 @@
kFailedProxyInstantiation
};
- // Returns true when the opsTasks from 'startIndex' to 'stopIndex' should be executed;
+ // Returns true when the opLists from 'startIndex' to 'stopIndex' should be executed;
// false when nothing remains to be executed.
// If any proxy fails to instantiate, the AssignError will be set to kFailedProxyInstantiation.
// If this happens, the caller should remove all ops which reference an uninstantiated proxy.
- // This is used to execute a portion of the queued opsTasks in order to reduce the total
+ // This is used to execute a portion of the queued opLists in order to reduce the total
// amount of GPU resources required.
bool assign(int* startIndex, int* stopIndex, AssignError* outError);
void determineRecyclability();
- void markEndOfOpsTask(int opsTaskIndex);
+ void markEndOfOpList(int opListIndex);
#if GR_ALLOCATION_SPEW
void dumpIntervals();
@@ -122,7 +122,7 @@
// Remove dead intervals from the active list
void expire(unsigned int curIndex);
- bool onOpsTaskBoundary() const;
+ bool onOpListBoundary() const;
void forceIntermediateFlush(int* stopIndex);
// These two methods wrap the interactions with the free pool
@@ -269,9 +269,9 @@
IntervalList fActiveIntvls; // List of live intervals during assignment
// (sorted by increasing end)
unsigned int fNumOps = 0;
- SkTArray<unsigned int> fEndOfOpsTaskOpIndices;
- int fCurOpsTaskIndex = 0;
- SkDEBUGCODE(const int fNumOpsTasks = -1;)
+ SkTArray<unsigned int> fEndOfOpListOpIndices;
+ int fCurOpListIndex = 0;
+ SkDEBUGCODE(const int fNumOpLists = -1;)
SkDEBUGCODE(bool fAssigned = false;)
diff --git a/src/gpu/GrResourceProvider.h b/src/gpu/GrResourceProvider.h
index d3264d3..4adb2fa 100644
--- a/src/gpu/GrResourceProvider.h
+++ b/src/gpu/GrResourceProvider.h
@@ -45,7 +45,7 @@
kNone = 0x0,
/** If the caller intends to do direct reads/writes to/from the CPU then this flag must be
- * set when accessing resources during a GrOpsTask flush. This includes the execution of
+ * set when accessing resources during a GrOpList flush. This includes the execution of
* GrOp objects. The reason is that these memory operations are done immediately and
* will occur out of order WRT the operations being flushed.
* Make this automatic: https://bug.skia.org/4156
diff --git a/src/gpu/GrSoftwarePathRenderer.cpp b/src/gpu/GrSoftwarePathRenderer.cpp
index c562436..a3d3f49 100644
--- a/src/gpu/GrSoftwarePathRenderer.cpp
+++ b/src/gpu/GrSoftwarePathRenderer.cpp
@@ -16,6 +16,7 @@
#include "src/gpu/GrDeferredProxyUploader.h"
#include "src/gpu/GrGpuResourcePriv.h"
#include "src/gpu/GrOpFlushState.h"
+#include "src/gpu/GrOpList.h"
#include "src/gpu/GrProxyProvider.h"
#include "src/gpu/GrRecordingContextPriv.h"
#include "src/gpu/GrRenderTargetContextPriv.h"
diff --git a/src/gpu/GrSurface.cpp b/src/gpu/GrSurface.cpp
index df451a8..db5a707 100644
--- a/src/gpu/GrSurface.cpp
+++ b/src/gpu/GrSurface.cpp
@@ -8,6 +8,7 @@
#include "include/gpu/GrContext.h"
#include "include/gpu/GrSurface.h"
#include "include/gpu/GrTexture.h"
+#include "src/gpu/GrOpList.h"
#include "src/gpu/GrRenderTarget.h"
#include "src/gpu/GrResourceProvider.h"
#include "src/gpu/GrSurfacePriv.h"
diff --git a/src/gpu/GrSurfaceContext.cpp b/src/gpu/GrSurfaceContext.cpp
index 3a4726b..dff02b0 100644
--- a/src/gpu/GrSurfaceContext.cpp
+++ b/src/gpu/GrSurfaceContext.cpp
@@ -15,6 +15,7 @@
#include "src/gpu/GrDataUtils.h"
#include "src/gpu/GrDrawingManager.h"
#include "src/gpu/GrGpu.h"
+#include "src/gpu/GrOpList.h"
#include "src/gpu/GrRecordingContextPriv.h"
#include "src/gpu/GrRenderTargetContext.h"
#include "src/gpu/GrSurfaceContextPriv.h"
@@ -27,10 +28,10 @@
SkDEBUGCODE(GrSingleOwner::AutoEnforce debug_SingleOwner(this->singleOwner());)
#define RETURN_FALSE_IF_ABANDONED if (this->fContext->priv().abandoned()) { return false; }
-// In MDB mode the reffing of the 'getLastOpsTask' call's result allows in-progress
-// GrOpsTasks to be picked up and added to by renderTargetContexts lower in the call
-// stack. When this occurs with a closed GrOpsTask, a new one will be allocated
-// when the renderTargetContext attempts to use it (via getOpsTask).
+// In MDB mode the reffing of the 'getLastOpList' call's result allows in-progress
+// GrOpLists to be picked up and added to by renderTargetContexts lower in the call
+// stack. When this occurs with a closed GrOpList, a new one will be allocated
+// when the renderTargetContext attempts to use it (via getOpList).
GrSurfaceContext::GrSurfaceContext(GrRecordingContext* context,
GrColorType colorType,
SkAlphaType alphaType,
diff --git a/src/gpu/GrSurfaceContext.h b/src/gpu/GrSurfaceContext.h
index fccc52b..6bbeb72 100644
--- a/src/gpu/GrSurfaceContext.h
+++ b/src/gpu/GrSurfaceContext.h
@@ -19,6 +19,7 @@
class GrAuditTrail;
class GrDrawingManager;
+class GrOpList;
class GrRecordingContext;
class GrRenderTargetContext;
class GrRenderTargetProxy;
diff --git a/src/gpu/GrSurfaceProxy.cpp b/src/gpu/GrSurfaceProxy.cpp
index 484087b..f9ec3c0 100644
--- a/src/gpu/GrSurfaceProxy.cpp
+++ b/src/gpu/GrSurfaceProxy.cpp
@@ -16,7 +16,7 @@
#include "src/gpu/GrClip.h"
#include "src/gpu/GrContextPriv.h"
#include "src/gpu/GrGpuResourcePriv.h"
-#include "src/gpu/GrOpsTask.h"
+#include "src/gpu/GrOpList.h"
#include "src/gpu/GrProxyProvider.h"
#include "src/gpu/GrRecordingContextPriv.h"
#include "src/gpu/GrStencilAttachment.h"
@@ -107,7 +107,7 @@
}
GrSurfaceProxy::~GrSurfaceProxy() {
- // For this to be deleted the opsTask that held a ref on it (if there was one) must have been
+ // For this to be deleted the opList that held a ref on it (if there was one) must have been
// deleted. Which would have cleared out this back pointer.
SkASSERT(!fLastRenderTask);
}
@@ -302,8 +302,8 @@
fLastRenderTask = renderTask;
}
-GrOpsTask* GrSurfaceProxy::getLastOpsTask() {
- return fLastRenderTask ? fLastRenderTask->asOpsTask() : nullptr;
+GrRenderTargetOpList* GrSurfaceProxy::getLastRenderTargetOpList() {
+ return fLastRenderTask ? fLastRenderTask->asRenderTargetOpList() : nullptr;
}
int GrSurfaceProxy::worstCaseWidth() const {
diff --git a/src/gpu/GrSurfaceProxy.h b/src/gpu/GrSurfaceProxy.h
index 5b0297d..4c78019 100644
--- a/src/gpu/GrSurfaceProxy.h
+++ b/src/gpu/GrSurfaceProxy.h
@@ -18,8 +18,8 @@
class GrCaps;
class GrContext_Base;
-class GrOpsTask;
class GrRecordingContext;
+class GrRenderTargetOpList;
class GrRenderTargetProxy;
class GrRenderTask;
class GrResourceProvider;
@@ -281,7 +281,7 @@
void setLastRenderTask(GrRenderTask*);
GrRenderTask* getLastRenderTask() { return fLastRenderTask; }
- GrOpsTask* getLastOpsTask();
+ GrRenderTargetOpList* getLastRenderTargetOpList();
/**
* Retrieves the amount of GPU memory that will be or currently is used by this resource
@@ -439,12 +439,12 @@
// the instantiation method.
mutable size_t fGpuMemorySize;
- // The last GrRenderTask that wrote to or is currently going to write to this surface
- // The GrRenderTask can be closed (e.g., no surface context is currently bound
+ // The last opList that wrote to or is currently going to write to this surface
+ // The opList can be closed (e.g., no surface context is currently bound
// to this proxy).
// This back-pointer is required so that we can add a dependancy between
- // the GrRenderTask used to create the current contents of this surface
- // and the GrRenderTask of a destination surface to which this one is being drawn or copied.
+ // the opList used to create the current contents of this surface
+ // and the opList of a destination surface to which this one is being drawn or copied.
// This pointer is unreffed. GrRenderTasks own a ref on their surface proxies.
GrRenderTask* fLastRenderTask;
diff --git a/src/gpu/GrTextureProxy.h b/src/gpu/GrTextureProxy.h
index 5870510..986975b 100644
--- a/src/gpu/GrTextureProxy.h
+++ b/src/gpu/GrTextureProxy.h
@@ -145,7 +145,7 @@
// This tracks the mipmap status at the proxy level and is thus somewhat distinct from the
// backing GrTexture's mipmap status. In particular, this status is used to determine when
- // mipmap levels need to be explicitly regenerated during the execution of a DAG of opsTasks.
+ // mipmap levels need to be explicitly regenerated during the execution of a DAG of opLists.
GrMipMapsStatus fMipMapsStatus;
// TEMPORARY: We are in the process of moving GrMipMapsStatus from the texture to the proxy.
// We track the fInitialMipMapsStatus here so we can assert that the proxy did indeed expect
diff --git a/src/gpu/GrTextureResolveRenderTask.cpp b/src/gpu/GrTextureResolveRenderTask.cpp
index 1e52b87..613f6bd 100644
--- a/src/gpu/GrTextureResolveRenderTask.cpp
+++ b/src/gpu/GrTextureResolveRenderTask.cpp
@@ -27,7 +27,7 @@
textureProxyPtr, GrMipMapped::kNo, GrTextureResolveManager(nullptr), caps);
textureProxyPtr->setLastRenderTask(resolveTask.get());
- // We only resolve the texture; nobody should try to do anything else with this opsTask.
+ // We only resolve the texture; nobody should try to do anything else with this opList.
resolveTask->makeClosed(caps);
if (GrTextureResolveFlags::kMipMaps & flags) {
@@ -41,7 +41,7 @@
void GrTextureResolveRenderTask::gatherProxyIntervals(GrResourceAllocator* alloc) const {
// This renderTask doesn't have "normal" ops. In this case we still need to add an interval (so
- // fEndOfOpsTaskOpIndices will remain in sync), so we create a fake op# to capture the fact that
+ // fEndOfOpListOpIndices will remain in sync), so we create a fake op# to capture the fact that
// we manipulate fTarget.
alloc->addInterval(fTarget.get(), alloc->curOp(), alloc->curOp(),
GrResourceAllocator::ActualUse::kYes);
diff --git a/src/gpu/GrTransferFromRenderTask.cpp b/src/gpu/GrTransferFromRenderTask.cpp
index 7826bce..3e6dfc5 100644
--- a/src/gpu/GrTransferFromRenderTask.cpp
+++ b/src/gpu/GrTransferFromRenderTask.cpp
@@ -13,7 +13,7 @@
void GrTransferFromRenderTask::gatherProxyIntervals(GrResourceAllocator* alloc) const {
// This renderTask doesn't have "normal" ops. In this case we still need to add an interval (so
- // fEndOfOpsTaskOpIndices will remain in sync), so we create a fake op# to capture the fact that
+ // fEndOfOpListOpIndices will remain in sync), so we create a fake op# to capture the fact that
// we read fSrcProxy.
alloc->addInterval(fSrcProxy.get(), alloc->curOp(), alloc->curOp(),
GrResourceAllocator::ActualUse::kYes);
diff --git a/src/gpu/GrUserStencilSettings.h b/src/gpu/GrUserStencilSettings.h
index 83a19b7..b89a9ec 100644
--- a/src/gpu/GrUserStencilSettings.h
+++ b/src/gpu/GrUserStencilSettings.h
@@ -13,12 +13,12 @@
/**
* Gr uses the stencil buffer to implement complex clipping inside the
- * GrOpsTask class. The GrOpsTask makes a subset of the stencil buffer
+ * GrOpList class. The GrOpList makes a subset of the stencil buffer
* bits available for other uses by external code (user bits). Client code can
- * modify these bits. GrOpsTask will ignore ref, mask, and writemask bits
+ * modify these bits. GrOpList will ignore ref, mask, and writemask bits
* provided by clients that fall outside the user range.
*
- * When code outside the GrOpsTask class uses the stencil buffer the contract
+ * When code outside the GrOpList class uses the stencil buffer the contract
* is as follows:
*
* > Normal stencil funcs allow the client to pass / fail regardless of the
diff --git a/src/gpu/ccpr/GrCCClipPath.h b/src/gpu/ccpr/GrCCClipPath.h
index 32e5ae4..1494d2c6 100644
--- a/src/gpu/ccpr/GrCCClipPath.h
+++ b/src/gpu/ccpr/GrCCClipPath.h
@@ -19,7 +19,7 @@
/**
* These are keyed by SkPath generation ID, and store which device-space paths are accessed and
- * where by clip FPs in a given opsTask. A single GrCCClipPath can be referenced by multiple FPs. At
+ * where by clip FPs in a given opList. A single GrCCClipPath can be referenced by multiple FPs. At
* flush time their coverage count masks are packed into atlas(es) alongside normal DrawPathOps.
*/
class GrCCClipPath {
diff --git a/src/gpu/ccpr/GrCCDrawPathsOp.cpp b/src/gpu/ccpr/GrCCDrawPathsOp.cpp
index 4ad6cd9..0a6433c 100644
--- a/src/gpu/ccpr/GrCCDrawPathsOp.cpp
+++ b/src/gpu/ccpr/GrCCDrawPathsOp.cpp
@@ -111,7 +111,7 @@
// If the path is clipped, CCPR will only draw the visible portion. This helps improve batching,
// since it eliminates the need for scissor when drawing to the main canvas.
// FIXME: We should parse the path right here. It will provide a tighter bounding box for us to
- // give the opsTask, as well as enabling threaded parsing when using DDL.
+ // give the opList, as well as enabling threaded parsing when using DDL.
SkRect clippedDrawBounds;
if (!clippedDrawBounds.intersect(conservativeDevBounds, SkRect::Make(maskDevIBounds))) {
clippedDrawBounds.setEmpty();
@@ -122,9 +122,9 @@
}
GrCCDrawPathsOp::~GrCCDrawPathsOp() {
- if (fOwningPerOpsTaskPaths) {
+ if (fOwningPerOpListPaths) {
// Remove the list's dangling pointer to this Op before deleting it.
- fOwningPerOpsTaskPaths->fDrawOps.remove(this);
+ fOwningPerOpListPaths->fDrawOps.remove(this);
}
}
@@ -195,10 +195,9 @@
GrOp::CombineResult GrCCDrawPathsOp::onCombineIfPossible(GrOp* op, const GrCaps&) {
GrCCDrawPathsOp* that = op->cast<GrCCDrawPathsOp>();
- SkASSERT(fOwningPerOpsTaskPaths);
+ SkASSERT(fOwningPerOpListPaths);
SkASSERT(fNumDraws);
- SkASSERT(!that->fOwningPerOpsTaskPaths ||
- that->fOwningPerOpsTaskPaths == fOwningPerOpsTaskPaths);
+ SkASSERT(!that->fOwningPerOpListPaths || that->fOwningPerOpListPaths == fOwningPerOpListPaths);
SkASSERT(that->fNumDraws);
if (fProcessors != that->fProcessors ||
@@ -206,18 +205,18 @@
return CombineResult::kCannotCombine;
}
- fDraws.append(std::move(that->fDraws), &fOwningPerOpsTaskPaths->fAllocator);
+ fDraws.append(std::move(that->fDraws), &fOwningPerOpListPaths->fAllocator);
SkDEBUGCODE(fNumDraws += that->fNumDraws);
SkDEBUGCODE(that->fNumDraws = 0);
return CombineResult::kMerged;
}
-void GrCCDrawPathsOp::addToOwningPerOpsTaskPaths(sk_sp<GrCCPerOpsTaskPaths> owningPerOpsTaskPaths) {
+void GrCCDrawPathsOp::addToOwningPerOpListPaths(sk_sp<GrCCPerOpListPaths> owningPerOpListPaths) {
SkASSERT(1 == fNumDraws);
- SkASSERT(!fOwningPerOpsTaskPaths);
- fOwningPerOpsTaskPaths = std::move(owningPerOpsTaskPaths);
- fOwningPerOpsTaskPaths->fDrawOps.addToTail(this);
+ SkASSERT(!fOwningPerOpListPaths);
+ fOwningPerOpListPaths = std::move(owningPerOpListPaths);
+ fOwningPerOpListPaths->fDrawOps.addToTail(this);
}
void GrCCDrawPathsOp::accountForOwnPaths(GrCCPathCache* pathCache,
@@ -415,9 +414,9 @@
}
void GrCCDrawPathsOp::onExecute(GrOpFlushState* flushState, const SkRect& chainBounds) {
- SkASSERT(fOwningPerOpsTaskPaths);
+ SkASSERT(fOwningPerOpListPaths);
- const GrCCPerFlushResources* resources = fOwningPerOpsTaskPaths->fFlushResources.get();
+ const GrCCPerFlushResources* resources = fOwningPerOpListPaths->fFlushResources.get();
if (!resources) {
return; // Setup failed.
}
diff --git a/src/gpu/ccpr/GrCCDrawPathsOp.h b/src/gpu/ccpr/GrCCDrawPathsOp.h
index d0c4777..1499c28 100644
--- a/src/gpu/ccpr/GrCCDrawPathsOp.h
+++ b/src/gpu/ccpr/GrCCDrawPathsOp.h
@@ -17,7 +17,7 @@
class GrCCAtlas;
class GrCCPerFlushResources;
struct GrCCPerFlushResourceSpecs;
-struct GrCCPerOpsTaskPaths;
+struct GrCCPerOpListPaths;
class GrOnFlushResourceProvider;
class GrRecordingContext;
@@ -46,7 +46,7 @@
}
void onPrepare(GrOpFlushState*) override {}
- void addToOwningPerOpsTaskPaths(sk_sp<GrCCPerOpsTaskPaths> owningPerOpsTaskPaths);
+ void addToOwningPerOpListPaths(sk_sp<GrCCPerOpListPaths> owningPerOpListPaths);
// Makes decisions about how to draw each path (cached, copied, rendered, etc.), and
// increments/fills out the corresponding GrCCPerFlushResourceSpecs.
@@ -125,9 +125,9 @@
friend class GrCCSTLList<SingleDraw>; // To access fNext.
};
- // Declare fOwningPerOpsTaskPaths first, before fDraws. The draws use memory allocated by
- // fOwningPerOpsTaskPaths, so it must not be unreffed until after fDraws is destroyed.
- sk_sp<GrCCPerOpsTaskPaths> fOwningPerOpsTaskPaths;
+ // Declare fOwningPerOpListPaths first, before fDraws. The draws use memory allocated by
+ // fOwningPerOpListPaths, so it must not be unreffed until after fDraws is destroyed.
+ sk_sp<GrCCPerOpListPaths> fOwningPerOpListPaths;
GrCCSTLList<SingleDraw> fDraws;
SkDEBUGCODE(int fNumDraws = 1);
diff --git a/src/gpu/ccpr/GrCCPerFlushResources.h b/src/gpu/ccpr/GrCCPerFlushResources.h
index f2504e6..59122fe 100644
--- a/src/gpu/ccpr/GrCCPerFlushResources.h
+++ b/src/gpu/ccpr/GrCCPerFlushResources.h
@@ -62,8 +62,8 @@
/**
* This class wraps all the GPU resources that CCPR builds at flush time. It is allocated in CCPR's
- * preFlush() method, and referenced by all the GrCCPerOpsTaskPaths objects that are being flushed.
- * It is deleted in postFlush() once all the flushing GrCCPerOpsTaskPaths objects are deleted.
+ * preFlush() method, and referenced by all the GrCCPerOpListPaths objects that are being flushed.
+ * It is deleted in postFlush() once all the flushing GrCCPerOpListPaths objects are deleted.
*/
class GrCCPerFlushResources : public GrNonAtomicRef<GrCCPerFlushResources> {
public:
diff --git a/src/gpu/ccpr/GrCCPerOpsTaskPaths.h b/src/gpu/ccpr/GrCCPerOpListPaths.h
similarity index 78%
rename from src/gpu/ccpr/GrCCPerOpsTaskPaths.h
rename to src/gpu/ccpr/GrCCPerOpListPaths.h
index ff8a224..e0dd115 100644
--- a/src/gpu/ccpr/GrCCPerOpsTaskPaths.h
+++ b/src/gpu/ccpr/GrCCPerOpListPaths.h
@@ -5,8 +5,8 @@
* found in the LICENSE file.
*/
-#ifndef GrCCPerOpsTaskPaths_DEFINED
-#define GrCCPerOpsTaskPaths_DEFINED
+#ifndef GrCCPerOpListPaths_DEFINED
+#define GrCCPerOpListPaths_DEFINED
#include "include/core/SkRefCnt.h"
#include "src/core/SkArenaAlloc.h"
@@ -19,10 +19,10 @@
class GrCCPerFlushResources;
/**
- * Tracks all the CCPR paths in a given opsTask that will be drawn when it flushes.
+ * Tracks all the CCPR paths in a given opList that will be drawn when it flushes.
*/
// DDL TODO: given the usage pattern in DDL mode, this could probably be non-atomic refcounting.
-struct GrCCPerOpsTaskPaths : public SkRefCnt {
+struct GrCCPerOpListPaths : public SkRefCnt {
SkTInternalLList<GrCCDrawPathsOp> fDrawOps; // This class does not own these ops.
std::map<uint32_t, GrCCClipPath> fClipPaths;
SkSTArenaAlloc<10 * 1024> fAllocator{10 * 1024 * 2};
diff --git a/src/gpu/ccpr/GrCCSTLList.h b/src/gpu/ccpr/GrCCSTLList.h
index 29f26b9..eb75863 100644
--- a/src/gpu/ccpr/GrCCSTLList.h
+++ b/src/gpu/ccpr/GrCCSTLList.h
@@ -14,8 +14,8 @@
/**
* A singly-linked list whose head element is a local class member. This is required by
- * GrCCDrawPathsOp because the owning opsTask is unknown at the time of creation, so we can't use
- * its associated allocator to create the first element.
+ * GrCCDrawPathsOp because the owning opList is unknown at the time of creation, so we can't use its
+ * associated allocator to create the first element.
*/
template<typename T> class GrCCSTLList : SkNoncopyable {
public:
diff --git a/src/gpu/ccpr/GrCoverageCountingPathRenderer.cpp b/src/gpu/ccpr/GrCoverageCountingPathRenderer.cpp
index 4798b6f..a9e080b 100644
--- a/src/gpu/ccpr/GrCoverageCountingPathRenderer.cpp
+++ b/src/gpu/ccpr/GrCoverageCountingPathRenderer.cpp
@@ -71,11 +71,11 @@
}
}
-GrCCPerOpsTaskPaths* GrCoverageCountingPathRenderer::lookupPendingPaths(uint32_t opsTaskID) {
- auto it = fPendingPaths.find(opsTaskID);
+GrCCPerOpListPaths* GrCoverageCountingPathRenderer::lookupPendingPaths(uint32_t opListID) {
+ auto it = fPendingPaths.find(opListID);
if (fPendingPaths.end() == it) {
- sk_sp<GrCCPerOpsTaskPaths> paths = sk_make_sp<GrCCPerOpsTaskPaths>();
- it = fPendingPaths.insert(std::make_pair(opsTaskID, std::move(paths))).first;
+ sk_sp<GrCCPerOpListPaths> paths = sk_make_sp<GrCCPerOpListPaths>();
+ it = fPendingPaths.insert(std::make_pair(opListID, std::move(paths))).first;
}
return it->second.get();
}
@@ -182,17 +182,16 @@
void GrCoverageCountingPathRenderer::recordOp(std::unique_ptr<GrCCDrawPathsOp> op,
const DrawPathArgs& args) {
if (op) {
- auto addToOwningPerOpsTaskPaths = [this](GrOp* op, uint32_t opsTaskID) {
- op->cast<GrCCDrawPathsOp>()->addToOwningPerOpsTaskPaths(
- sk_ref_sp(this->lookupPendingPaths(opsTaskID)));
+ auto addToOwningPerOpListPaths = [this](GrOp* op, uint32_t opListID) {
+ op->cast<GrCCDrawPathsOp>()->addToOwningPerOpListPaths(
+ sk_ref_sp(this->lookupPendingPaths(opListID)));
};
- args.fRenderTargetContext->addDrawOp(*args.fClip, std::move(op),
- addToOwningPerOpsTaskPaths);
+ args.fRenderTargetContext->addDrawOp(*args.fClip, std::move(op), addToOwningPerOpListPaths);
}
}
std::unique_ptr<GrFragmentProcessor> GrCoverageCountingPathRenderer::makeClipProcessor(
- uint32_t opsTaskID, const SkPath& deviceSpacePath, const SkIRect& accessRect,
+ uint32_t opListID, const SkPath& deviceSpacePath, const SkIRect& accessRect,
const GrCaps& caps) {
SkASSERT(!fFlushing);
@@ -203,7 +202,7 @@
key = (key << 1) | (uint32_t)GrFillRuleForSkPath(deviceSpacePath);
}
GrCCClipPath& clipPath =
- this->lookupPendingPaths(opsTaskID)->fClipPaths[key];
+ this->lookupPendingPaths(opListID)->fClipPaths[key];
if (!clipPath.isInitialized()) {
// This ClipPath was just created during lookup. Initialize it.
const SkRect& pathDevBounds = deviceSpacePath.getBounds();
@@ -229,8 +228,8 @@
void GrCoverageCountingPathRenderer::preFlush(
GrOnFlushResourceProvider* onFlushRP,
- const uint32_t* opsTaskIDs,
- int numOpsTaskIDs,
+ const uint32_t* opListIDs,
+ int numOpListIDs,
SkTArray<std::unique_ptr<GrRenderTargetContext>>* out) {
using DoCopiesToA8Coverage = GrCCDrawPathsOp::DoCopiesToA8Coverage;
SkASSERT(!fFlushing);
@@ -252,13 +251,13 @@
specs.fRenderedAtlasSpecs.fMaxPreferredTextureSize = maxPreferredRTSize;
specs.fRenderedAtlasSpecs.fMinTextureSize = SkTMin(512, maxPreferredRTSize);
- // Move the per-opsTask paths that are about to be flushed from fPendingPaths to fFlushingPaths,
+ // Move the per-opList paths that are about to be flushed from fPendingPaths to fFlushingPaths,
// and count them up so we can preallocate buffers.
- fFlushingPaths.reserve(numOpsTaskIDs);
- for (int i = 0; i < numOpsTaskIDs; ++i) {
- auto iter = fPendingPaths.find(opsTaskIDs[i]);
+ fFlushingPaths.reserve(numOpListIDs);
+ for (int i = 0; i < numOpListIDs; ++i) {
+ auto iter = fPendingPaths.find(opListIDs[i]);
if (fPendingPaths.end() == iter) {
- continue; // No paths on this opsTask.
+ continue; // No paths on this opList.
}
fFlushingPaths.push_back(std::move(iter->second));
@@ -319,8 +318,8 @@
}
}
-void GrCoverageCountingPathRenderer::postFlush(GrDeferredUploadToken, const uint32_t* opsTaskIDs,
- int numOpsTaskIDs) {
+void GrCoverageCountingPathRenderer::postFlush(GrDeferredUploadToken, const uint32_t* opListIDs,
+ int numOpListIDs) {
SkASSERT(fFlushing);
if (!fFlushingPaths.empty()) {
diff --git a/src/gpu/ccpr/GrCoverageCountingPathRenderer.h b/src/gpu/ccpr/GrCoverageCountingPathRenderer.h
index 4a7ca18..0450918 100644
--- a/src/gpu/ccpr/GrCoverageCountingPathRenderer.h
+++ b/src/gpu/ccpr/GrCoverageCountingPathRenderer.h
@@ -10,10 +10,10 @@
#include <map>
#include "src/gpu/GrOnFlushResourceProvider.h"
-#include "src/gpu/GrOpsTask.h"
#include "src/gpu/GrPathRenderer.h"
+#include "src/gpu/GrRenderTargetOpList.h"
#include "src/gpu/ccpr/GrCCPerFlushResources.h"
-#include "src/gpu/ccpr/GrCCPerOpsTaskPaths.h"
+#include "src/gpu/ccpr/GrCCPerOpListPaths.h"
class GrCCDrawPathsOp;
class GrCCPathCache;
@@ -41,16 +41,16 @@
CoverageType coverageType() const { return fCoverageType; }
- using PendingPathsMap = std::map<uint32_t, sk_sp<GrCCPerOpsTaskPaths>>;
+ using PendingPathsMap = std::map<uint32_t, sk_sp<GrCCPerOpListPaths>>;
- // In DDL mode, Ganesh needs to be able to move the pending GrCCPerOpsTaskPaths to the DDL
- // object (detachPendingPaths) and then return them upon replay (mergePendingPaths).
+ // In DDL mode, Ganesh needs to be able to move the pending GrCCPerOpListPaths to the DDL object
+ // (detachPendingPaths) and then return them upon replay (mergePendingPaths).
PendingPathsMap detachPendingPaths() { return std::move(fPendingPaths); }
void mergePendingPaths(const PendingPathsMap& paths) {
#ifdef SK_DEBUG
- // Ensure there are no duplicate opsTask IDs between the incoming path map and ours.
- // This should always be true since opsTask IDs are globally unique and these are coming
+ // Ensure there are no duplicate opList IDs between the incoming path map and ours.
+ // This should always be true since opList IDs are globally unique and these are coming
// from different DDL recordings.
for (const auto& it : paths) {
SkASSERT(!fPendingPaths.count(it.first));
@@ -65,9 +65,9 @@
const GrCaps&);
// GrOnFlushCallbackObject overrides.
- void preFlush(GrOnFlushResourceProvider*, const uint32_t* opsTaskIDs, int numOpsTaskIDs,
+ void preFlush(GrOnFlushResourceProvider*, const uint32_t* opListIDs, int numOpListIDs,
SkTArray<std::unique_ptr<GrRenderTargetContext>>* out) override;
- void postFlush(GrDeferredUploadToken, const uint32_t* opsTaskIDs, int numOpsTaskIDs) override;
+ void postFlush(GrDeferredUploadToken, const uint32_t* opListIDs, int numOpListIDs) override;
void purgeCacheEntriesOlderThan(GrProxyProvider*, const GrStdSteadyClock::time_point&);
@@ -94,19 +94,19 @@
CanDrawPath onCanDrawPath(const CanDrawPathArgs&) const override;
bool onDrawPath(const DrawPathArgs&) override;
- GrCCPerOpsTaskPaths* lookupPendingPaths(uint32_t opsTaskID);
+ GrCCPerOpListPaths* lookupPendingPaths(uint32_t opListID);
void recordOp(std::unique_ptr<GrCCDrawPathsOp>, const DrawPathArgs&);
const CoverageType fCoverageType;
- // fPendingPaths holds the GrCCPerOpsTaskPaths objects that have already been created, but not
- // flushed, and those that are still being created. All GrCCPerOpsTaskPaths objects will first
+ // fPendingPaths holds the GrCCPerOpListPaths objects that have already been created, but not
+ // flushed, and those that are still being created. All GrCCPerOpListPaths objects will first
// reside in fPendingPaths, then be moved to fFlushingPaths during preFlush().
PendingPathsMap fPendingPaths;
- // fFlushingPaths holds the GrCCPerOpsTaskPaths objects that are currently being flushed.
+ // fFlushingPaths holds the GrCCPerOpListPaths objects that are currently being flushed.
// (It will only contain elements when fFlushing is true.)
- SkSTArray<4, sk_sp<GrCCPerOpsTaskPaths>> fFlushingPaths;
+ SkSTArray<4, sk_sp<GrCCPerOpListPaths>> fFlushingPaths;
std::unique_ptr<GrCCPathCache> fPathCache;
diff --git a/src/gpu/ccpr/GrCoverageCountingPathRenderer_none.cpp b/src/gpu/ccpr/GrCoverageCountingPathRenderer_none.cpp
index 1b2a55e..0b61e4b 100644
--- a/src/gpu/ccpr/GrCoverageCountingPathRenderer_none.cpp
+++ b/src/gpu/ccpr/GrCoverageCountingPathRenderer_none.cpp
@@ -17,7 +17,7 @@
}
std::unique_ptr<GrFragmentProcessor> GrCoverageCountingPathRenderer::makeClipProcessor(
- uint32_t opsTaskID, const SkPath& deviceSpacePath, const SkIRect& accessRect,
+ uint32_t opListID, const SkPath& deviceSpacePath, const SkIRect& accessRect,
const GrCaps& caps) {
return nullptr;
}
diff --git a/src/gpu/gl/GrGLGpu.cpp b/src/gpu/gl/GrGLGpu.cpp
index 479ca28..0cbef8b 100644
--- a/src/gpu/gl/GrGLGpu.cpp
+++ b/src/gpu/gl/GrGLGpu.cpp
@@ -1879,7 +1879,7 @@
if (rt && rt->needsResolve()) {
this->resolveRenderTarget(rt);
// TEMPORARY: MSAA resolve will have dirtied mipmaps. This goes away once we switch
- // to resolving MSAA from the opsTask as well.
+ // to resolving MSAA from the opList as well.
if (GrSamplerState::Filter::kMipMap == sampler.filter() &&
(tex->width() != 1 || tex->height() != 1)) {
SkASSERT(tex->texturePriv().mipMapped() == GrMipMapped::kYes);
@@ -1887,7 +1887,7 @@
this->regenerateMipMapLevels(tex);
}
}
- // Ensure mipmaps were all resolved ahead of time by the opsTask.
+ // Ensure mipmaps were all resolved ahead of time by the opList.
if (GrSamplerState::Filter::kMipMap == sampler.filter() &&
(tex->width() != 1 || tex->height() != 1)) {
// There are some cases where we might be given a non-mipmapped texture with a mipmap
@@ -2165,7 +2165,7 @@
#else
// we could just clear the clip bit but when we go through
// ANGLE a partial stencil mask will cause clears to be
- // turned into draws. Our contract on GrOpsTask says that
+ // turned into draws. Our contract on GrOpList says that
// changing the clip between stencil passes may or may not
// zero the client's clip bits. So we just clear the whole thing.
static const GrGLint clipStencilMask = ~0;
diff --git a/src/gpu/ops/GrOp.h b/src/gpu/ops/GrOp.h
index 7aff59d..f94e041 100644
--- a/src/gpu/ops/GrOp.h
+++ b/src/gpu/ops/GrOp.h
@@ -21,6 +21,7 @@
class GrCaps;
class GrGpuCommandBuffer;
class GrOpFlushState;
+class GrRenderTargetOpList;
/**
* GrOp is the base class for all Ganesh deferred GPU operations. To facilitate reordering and to
diff --git a/src/gpu/ops/GrSmallPathRenderer.h b/src/gpu/ops/GrSmallPathRenderer.h
index e7017b1..d7aa781 100644
--- a/src/gpu/ops/GrSmallPathRenderer.h
+++ b/src/gpu/ops/GrSmallPathRenderer.h
@@ -41,7 +41,7 @@
}
void postFlush(GrDeferredUploadToken startTokenForNextFlush,
- const uint32_t* /*opsTaskIDs*/, int /*numOpsTaskIDs*/) override {
+ const uint32_t* /*opListIDs*/, int /*numOpListIDs*/) override {
if (fAtlas) {
fAtlas->compact(startTokenForNextFlush);
}
diff --git a/src/gpu/text/GrAtlasManager.h b/src/gpu/text/GrAtlasManager.h
index 650b905..026806b 100644
--- a/src/gpu/text/GrAtlasManager.h
+++ b/src/gpu/text/GrAtlasManager.h
@@ -98,7 +98,7 @@
}
void postFlush(GrDeferredUploadToken startTokenForNextFlush,
- const uint32_t* opsTaskIDs, int numOpsTaskIDs) override {
+ const uint32_t* opListIDs, int numOpListIDs) override {
for (int i = 0; i < kMaskFormatCount; ++i) {
if (fAtlases[i]) {
fAtlases[i]->compact(startTokenForNextFlush);
diff --git a/src/gpu/vk/GrVkGpuCommandBuffer.cpp b/src/gpu/vk/GrVkGpuCommandBuffer.cpp
index 8f5309e..80e4340 100644
--- a/src/gpu/vk/GrVkGpuCommandBuffer.cpp
+++ b/src/gpu/vk/GrVkGpuCommandBuffer.cpp
@@ -637,7 +637,7 @@
if (texRT && texRT->needsResolve()) {
fGpu->resolveRenderTargetNoFlush(texRT);
// TEMPORARY: MSAA resolve will have dirtied mipmaps. This goes away once we switch
- // to resolving MSAA from the opsTask as well.
+ // to resolving MSAA from the opList as well.
if (GrSamplerState::Filter::kMipMap == filter &&
(vkTexture->width() != 1 || vkTexture->height() != 1)) {
SkASSERT(vkTexture->texturePriv().mipMapped() == GrMipMapped::kYes);
@@ -646,7 +646,7 @@
}
}
- // Ensure mip maps were all resolved ahead of time by the opsTask.
+ // Ensure mip maps were all resolved ahead of time by the opList.
if (GrSamplerState::Filter::kMipMap == filter &&
(vkTexture->width() != 1 || vkTexture->height() != 1)) {
SkASSERT(vkTexture->texturePriv().mipMapped() == GrMipMapped::kYes);
diff --git a/tests/GrCCPRTest.cpp b/tests/GrCCPRTest.cpp
index c7b0128..4628c90 100644
--- a/tests/GrCCPRTest.cpp
+++ b/tests/GrCCPRTest.cpp
@@ -42,7 +42,7 @@
private:
bool apply(GrRecordingContext* context, GrRenderTargetContext* rtc, bool useHWAA,
bool hasUserStencilSettings, GrAppliedClip* out, SkRect* bounds) const override {
- out->addCoverageFP(fCCPR->makeClipProcessor(rtc->priv().testingOnly_getOpsTaskID(), fPath,
+ out->addCoverageFP(fCCPR->makeClipProcessor(rtc->priv().testingOnly_getOpListID(), fPath,
SkIRect::MakeWH(rtc->width(), rtc->height()),
*context->priv().caps()));
return true;
@@ -321,7 +321,7 @@
int lastCopyAtlasID() const { return fLastCopyAtlasID; }
int lastRenderedAtlasID() const { return fLastRenderedAtlasID; }
- void preFlush(GrOnFlushResourceProvider*, const uint32_t* opsTaskIDs, int numOpsTaskIDs,
+ void preFlush(GrOnFlushResourceProvider*, const uint32_t* opListIDs, int numOpListIDs,
SkTArray<std::unique_ptr<GrRenderTargetContext>>* out) override {
fLastRenderedAtlasID = fLastCopyAtlasID = 0;
@@ -839,7 +839,7 @@
};
DEF_CCPR_TEST(CCPR_cache_partialInvalidate)
-class CCPR_unrefPerOpsTaskPathsBeforeOps : public CCPRTest {
+class CCPR_unrefPerOpListPathsBeforeOps : public CCPRTest {
void onRun(skiatest::Reporter* reporter, CCPRPathDrawer& ccpr) override {
REPORTER_ASSERT(reporter, SkPathPriv::TestingOnly_unique(fPath));
for (int i = 0; i < 10000; ++i) {
@@ -847,9 +847,9 @@
ccpr.drawPath(fPath);
}
- // Unref the GrCCPerOpsTaskPaths object.
- auto perOpsTaskPathsMap = ccpr.ccpr()->detachPendingPaths();
- perOpsTaskPathsMap.clear();
+ // Unref the GrCCPerOpListPaths object.
+ auto perOpListPathsMap = ccpr.ccpr()->detachPendingPaths();
+ perOpListPathsMap.clear();
// Now delete the Op and all its draws.
REPORTER_ASSERT(reporter, !SkPathPriv::TestingOnly_unique(fPath));
@@ -857,7 +857,7 @@
REPORTER_ASSERT(reporter, SkPathPriv::TestingOnly_unique(fPath));
}
};
-DEF_CCPR_TEST(CCPR_unrefPerOpsTaskPathsBeforeOps)
+DEF_CCPR_TEST(CCPR_unrefPerOpListPathsBeforeOps)
class CCPRRenderingTest {
public:
diff --git a/tests/GrMipMappedTest.cpp b/tests/GrMipMappedTest.cpp
index eaf5f23..e660556 100644
--- a/tests/GrMipMappedTest.cpp
+++ b/tests/GrMipMappedTest.cpp
@@ -356,7 +356,7 @@
return rtc;
}
-// Test that two opsTasks using the same mipmaps both depend on the same GrTextureResolveRenderTask.
+// Test that two opLists using the same mipmaps both depend on the same GrTextureResolveRenderTask.
DEF_GPUTEST(GrManyDependentsMipMappedTest, reporter, /* options */) {
using CanClearFullscreen = GrRenderTargetContext::CanClearFullscreen;
using Enable = GrContextOptions::Enable;
@@ -369,7 +369,7 @@
ctxOptions.fReduceOpListSplitting = enableSortingAndReduction;
sk_sp<GrContext> context = GrContext::MakeMock(&mockOptions, ctxOptions);
if (!context) {
- ERRORF(reporter, "could not create mock context with fReduceOpsTaskSplitting %s.",
+ ERRORF(reporter, "could not create mock context with fReduceOpListSplitting %s.",
(Enable::kYes == enableSortingAndReduction) ? "enabled" : "disabled");
continue;
}
@@ -402,9 +402,9 @@
mipmapProxy, colorType, nullptr, nullptr, true);
mipmapRTC->clear(nullptr, {.1f,.2f,.3f,.4f}, CanClearFullscreen::kYes);
REPORTER_ASSERT(reporter, mipmapProxy->getLastRenderTask());
- // mipmapProxy's last render task should now just be the opsTask containing the clear.
+ // mipmapProxy's last render task should now just be the opList containing the clear.
REPORTER_ASSERT(reporter,
- mipmapRTC->testingOnly_PeekLastOpsTask() == mipmapProxy->getLastRenderTask());
+ mipmapRTC->testingOnly_PeekLastOpList() == mipmapProxy->getLastRenderTask());
// Mipmaps don't get marked dirty until makeClosed().
REPORTER_ASSERT(reporter, !mipmapProxy->mipMapsAreDirty());
@@ -415,14 +415,14 @@
// Mipmaps should have gotten marked dirty during makeClosed, then marked clean again as
// soon as a GrTextureResolveRenderTask was inserted. The way we know they were resolved is
- // if mipmapProxy->getLastRenderTask() has switched from the opsTask that drew to it, to the
+ // if mipmapProxy->getLastRenderTask() has switched from the opList that drew to it, to the
// task that resolved its mips.
GrRenderTask* initialMipmapRegenTask = mipmapProxy->getLastRenderTask();
REPORTER_ASSERT(reporter, initialMipmapRegenTask);
REPORTER_ASSERT(reporter,
- initialMipmapRegenTask != mipmapRTC->testingOnly_PeekLastOpsTask());
+ initialMipmapRegenTask != mipmapRTC->testingOnly_PeekLastOpList());
REPORTER_ASSERT(reporter,
- rtc1->testingOnly_PeekLastOpsTask()->dependsOn(initialMipmapRegenTask));
+ rtc1->testingOnly_PeekLastOpList()->dependsOn(initialMipmapRegenTask));
REPORTER_ASSERT(reporter, !mipmapProxy->mipMapsAreDirty());
// Draw the now-clean mipmap texture into a second target.
@@ -432,7 +432,7 @@
// Make sure the mipmap texture still has the same regen task.
REPORTER_ASSERT(reporter, mipmapProxy->getLastRenderTask() == initialMipmapRegenTask);
REPORTER_ASSERT(reporter,
- rtc2->testingOnly_PeekLastOpsTask()->dependsOn(initialMipmapRegenTask));
+ rtc2->testingOnly_PeekLastOpList()->dependsOn(initialMipmapRegenTask));
SkASSERT(!mipmapProxy->mipMapsAreDirty());
// Reset everything so we can go again, this time with the first draw not mipmapped.
@@ -441,9 +441,9 @@
// Render something to dirty the mips.
mipmapRTC->clear(nullptr, {.1f,.2f,.3f,.4f}, CanClearFullscreen::kYes);
REPORTER_ASSERT(reporter, mipmapProxy->getLastRenderTask());
- // mipmapProxy's last render task should now just be the opsTask containing the clear.
+ // mipmapProxy's last render task should now just be the opList containing the clear.
REPORTER_ASSERT(reporter,
- mipmapRTC->testingOnly_PeekLastOpsTask() == mipmapProxy->getLastRenderTask());
+ mipmapRTC->testingOnly_PeekLastOpList() == mipmapProxy->getLastRenderTask());
// Mipmaps don't get marked dirty until makeClosed().
REPORTER_ASSERT(reporter, !mipmapProxy->mipMapsAreDirty());
@@ -459,7 +459,7 @@
// Since mips weren't regenerated, the last render task shouldn't have changed.
REPORTER_ASSERT(reporter,
- mipmapRTC->testingOnly_PeekLastOpsTask() == mipmapProxy->getLastRenderTask());
+ mipmapRTC->testingOnly_PeekLastOpList() == mipmapProxy->getLastRenderTask());
// Draw the stil-dirty mipmap texture into a second target with mipmap filtering.
rtc2 = draw_mipmap_into_new_render_target(
@@ -469,9 +469,9 @@
// and that the mipmaps are now clean.
REPORTER_ASSERT(reporter, mipmapProxy->getLastRenderTask());
REPORTER_ASSERT(reporter,
- mipmapRTC->testingOnly_PeekLastOpsTask() != mipmapProxy->getLastRenderTask());
+ mipmapRTC->testingOnly_PeekLastOpList() != mipmapProxy->getLastRenderTask());
REPORTER_ASSERT(reporter,
- rtc2->testingOnly_PeekLastOpsTask()->dependsOn(mipmapProxy->getLastRenderTask()));
+ rtc2->testingOnly_PeekLastOpList()->dependsOn(mipmapProxy->getLastRenderTask()));
SkASSERT(!mipmapProxy->mipMapsAreDirty());
}
}
diff --git a/tests/GrOpListFlushTest.cpp b/tests/GrOpListFlushTest.cpp
index d7d9968..b413317 100644
--- a/tests/GrOpListFlushTest.cpp
+++ b/tests/GrOpListFlushTest.cpp
@@ -25,7 +25,7 @@
return result;
}
-DEF_GPUTEST_FOR_RENDERING_CONTEXTS(GrOpsTaskFlushCount, reporter, ctxInfo) {
+DEF_GPUTEST_FOR_RENDERING_CONTEXTS(GrOpListFlushCount, reporter, ctxInfo) {
GrContext* context = ctxInfo.grContext();
GrGpu* gpu = context->priv().getGpu();
diff --git a/tests/IncrTopoSortTest.cpp b/tests/IncrTopoSortTest.cpp
index 9f5aa66..93fedb7 100644
--- a/tests/IncrTopoSortTest.cpp
+++ b/tests/IncrTopoSortTest.cpp
@@ -11,7 +11,7 @@
#include "tools/ToolUtils.h"
-// A node in the graph. This corresponds to an opsTask in the MDB world.
+// A node in the graph. This corresponds to an opList in the MDB world.
class Node : public SkRefCnt {
public:
char id() const { return fID; }
@@ -80,7 +80,7 @@
bool fVisited; // only used in addEdges()
};
-// The DAG driving the incremental topological sort. This corresponds to the opsTask DAG in
+// The DAG driving the incremental topological sort. This corresponds to the opList DAG in
// the MDB world.
class Graph {
public:
diff --git a/tests/LazyProxyTest.cpp b/tests/LazyProxyTest.cpp
index 4b3e7f3..5aae8e9 100644
--- a/tests/LazyProxyTest.cpp
+++ b/tests/LazyProxyTest.cpp
@@ -48,7 +48,7 @@
REPORTER_ASSERT(fReporter, !fHasClipTexture);
}
- void postFlush(GrDeferredUploadToken, const uint32_t* opsTaskIDs, int numOpsTaskIDs) override {
+ void postFlush(GrDeferredUploadToken, const uint32_t* opListIDs, int numOpListIDs) override {
REPORTER_ASSERT(fReporter, fHasOpTexture);
REPORTER_ASSERT(fReporter, fHasClipTexture);
}
diff --git a/tests/OnFlushCallbackTest.cpp b/tests/OnFlushCallbackTest.cpp
index dd699da..2079d34 100644
--- a/tests/OnFlushCallbackTest.cpp
+++ b/tests/OnFlushCallbackTest.cpp
@@ -231,7 +231,7 @@
static const GrColor kColors[kMaxIDs];
int fID;
- // The Atlased ops have an internal singly-linked list of ops that land in the same opsTask
+ // The Atlased ops have an internal singly-linked list of ops that land in the same opList
AtlasedRectOp* fNext;
typedef NonAARectOp INHERITED;
@@ -274,17 +274,17 @@
fDone = true;
}
- // Insert the new op in an internal singly-linked list for 'opsTaskID'
- void addOp(uint32_t opsTaskID, AtlasedRectOp* op) {
+ // Insert the new op in an internal singly-linked list for 'opListID'
+ void addOp(uint32_t opListID, AtlasedRectOp* op) {
LinkedListHeader* header = nullptr;
for (int i = 0; i < fOps.count(); ++i) {
- if (opsTaskID == fOps[i].fID) {
+ if (opListID == fOps[i].fID) {
header = &(fOps[i]);
}
}
if (!header) {
- fOps.push_back({opsTaskID, nullptr});
+ fOps.push_back({opListID, nullptr});
header = &(fOps[fOps.count()-1]);
}
@@ -334,15 +334,15 @@
* This callback creates the atlas and updates the AtlasedRectOps to read from it
*/
void preFlush(GrOnFlushResourceProvider* resourceProvider,
- const uint32_t* opsTaskIDs,
- int numOpsTaskIDs,
+ const uint32_t* opListIDs,
+ int numOpListIDs,
SkTArray<std::unique_ptr<GrRenderTargetContext>>* results) override {
SkASSERT(!results->count());
- // Until MDB is landed we will most-likely only have one opsTask.
+ // Until MDB is landed we will most-likely only have one opList.
SkTDArray<LinkedListHeader*> lists;
- for (int i = 0; i < numOpsTaskIDs; ++i) {
- if (LinkedListHeader* list = this->getList(opsTaskIDs[i])) {
+ for (int i = 0; i < numOpListIDs; ++i) {
+ if (LinkedListHeader* list = this->getList(opListIDs[i])) {
lists.push_back(list);
}
}
@@ -407,9 +407,9 @@
AtlasedRectOp* fHead;
} LinkedListHeader;
- LinkedListHeader* getList(uint32_t opsTaskID) {
+ LinkedListHeader* getList(uint32_t opListID) {
for (int i = 0; i < fOps.count(); ++i) {
- if (opsTaskID == fOps[i].fID) {
+ if (opListID == fOps[i].fID) {
return &(fOps[i]);
}
}
@@ -420,10 +420,10 @@
// The AtlasedRectOps have yet to execute (and this class doesn't own them) so just
// forget about them in the laziest way possible.
header->fHead = nullptr;
- header->fID = 0; // invalid opsTask ID
+ header->fID = 0; // invalid opList ID
}
- // Each opsTask containing AtlasedRectOps gets its own internal singly-linked list
+ // Each opList containing AtlasedRectOps gets its own internal singly-linked list
SkTDArray<LinkedListHeader> fOps;
// The fully lazy proxy for the atlas
@@ -456,12 +456,12 @@
AtlasedRectOp* sparePtr = op.get();
- uint32_t opsTaskID;
+ uint32_t opListID;
rtc->priv().testingOnly_addDrawOp(GrNoClip(), std::move(op),
- [&opsTaskID](GrOp* op, uint32_t id) { opsTaskID = id; });
- SkASSERT(SK_InvalidUniqueID != opsTaskID);
+ [&opListID](GrOp* op, uint32_t id) { opListID = id; });
+ SkASSERT(SK_InvalidUniqueID != opListID);
- object->addOp(opsTaskID, sparePtr);
+ object->addOp(opListID, sparePtr);
}
return rtc->asTextureProxyRef();
diff --git a/tests/OpChainTest.cpp b/tests/OpChainTest.cpp
index 1cbc437..90acfa7 100644
--- a/tests/OpChainTest.cpp
+++ b/tests/OpChainTest.cpp
@@ -9,7 +9,7 @@
#include "src/gpu/GrContextPriv.h"
#include "src/gpu/GrMemoryPool.h"
#include "src/gpu/GrOpFlushState.h"
-#include "src/gpu/GrOpsTask.h"
+#include "src/gpu/GrRenderTargetOpList.h"
#include "src/gpu/ops/GrOp.h"
#include "tests/Test.h"
@@ -205,7 +205,7 @@
GrOpFlushState flushState(context->priv().getGpu(),
context->priv().resourceProvider(),
&tracker);
- GrOpsTask opsTask(sk_ref_sp(context->priv().opMemoryPool()),
+ GrRenderTargetOpList opList(sk_ref_sp(context->priv().opMemoryPool()),
sk_ref_sp(proxy->asRenderTargetProxy()),
context->priv().auditTrail());
// This assumes the particular values of kRanges.
@@ -221,14 +221,14 @@
range.fOffset += pos;
auto op = TestOp::Make(context.get(), value, range, result, &combinable);
op->writeResult(validResult);
- opsTask.addOp(std::move(op),
- GrTextureResolveManager(context->priv().drawingManager()),
- *context->priv().caps());
+ opList.addOp(std::move(op),
+ GrTextureResolveManager(context->priv().drawingManager()),
+ *context->priv().caps());
}
- opsTask.makeClosed(*context->priv().caps());
- opsTask.prepare(&flushState);
- opsTask.execute(&flushState);
- opsTask.endFlush();
+ opList.makeClosed(*context->priv().caps());
+ opList.prepare(&flushState);
+ opList.execute(&flushState);
+ opList.endFlush();
#if 0 // Useful to repeat a random configuration that fails the test while debugger attached.
if (!std::equal(result, result + result_width(), validResult)) {
repeat = true;
diff --git a/tests/ResourceAllocatorTest.cpp b/tests/ResourceAllocatorTest.cpp
index dfc2b30..7d0cc47 100644
--- a/tests/ResourceAllocatorTest.cpp
+++ b/tests/ResourceAllocatorTest.cpp
@@ -83,7 +83,7 @@
alloc.incOps();
alloc.addInterval(p2.get(), 1, 2, GrResourceAllocator::ActualUse::kYes);
alloc.incOps();
- alloc.markEndOfOpsTask(0);
+ alloc.markEndOfOpList(0);
alloc.determineRecyclability();
@@ -115,7 +115,7 @@
alloc.addInterval(p1.get(), 0, 2, GrResourceAllocator::ActualUse::kYes);
alloc.addInterval(p2.get(), 3, 5, GrResourceAllocator::ActualUse::kYes);
- alloc.markEndOfOpsTask(0);
+ alloc.markEndOfOpList(0);
alloc.determineRecyclability();
@@ -329,7 +329,7 @@
alloc.addInterval(p2.get(), 0, 1, GrResourceAllocator::ActualUse::kNo);
alloc.addInterval(p3.get(), 0, 1, GrResourceAllocator::ActualUse::kNo);
alloc.incOps();
- alloc.markEndOfOpsTask(0);
+ alloc.markEndOfOpList(0);
alloc.determineRecyclability();
@@ -344,8 +344,8 @@
REPORTER_ASSERT(reporter, p3->isInstantiated());
}
-// Set up so there are two opsTasks that need to be flushed but the resource allocator thinks
-// it is over budget. The two opsTasks should be flushed separately and the opsTask indices
+// Set up so there are two opLists that need to be flushed but the resource allocator thinks
+// it is over budget. The two opLists should be flushed separately and the opList indices
// returned from assign should be correct.
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ResourceAllocatorOverBudgetTest, reporter, ctxInfo) {
GrContext* context = ctxInfo.grContext();
@@ -377,13 +377,13 @@
alloc.incOps();
alloc.addInterval(p2.get(), 1, 1, GrResourceAllocator::ActualUse::kYes);
alloc.incOps();
- alloc.markEndOfOpsTask(0);
+ alloc.markEndOfOpList(0);
alloc.addInterval(p3.get(), 2, 2, GrResourceAllocator::ActualUse::kYes);
alloc.incOps();
alloc.addInterval(p4.get(), 3, 3, GrResourceAllocator::ActualUse::kYes);
alloc.incOps();
- alloc.markEndOfOpsTask(1);
+ alloc.markEndOfOpList(1);
int startIndex, stopIndex;
GrResourceAllocator::AssignError error;
diff --git a/tools/DDLTileHelper.cpp b/tools/DDLTileHelper.cpp
index eb50f4e..236dbbd 100644
--- a/tools/DDLTileHelper.cpp
+++ b/tools/DDLTileHelper.cpp
@@ -36,7 +36,7 @@
std::unique_ptr<SkDeferredDisplayList> ddl = recorder.detach();
if (ddl->priv().numRenderTasks()) {
// TODO: remove this once skbug.com/8424 is fixed. If the DDL resulting from the
- // reinflation of the SKPs contains opsTasks that means some image subset operation
+ // reinflation of the SKPs contains opLists that means some image subset operation
// created a draw.
fReconstitutedPicture.reset();
}
diff --git a/tools/debugger/DebugCanvas.cpp b/tools/debugger/DebugCanvas.cpp
index 0aec409..24d467c 100644
--- a/tools/debugger/DebugCanvas.cpp
+++ b/tools/debugger/DebugCanvas.cpp
@@ -172,7 +172,7 @@
at->getBoundsByClientID(&childrenBounds, index);
} else {
// the client wants us to draw the mth op
- at->getBoundsByOpsTaskID(&childrenBounds.push_back(), m);
+ at->getBoundsByOpListID(&childrenBounds.push_back(), m);
}
SkPaint paint;
paint.setStyle(SkPaint::kStroke_Style);
@@ -270,12 +270,12 @@
this->cleanupAuditTrail(canvas);
}
-void DebugCanvas::toJSONOpsTask(SkJSONWriter& writer, int n, SkCanvas* canvas) {
+void DebugCanvas::toJSONOpList(SkJSONWriter& writer, int n, SkCanvas* canvas) {
this->drawAndCollectOps(n, canvas);
GrAuditTrail* at = this->getAuditTrail(canvas);
if (at) {
- GrAuditTrail::AutoManageOpsTask enable(at);
+ GrAuditTrail::AutoManageOpList enable(at);
at->toJson(writer);
} else {
writer.beginObject();
diff --git a/tools/debugger/DebugCanvas.h b/tools/debugger/DebugCanvas.h
index b7c314f..0041a7b 100644
--- a/tools/debugger/DebugCanvas.h
+++ b/tools/debugger/DebugCanvas.h
@@ -100,7 +100,7 @@
*/
void toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager, int n, SkCanvas*);
- void toJSONOpsTask(SkJSONWriter& writer, int n, SkCanvas*);
+ void toJSONOpList(SkJSONWriter& writer, int n, SkCanvas*);
void detachCommands(SkTDArray<DrawCommand*>* dst) { fCommandVector.swap(*dst); }
diff --git a/tools/flags/CommonFlags.h b/tools/flags/CommonFlags.h
index 83ed083..c7380a2 100644
--- a/tools/flags/CommonFlags.h
+++ b/tools/flags/CommonFlags.h
@@ -31,8 +31,8 @@
* --noGS
* --pr
* --disableDriverCorrectnessWorkarounds
- * --reduceOpsTaskSplitting
- * --dontReduceOpsTaskSplitting
+ * --reduceOpListSplitting
+ * --dontReduceOpListSplitting
*/
void SetCtxOptionsFromCommonFlags(struct GrContextOptions*);
diff --git a/tools/flags/CommonFlagsGpu.cpp b/tools/flags/CommonFlagsGpu.cpp
index 7ed0d30..1c4019b 100644
--- a/tools/flags/CommonFlagsGpu.cpp
+++ b/tools/flags/CommonFlagsGpu.cpp
@@ -29,8 +29,8 @@
static DEFINE_bool(disableDriverCorrectnessWorkarounds, false,
"Disables all GPU driver correctness workarounds");
-static DEFINE_bool(reduceOpsTaskSplitting, false, "Improve opsTask sorting");
-static DEFINE_bool(dontReduceOpsTaskSplitting, false, "Allow more opsTask splitting");
+static DEFINE_bool(reduceOpListSplitting, false, "Improve opList sorting");
+static DEFINE_bool(dontReduceOpListSplitting, false, "Allow more opList splitting");
static GpuPathRenderers get_named_pathrenderers_flags(const char* name) {
if (!strcmp(name, "none")) {
@@ -89,10 +89,10 @@
ctxOptions->fGpuPathRenderers = collect_gpu_path_renderers_from_flags();
ctxOptions->fDisableDriverCorrectnessWorkarounds = FLAGS_disableDriverCorrectnessWorkarounds;
- if (FLAGS_reduceOpsTaskSplitting) {
- SkASSERT(!FLAGS_dontReduceOpsTaskSplitting);
+ if (FLAGS_reduceOpListSplitting) {
+ SkASSERT(!FLAGS_dontReduceOpListSplitting);
ctxOptions->fReduceOpListSplitting = GrContextOptions::Enable::kYes;
- } else if (FLAGS_dontReduceOpsTaskSplitting) {
+ } else if (FLAGS_dontReduceOpListSplitting) {
ctxOptions->fReduceOpListSplitting = GrContextOptions::Enable::kNo;
}
}
diff --git a/tools/gpu/GrTest.cpp b/tools/gpu/GrTest.cpp
index 70d8692..465acf1 100644
--- a/tools/gpu/GrTest.cpp
+++ b/tools/gpu/GrTest.cpp
@@ -60,8 +60,8 @@
SkDEBUGCODE(GrSingleOwner::AutoEnforce debug_SingleOwner(fRenderTargetContext->singleOwner());)
-uint32_t GrRenderTargetContextPriv::testingOnly_getOpsTaskID() {
- return fRenderTargetContext->getOpsTask()->uniqueID();
+uint32_t GrRenderTargetContextPriv::testingOnly_getOpListID() {
+ return fRenderTargetContext->getOpList()->uniqueID();
}
void GrRenderTargetContextPriv::testingOnly_addDrawOp(std::unique_ptr<GrDrawOp> op) {
diff --git a/tools/mdbviz/Model.cpp b/tools/mdbviz/Model.cpp
index 0243d00..3cb01f0 100644
--- a/tools/mdbviz/Model.cpp
+++ b/tools/mdbviz/Model.cpp
@@ -21,7 +21,7 @@
}
Model::~Model() {
- this->resetOpsTask();
+ this->resetOpList();
}
Model::ErrorCode Model::load(const char* filename) {
@@ -42,7 +42,7 @@
temp->setPicture(pic.get());
pic->playback(temp.get());
temp->setPicture(nullptr);
- this->resetOpsTask();
+ this->resetOpList();
temp->detachCommands(&fOps);
}
@@ -105,7 +105,7 @@
canvas.restoreToCount(saveCount);
}
-void Model::resetOpsTask() {
+void Model::resetOpList() {
for (int i = 0; i < fOps.count(); ++i) {
delete fOps[i];
}
diff --git a/tools/mdbviz/Model.h b/tools/mdbviz/Model.h
index f3bc99d..debb4f4 100644
--- a/tools/mdbviz/Model.h
+++ b/tools/mdbviz/Model.h
@@ -27,7 +27,7 @@
// Replace the list of draw ops by reading the provided skp filename and
// reset the Skia draw state. It is up to the view portion to update itself
- // after this call (i.e., rebuild the opsTask view).
+ // after this call (i.e., rebuild the opList view).
ErrorCode load(const char* filename);
// Update the rendering state to the provided op
@@ -48,7 +48,7 @@
protected:
// draw the ops up to (and including) the index-th op
void drawTo(int index);
- void resetOpsTask();
+ void resetOpList();
private:
SkTDArray<DrawCommand*> fOps;
diff --git a/tools/mdbviz/mainwindow.cpp b/tools/mdbviz/mainwindow.cpp
index e36f81a..5f5746b 100644
--- a/tools/mdbviz/mainwindow.cpp
+++ b/tools/mdbviz/mainwindow.cpp
@@ -27,8 +27,8 @@
}
}
-void MainWindow::setupOpsTaskWidget() {
- fOpsTaskWidget->clear();
+void MainWindow::setupOpListWidget() {
+ fOpListWidget->clear();
QTreeWidgetItem* item = nullptr;
SkTDArray<QTreeWidgetItem*> parents;
@@ -45,7 +45,7 @@
}
if (parents.isEmpty()) {
- fOpsTaskWidget->addTopLevelItem(item);
+ fOpListWidget->addTopLevelItem(item);
} else {
parents.top()->addChild(item);
}
@@ -55,8 +55,8 @@
}
}
- fOpsTaskWidget->setCurrentItem(item);
- fOpsTaskWidget->expandToDepth(100);
+ fOpListWidget->setCurrentItem(item);
+ fOpListWidget->expandToDepth(100);
}
void MainWindow::presentCurrentRenderState() {
@@ -87,7 +87,7 @@
return;
}
- this->setupOpsTaskWidget();
+ this->setupOpListWidget();
this->presentCurrentRenderState();
#ifndef QT_NO_CURSOR
@@ -147,25 +147,25 @@
// Op List Window
{
- QDockWidget* opsTaskDock = new QDockWidget("Ops", this);
- opsTaskDock->setAllowedAreas(Qt::LeftDockWidgetArea);
+ QDockWidget* opListDock = new QDockWidget("Ops", this);
+ opListDock->setAllowedAreas(Qt::LeftDockWidgetArea);
- fOpsTaskWidget = new QTreeWidget(opsTaskDock);
+ fOpListWidget = new QTreeWidget(opListDock);
QTreeWidgetItem* headerItem = new QTreeWidgetItem;
headerItem->setText(0, "Index");
headerItem->setText(1, "Op Name");
- fOpsTaskWidget->setHeaderItem(headerItem);
+ fOpListWidget->setHeaderItem(headerItem);
- fOpsTaskWidget->header()->setSectionResizeMode(0, QHeaderView::ResizeToContents);
- fOpsTaskWidget->header()->setSectionResizeMode(1, QHeaderView::ResizeToContents);
+ fOpListWidget->header()->setSectionResizeMode(0, QHeaderView::ResizeToContents);
+ fOpListWidget->header()->setSectionResizeMode(1, QHeaderView::ResizeToContents);
- opsTaskDock->setWidget(fOpsTaskWidget);
- this->addDockWidget(Qt::LeftDockWidgetArea, opsTaskDock);
+ opListDock->setWidget(fOpListWidget);
+ this->addDockWidget(Qt::LeftDockWidgetArea, opListDock);
- fViewMenu->addAction(opsTaskDock->toggleViewAction());
+ fViewMenu->addAction(opListDock->toggleViewAction());
- connect(fOpsTaskWidget, SIGNAL(currentItemChanged(QTreeWidgetItem*,QTreeWidgetItem*)),
+ connect(fOpListWidget, SIGNAL(currentItemChanged(QTreeWidgetItem*,QTreeWidgetItem*)),
this, SLOT(onCurrentItemChanged(QTreeWidgetItem*, QTreeWidgetItem*)));
}
diff --git a/tools/mdbviz/mainwindow.h b/tools/mdbviz/mainwindow.h
index f80b157..7fa6152 100644
--- a/tools/mdbviz/mainwindow.h
+++ b/tools/mdbviz/mainwindow.h
@@ -32,7 +32,7 @@
private:
void loadFile(const QString &fileName);
- void setupOpsTaskWidget();
+ void setupOpListWidget();
void presentCurrentRenderState();
@@ -46,7 +46,7 @@
QImage fImage;
QLabel* fImageLabel;
- QTreeWidget* fOpsTaskWidget;
+ QTreeWidget* fOpListWidget;
QMenu* fViewMenu;
diff --git a/tools/skiaserve/Request.cpp b/tools/skiaserve/Request.cpp
index f2dbab0..dc0b40d 100644
--- a/tools/skiaserve/Request.cpp
+++ b/tools/skiaserve/Request.cpp
@@ -229,13 +229,13 @@
return stream.detachAsData();
}
-sk_sp<SkData> Request::getJsonOpsTask(int n) {
+sk_sp<SkData> Request::getJsonOpList(int n) {
SkCanvas* canvas = this->getCanvas();
SkASSERT(fGPUEnabled);
SkDynamicMemoryWStream stream;
SkJSONWriter writer(&stream, SkJSONWriter::Mode::kFast);
- fDebugCanvas->toJSONOpsTask(writer, n, canvas);
+ fDebugCanvas->toJSONOpList(writer, n, canvas);
writer.flush();
return stream.detachAsData();
diff --git a/tools/skiaserve/Request.h b/tools/skiaserve/Request.h
index e3dfada..aef69c3 100644
--- a/tools/skiaserve/Request.h
+++ b/tools/skiaserve/Request.h
@@ -51,7 +51,7 @@
sk_sp<SkData> getJsonOps(int n);
// Returns a json list of ops as an SkData
- sk_sp<SkData> getJsonOpsTask(int n);
+ sk_sp<SkData> getJsonOpList(int n);
// Returns json with the viewMatrix and clipRect
sk_sp<SkData> getJsonInfo(int n);
diff --git a/tools/skiaserve/urlhandlers/OpsHandler.cpp b/tools/skiaserve/urlhandlers/OpsHandler.cpp
index 0c55419..556c2a9 100644
--- a/tools/skiaserve/urlhandlers/OpsHandler.cpp
+++ b/tools/skiaserve/urlhandlers/OpsHandler.cpp
@@ -31,7 +31,7 @@
if (0 == strcmp(method, MHD_HTTP_METHOD_GET)) {
int n = request->getLastOp();
- sk_sp<SkData> data(request->getJsonOpsTask(n));
+ sk_sp<SkData> data(request->getJsonOpList(n));
return SendData(connection, data.get(), "application/json");
}
