Loosen requirement that there be only one GrDrawTarget

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 44 matching lines @@
 #define ASSERT_OWNED_RESOURCE(R) SkASSERT(!(R) || (R)->getContext() == this)
 #define RETURN_IF_ABANDONED if (fDrawingMgr.abandoned()) { return; }
 #define RETURN_FALSE_IF_ABANDONED if (fDrawingMgr.abandoned()) { return false; }
 #define RETURN_NULL_IF_ABANDONED if (fDrawingMgr.abandoned()) { return nullptr; }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 
 void GrContext::DrawingMgr::init(GrContext* context) {
     fContext = context;
-    fDrawTarget = new GrDrawTarget(context->getGpu(), context->resourceProvider());
 }
 
 void GrContext::DrawingMgr::cleanup() {
-    SkSafeSetNull(fDrawTarget);
+    for (int i = 0; i < fDrawTargets.count(); ++i) {
+        fDrawTargets[i]->unref();
+    }
+
+    fDrawTargets.reset();
+
     delete fNVPRTextContext;
     fNVPRTextContext = nullptr;
+
     for (int i = 0; i < kNumPixelGeometries; ++i) {
         delete fTextContexts[i][0];
         fTextContexts[i][0] = nullptr;
         delete fTextContexts[i][1];
         fTextContexts[i][1] = nullptr;
     }
 }
 
 GrContext::DrawingMgr::~DrawingMgr() {
     this->cleanup();
 }
 
 void GrContext::DrawingMgr::abandon() {
+    fAbandoned = true;
     this->cleanup();
 }
 
 void GrContext::DrawingMgr::reset() {
-    if (fDrawTarget) {
-        fDrawTarget->reset();
+    for (int i = 0; i < fDrawTargets.count(); ++i) {
+        fDrawTargets[i]->reset();
     }
 }
 
 void GrContext::DrawingMgr::flush() {
-    if (fDrawTarget) {
-        fDrawTarget->flush();
+    for (int i = 0; i < fDrawTargets.count(); ++i) {
+        fDrawTargets[i]->flush();
     }
 }
 
 GrTextContext* GrContext::DrawingMgr::textContext(const SkSurfaceProps& props,
                                                   GrRenderTarget* rt) {
     if (this->abandoned()) {
         return nullptr;
     }
 
     SkASSERT(props.pixelGeometry() < kNumPixelGeometries);
@@ skipping 11 matching lines @@
         }
     }
 
     if (!fTextContexts[props.pixelGeometry()][useDIF]) {
         fTextContexts[props.pixelGeometry()][useDIF] = GrAtlasTextContext::Create(fContext, props);
     }
 
     return fTextContexts[props.pixelGeometry()][useDIF];
 }
 
+GrDrawTarget* GrContext::DrawingMgr::newDrawTarget(GrRenderTarget* rt) {
+    SkASSERT(fContext);
+
+    // When MDB is disabled we always just return the single drawTarget
+#ifndef ENABLE_MDB
+    if (fDrawTargets.count()) {
+        SkASSERT(fDrawTargets.count() == 1);
+        // DrawingMgr 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;
+
+    // DrawingMgr gets the creation ref - this ref is for the caller 
+    return SkRef(dt);
+}
+
 GrDrawContext* GrContext::DrawingMgr::drawContext(GrRenderTarget* rt, 
                                                   const SkSurfaceProps* surfaceProps) {
     if (this->abandoned()) {
         return nullptr;
     }
 
-    return new GrDrawContext(fContext, rt, fDrawTarget, surfaceProps);
+    return new GrDrawContext(fContext, rt, surfaceProps);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 
 GrContext* GrContext::Create(GrBackend backend, GrBackendContext backendContext) {
     GrContextOptions defaultOptions;
     return Create(backend, backendContext, defaultOptions);
 }
 
@@ skipping 614 matching lines @@
 
 void GrContext::setResourceCacheLimits(int maxTextures, size_t maxTextureBytes) {
     fResourceCache->setLimits(maxTextures, maxTextureBytes);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 void GrContext::dumpMemoryStatistics(SkTraceMemoryDump* traceMemoryDump) const {
     fResourceCache->dumpMemoryStatistics(traceMemoryDump);
 }