Add the machinery to GrDrawTarget to enable topological sorting

src/gpu/GrContext.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrContext.h"
 
@@ skipping 27 matching lines @@
 #include "GrVertices.h"
 #include "SkDashPathPriv.h"
 #include "SkConfig8888.h"
 #include "SkGrPriv.h"
 #include "SkRRect.h"
 #include "SkStrokeRec.h"
 #include "SkSurfacePriv.h"
 #include "SkTLazy.h"
 #include "SkTLS.h"
 #include "SkTraceEvent.h"
-
+#include "SkTTopoSort.h"
 
 #include "batches/GrBatch.h"
 
 #include "effects/GrConfigConversionEffect.h"
 #include "effects/GrDashingEffect.h"
 #include "effects/GrSingleTextureEffect.h"
 
 #define ASSERT_OWNED_RESOURCE(R) SkASSERT(!(R) || (R)->getContext() == this)
 #define RETURN_IF_ABANDONED if (fDrawingManager->abandoned()) { return; }
 #define RETURN_FALSE_IF_ABANDONED if (fDrawingManager->abandoned()) { return false; }
@@ skipping 29 matching lines @@
     this->cleanup();
 }
 
 void GrDrawingManager::reset() {
     for (int i = 0; i < fDrawTargets.count(); ++i) {
         fDrawTargets[i]->reset();
     }
 }
 
 void GrDrawingManager::flush() {
+
+    struct TopoSortTraits {
+        static void Output(GrDrawTarget* dt, int /* index */) {
+            dt->setFlag(GrDrawTarget::kWasOutput_Flag);
+        }
+        static bool WasOutput(const GrDrawTarget* dt) {
+            return dt->isSetFlag(GrDrawTarget::kWasOutput_Flag);
+        }
+        static void SetTempMark(GrDrawTarget* dt) {
+            dt->setFlag(GrDrawTarget::kTempMark_Flag);
+        }
+        static void ResetTempMark(GrDrawTarget* dt) {
+            dt->resetFlag(GrDrawTarget::kTempMark_Flag);
+        }
+        static bool IsTempMarked(const GrDrawTarget* dt) {
+            return dt->isSetFlag(GrDrawTarget::kTempMark_Flag);
+        }
+        static int NumDependencies(const GrDrawTarget* dt) {
+            return dt->numDependencies();
+        }
+        static GrDrawTarget* Dependency(GrDrawTarget* dt, int index) {
+            return dt->dependency(index);
+        }
+    };
+
+    SkDEBUGCODE(bool result =) SkTTopoSort<GrDrawTarget, TopoSortTraits>(&fDrawTargets);
+    SkASSERT(result);
+
     for (int i = 0; i < fDrawTargets.count(); ++i) {
         fDrawTargets[i]->flush();
     }
+
+#ifndef ENABLE_MDB
+    // When MDB is disabled we keep reusing the same drawTarget
+    if (fDrawTargets.count()) {
+        SkASSERT(fDrawTargets.count() == 1);
+        fDrawTargets[0]->resetFlag(GrDrawTarget::kWasOutput_Flag);
+    }
+#endif
 }
 
 GrTextContext* GrDrawingManager::textContext(const SkSurfaceProps& props,
                                              GrRenderTarget* rt) {
     if (this->abandoned()) {
         return nullptr;
     }
 
     SkASSERT(props.pixelGeometry() < kNumPixelGeometries);
     bool useDIF = props.isUseDeviceIndependentFonts();
@@ skipping 13 matching lines @@
     if (!fTextContexts[props.pixelGeometry()][useDIF]) {
         fTextContexts[props.pixelGeometry()][useDIF] = GrAtlasTextContext::Create(fContext, props);
     }
 
     return fTextContexts[props.pixelGeometry()][useDIF];
 }
 
 GrDrawTarget* GrDrawingManager::newDrawTarget(GrRenderTarget* rt) {
     SkASSERT(fContext);
 
+#ifndef ENABLE_MDB
     // When MDB is disabled we always just return the single drawTarget
-#ifndef ENABLE_MDB
     if (fDrawTargets.count()) {
         SkASSERT(fDrawTargets.count() == 1);
         // DrawingManager gets the creation ref - this ref is for the caller
         return SkRef(fDrawTargets[0]);
     }
 #endif
 
     GrDrawTarget* dt = new GrDrawTarget(fContext->getGpu(), fContext->resourceProvider());
 
     *fDrawTargets.append() = dt;
@@ skipping 645 matching lines @@
 
 void GrContext::setResourceCacheLimits(int maxTextures, size_t maxTextureBytes) {
     fResourceCache->setLimits(maxTextures, maxTextureBytes);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 void GrContext::dumpMemoryStatistics(SkTraceMemoryDump* traceMemoryDump) const {
     fResourceCache->dumpMemoryStatistics(traceMemoryDump);
 }