Remove DrawingMgr shims from GrContext

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"
 
 #include "GrBatchFontCache.h"
 #include "GrBatchFlushState.h"
 #include "GrBatchTest.h"
 #include "GrCaps.h"
 #include "GrContextOptions.h"
 #include "GrDefaultGeoProcFactory.h"
+#include "GrDrawingManager.h"
 #include "GrDrawContext.h"
 #include "GrDrawTarget.h"
 #include "GrGpuResource.h"
 #include "GrGpuResourcePriv.h"
 #include "GrGpu.h"
 #include "GrIndexBuffer.h"
 #include "GrLayerCache.h"
 #include "GrOvalRenderer.h"
 #include "GrPathRenderer.h"
 #include "GrPathUtils.h"
@@ skipping 19 matching lines @@
 #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; }
+#define RETURN_IF_ABANDONED if (fDrawingManager->abandoned()) { return; }
+#define RETURN_FALSE_IF_ABANDONED if (fDrawingManager->abandoned()) { return false; }
+#define RETURN_NULL_IF_ABANDONED if (fDrawingManager->abandoned()) { return nullptr; }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 
-void GrContext::DrawingMgr::init(GrContext* context) {
-    fContext = context;
-}
-
-void GrContext::DrawingMgr::cleanup() {
+void GrDrawingManager::cleanup() {
     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() {
+GrDrawingManager::~GrDrawingManager() {
     this->cleanup();
 }
 
-void GrContext::DrawingMgr::abandon() {
+void GrDrawingManager::abandon() {
     fAbandoned = true;
     this->cleanup();
 }
 
-void GrContext::DrawingMgr::reset() {
+void GrDrawingManager::reset() {
     for (int i = 0; i < fDrawTargets.count(); ++i) {
         fDrawTargets[i]->reset();
     }
 }
 
-void GrContext::DrawingMgr::flush() {
+void GrDrawingManager::flush() {
     for (int i = 0; i < fDrawTargets.count(); ++i) {
         fDrawTargets[i]->flush();
     }
 }
 
-GrTextContext* GrContext::DrawingMgr::textContext(const SkSurfaceProps& props,
-                                                  GrRenderTarget* rt) {
+GrTextContext* GrDrawingManager::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];
 }
 
-GrDrawTarget* GrContext::DrawingMgr::newDrawTarget(GrRenderTarget* rt) {
+GrDrawTarget* GrDrawingManager::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
+        // 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;
 
-    // DrawingMgr gets the creation ref - this ref is for the caller 
+    // DrawingManager gets the creation ref - this ref is for the caller 
     return SkRef(dt);
 }
 
-GrDrawContext* GrContext::DrawingMgr::drawContext(GrRenderTarget* rt, 
-                                                  const SkSurfaceProps* surfaceProps) {
+GrDrawContext* GrDrawingManager::drawContext(GrRenderTarget* rt, 
+                                             const SkSurfaceProps* surfaceProps) {
     if (this->abandoned()) {
         return nullptr;
     }
 
-    return new GrDrawContext(fContext, rt, surfaceProps);
+    return new GrDrawContext(this, rt, surfaceProps);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 
 GrContext* GrContext::Create(GrBackend backend, GrBackendContext backendContext) {
     GrContextOptions defaultOptions;
     return Create(backend, backendContext, defaultOptions);
 }
 
@@ skipping 44 matching lines @@
 void GrContext::initCommon() {
     fCaps = SkRef(fGpu->caps());
     fResourceCache = new GrResourceCache(fCaps);
     fResourceCache->setOverBudgetCallback(OverBudgetCB, this);
     fResourceProvider = new GrResourceProvider(fGpu, fResourceCache);
 
     fLayerCache.reset(new GrLayerCache(this));
 
     fDidTestPMConversions = false;
 
-    fDrawingMgr.init(this);
+    fDrawingManager.reset(new GrDrawingManager(this));
 
     // GrBatchFontCache will eventually replace GrFontCache
     fBatchFontCache = new GrBatchFontCache(this);
 
     fTextBlobCache.reset(new GrTextBlobCache(TextBlobCacheOverBudgetCB, this));
 }
 
 GrContext::~GrContext() {
     if (!fGpu) {
         SkASSERT(!fCaps);
         return;
     }
 
     this->flush();
 
-    fDrawingMgr.cleanup();
+    fDrawingManager->cleanup();
 
     for (int i = 0; i < fCleanUpData.count(); ++i) {
         (*fCleanUpData[i].fFunc)(this, fCleanUpData[i].fInfo);
     }
 
     delete fResourceProvider;
     delete fResourceCache;
     delete fBatchFontCache;
 
     fGpu->unref();
     fCaps->unref();
     SkSafeUnref(fPathRendererChain);
     SkSafeUnref(fSoftwarePathRenderer);
 }
 
 void GrContext::abandonContext() {
     fResourceProvider->abandon();
     // abandon first to so destructors
     // don't try to free the resources in the API.
     fResourceCache->abandonAll();
 
     fGpu->contextAbandoned();
 
     // a path renderer may be holding onto resources that
     // are now unusable
     SkSafeSetNull(fPathRendererChain);
     SkSafeSetNull(fSoftwarePathRenderer);
 
-    fDrawingMgr.abandon();
+    fDrawingManager->abandon();
 
     fBatchFontCache->freeAll();
     fLayerCache->freeAll();
     fTextBlobCache->freeAll();
 }
 
 void GrContext::resetContext(uint32_t state) {
     fGpu->markContextDirty(state);
 }
 
@@ skipping 39 matching lines @@
     GrContext* context = reinterpret_cast<GrContext*>(data);
     context->flush();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 void GrContext::flush(int flagsBitfield) {
     RETURN_IF_ABANDONED
 
     if (kDiscard_FlushBit & flagsBitfield) {
-        fDrawingMgr.reset();
+        fDrawingManager->reset();
     } else {
-        fDrawingMgr.flush();
+        fDrawingManager->flush();
     }
     fResourceCache->notifyFlushOccurred();
     fFlushToReduceCacheSize = false;
 }
 
 bool sw_convert_to_premul(GrPixelConfig srcConfig, int width, int height, size_t inRowBytes,
                           const void* inPixels, size_t outRowBytes, void* outPixels) {
     SkSrcPixelInfo srcPI;
     if (!GrPixelConfig2ColorAndProfileType(srcConfig, &srcPI.fColorType, nullptr)) {
         return false;
@@ skipping 367 matching lines @@
         if (dpi >= 250.0f) {
             chosenSampleCount = 4;
         } else {
             chosenSampleCount = 16;
         }
     }
     return chosenSampleCount <= fGpu->caps()->maxSampleCount() ?
         chosenSampleCount : 0;
 }
 
+
+GrDrawContext* GrContext::drawContext(GrRenderTarget* rt, const SkSurfaceProps* surfaceProps) {
+    return fDrawingManager->drawContext(rt, surfaceProps);
+}
+
+bool GrContext::abandoned() const { 
+    return fDrawingManager->abandoned();
+}
+
 namespace {
 void test_pm_conversions(GrContext* ctx, int* pmToUPMValue, int* upmToPMValue) {
     GrConfigConversionEffect::PMConversion pmToUPM;
     GrConfigConversionEffect::PMConversion upmToPM;
     GrConfigConversionEffect::TestForPreservingPMConversions(ctx, &pmToUPM, &upmToPM);
     *pmToUPMValue = pmToUPM;
     *upmToPMValue = upmToPM;
 }
 }
 
@@ skipping 55 matching lines @@
 
 void GrContext::setResourceCacheLimits(int maxTextures, size_t maxTextureBytes) {
     fResourceCache->setLimits(maxTextures, maxTextureBytes);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 void GrContext::dumpMemoryStatistics(SkTraceMemoryDump* traceMemoryDump) const {
     fResourceCache->dumpMemoryStatistics(traceMemoryDump);
 }