Dynamically allocate the GrDrawContexts

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 10 matching lines @@
 #include "GrGpu.h"
 #include "GrIndexBuffer.h"
 #include "GrLayerCache.h"
 #include "GrOvalRenderer.h"
 #include "GrPathRenderer.h"
 #include "GrPathUtils.h"
 #include "GrRenderTargetPriv.h"
 #include "GrResourceCache.h"
 #include "GrResourceProvider.h"
 #include "GrSoftwarePathRenderer.h"
+#include "GrStencilAndCoverTextContext.h"
 #include "GrStrokeInfo.h"
 #include "GrSurfacePriv.h"
 #include "GrTextBlobCache.h"
 #include "GrTexturePriv.h"
 #include "GrTracing.h"
 #include "GrVertices.h"
 #include "SkDashPathPriv.h"
 #include "SkConfig8888.h"
 #include "SkGr.h"
 #include "SkRRect.h"
 #include "SkStrokeRec.h"
 #include "SkSurfacePriv.h"
 #include "SkTLazy.h"
 #include "SkTLS.h"
 #include "SkTraceEvent.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 (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);
+    delete fNVPRTextContext;
+    fNVPRTextContext = nullptr;
     for (int i = 0; i < kNumPixelGeometries; ++i) {
-        SkSafeSetNull(fDrawContext[i][0]);
-        SkSafeSetNull(fDrawContext[i][1]);
+        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() {
-    SkSafeSetNull(fDrawTarget);
-    for (int i = 0; i < kNumPixelGeometries; ++i) {
-        for (int j = 0; j < kNumDFTOptions; ++j) {
-            if (fDrawContext[i][j]) {
-                SkSafeSetNull(fDrawContext[i][j]->fDrawTarget);
-                SkSafeSetNull(fDrawContext[i][j]);
-            }
-        }
-    }
+    this->cleanup();
 }
 
 void GrContext::DrawingMgr::reset() {
     if (fDrawTarget) {
         fDrawTarget->reset();
     }
 }
 
 void GrContext::DrawingMgr::flush() {
     if (fDrawTarget) {
         fDrawTarget->flush();
     }
 }
 
+GrTextContext* GrContext::DrawingMgr::textContext(const SkSurfaceProps& props,
+                                                  GrRenderTarget* rt) {
+    if (this->abandoned()) {
+        return nullptr;
+    }
+
+    SkASSERT(props.pixelGeometry() < kNumPixelGeometries);
+    bool useDIF = props.isUseDeviceIndependentFonts();
+
+    if (useDIF && fContext->caps()->shaderCaps()->pathRenderingSupport() &&
+        rt->isStencilBufferMultisampled()) {
+        GrStencilAttachment* sb = fContext->resourceProvider()->attachStencilAttachment(rt);
+        if (sb) {
+            if (!fNVPRTextContext) {
+                fNVPRTextContext = GrStencilAndCoverTextContext::Create(fContext, props);
+            }
+
+            return fNVPRTextContext;
+        }
+    }
+
+    if (!fTextContexts[props.pixelGeometry()][useDIF]) {
+        fTextContexts[props.pixelGeometry()][useDIF] = GrAtlasTextContext::Create(fContext, props);
+    }
+
+    return fTextContexts[props.pixelGeometry()][useDIF];
+}
+
 GrDrawContext* GrContext::DrawingMgr::drawContext(const SkSurfaceProps* surfaceProps) {
     if (this->abandoned()) {
         return nullptr;
     }
 
-    const SkSurfaceProps props(SkSurfacePropsCopyOrDefault(surfaceProps));
-
-    SkASSERT(props.pixelGeometry() < kNumPixelGeometries);
-    if (!fDrawContext[props.pixelGeometry()][props.isUseDeviceIndependentFonts()]) {
-        fDrawContext[props.pixelGeometry()][props.isUseDeviceIndependentFonts()] =
-                new GrDrawContext(fContext, fDrawTarget, props);
-    }
-
-    // For now, everyone gets a faux creation ref
-    return SkRef(fDrawContext[props.pixelGeometry()][props.isUseDeviceIndependentFonts()]);
+    return new GrDrawContext(fContext, fDrawTarget, surfaceProps);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 
 GrContext* GrContext::Create(GrBackend backend, GrBackendContext backendContext) {
     GrContextOptions defaultOptions;
     return Create(backend, backendContext, defaultOptions);
 }
 
@@ skipping 622 matching lines @@
 
 void GrContext::setResourceCacheLimits(int maxTextures, size_t maxTextureBytes) {
     fResourceCache->setLimits(maxTextures, maxTextureBytes);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 void GrContext::dumpMemoryStatistics(SkTraceMemoryDump* traceMemoryDump) const {
     fResourceCache->dumpMemoryStatistics(traceMemoryDump);
 }