Remove DrawingMgr shims from GrContext

src/gpu/GrDrawContext.cpp

 
 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAtlasTextContext.h"
 #include "GrBatchTest.h"
 #include "GrColor.h"
 #include "GrDrawContext.h"
 #include "GrOvalRenderer.h"
 #include "GrPathRenderer.h"
 #include "GrRenderTarget.h"
 #include "GrRenderTargetPriv.h"
 #include "GrResourceProvider.h"
 #include "GrStencilAndCoverTextContext.h"
 #include "SkSurfacePriv.h"
 
 #include "batches/GrBatch.h"
 #include "batches/GrDrawAtlasBatch.h"
 #include "batches/GrDrawVerticesBatch.h"
 #include "batches/GrRectBatchFactory.h"
 
-#define ASSERT_OWNED_RESOURCE(R) SkASSERT(!(R) || (R)->getContext() == fContext)
-#define RETURN_IF_ABANDONED        if (fContext->abandoned()) { return; }
-#define RETURN_FALSE_IF_ABANDONED  if (fContext->abandoned()) { return false; }
-#define RETURN_NULL_IF_ABANDONED   if (fContext->abandoned()) { return nullptr; }
+#define ASSERT_OWNED_RESOURCE(R) SkASSERT(!(R) || (R)->getContext() == fDrawingMgr->getContext())
+#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; }
 
 class AutoCheckFlush {
 public:
-    AutoCheckFlush(GrContext* context) : fContext(context) { SkASSERT(context); }
-    ~AutoCheckFlush() { fContext->flushIfNecessary(); }
+    AutoCheckFlush(GrContext::DrawingMgr* drawingMgr) : fDrawingMgr(drawingMgr) { 
+        SkASSERT(fDrawingMgr);
+    }
+    ~AutoCheckFlush() { fDrawingMgr->getContext()->flushIfNecessary(); }
 
 private:
-    GrContext* fContext;
+    GrContext::DrawingMgr* fDrawingMgr;
 };
 
 // In MDB mode the reffing of the 'getLastDrawTarget' call's result allows in-progress
 // drawTargets to be picked up and added to by drawContexts lower in the call
 // stack. When this occurs with a closed drawTarget, a new one will be allocated
 // when the drawContext attempts to use it (via getDrawTarget).
-GrDrawContext::GrDrawContext(GrContext* context,
+GrDrawContext::GrDrawContext(GrContext::DrawingMgr* drawingMgr,
                              GrRenderTarget* rt,
                              const SkSurfaceProps* surfaceProps)
-    : fContext(context)
+    : fDrawingMgr(drawingMgr)
     , fRenderTarget(rt)
     , fDrawTarget(SkSafeRef(rt->getLastDrawTarget()))
     , fTextContext(nullptr)
     , fSurfaceProps(SkSurfacePropsCopyOrDefault(surfaceProps)) {
     SkDEBUGCODE(this->validate();)
 }
 
 #ifdef SK_DEBUG
 void GrDrawContext::validate() const {
     SkASSERT(fRenderTarget);
     ASSERT_OWNED_RESOURCE(fRenderTarget);
 
     if (fDrawTarget && !fDrawTarget->isClosed()) {
         SkASSERT(fRenderTarget->getLastDrawTarget() == fDrawTarget);
     }
 }
 #endif
 
 GrDrawContext::~GrDrawContext() {
     SkSafeUnref(fDrawTarget);
 }
 
 GrDrawTarget* GrDrawContext::getDrawTarget() {
     SkDEBUGCODE(this->validate();)
 
     if (!fDrawTarget || fDrawTarget->isClosed()) {
-        fDrawTarget = fContext->newDrawTarget(fRenderTarget);
+        fDrawTarget = fDrawingMgr->newDrawTarget(fRenderTarget);
         fRenderTarget->setLastDrawTarget(fDrawTarget);
     }
 
     return fDrawTarget;
 }
 
 void GrDrawContext::copySurface(GrSurface* src, const SkIRect& srcRect, const SkIPoint& dstPoint) {
     RETURN_IF_ABANDONED
     SkDEBUGCODE(this->validate();)
 
     this->getDrawTarget()->copySurface(fRenderTarget, src, srcRect, dstPoint);
 }
 
 
 void GrDrawContext::drawText(const GrClip& clip, const GrPaint& grPaint,
                              const SkPaint& skPaint,
                              const SkMatrix& viewMatrix,
                              const char text[], size_t byteLength,
                              SkScalar x, SkScalar y, const SkIRect& clipBounds) {
     RETURN_IF_ABANDONED
     SkDEBUGCODE(this->validate();)
 
     if (!fTextContext) {
-        fTextContext = fContext->textContext(fSurfaceProps, fRenderTarget);
+        fTextContext = fDrawingMgr->textContext(fSurfaceProps, fRenderTarget);
     }
 
     fTextContext->drawText(this, fRenderTarget, clip, grPaint, skPaint, viewMatrix,
                            text, byteLength, x, y, clipBounds);
 
 }
 void GrDrawContext::drawPosText(const GrClip& clip, const GrPaint& grPaint,
                                 const SkPaint& skPaint,
                                 const SkMatrix& viewMatrix,
                                 const char text[], size_t byteLength,
                                 const SkScalar pos[], int scalarsPerPosition,
                                 const SkPoint& offset, const SkIRect& clipBounds) {
     RETURN_IF_ABANDONED
     SkDEBUGCODE(this->validate();)
 
     if (!fTextContext) {
-        fTextContext = fContext->textContext(fSurfaceProps, fRenderTarget);
+        fTextContext = fDrawingMgr->textContext(fSurfaceProps, fRenderTarget);
     }
 
     fTextContext->drawPosText(this, fRenderTarget, clip, grPaint, skPaint, viewMatrix, text, byteLength,
                               pos, scalarsPerPosition, offset, clipBounds);
 
 }
 void GrDrawContext::drawTextBlob(const GrClip& clip, const SkPaint& skPaint,
                                  const SkMatrix& viewMatrix, const SkTextBlob* blob,
                                  SkScalar x, SkScalar y,
                                  SkDrawFilter* filter, const SkIRect& clipBounds) {
     RETURN_IF_ABANDONED
     SkDEBUGCODE(this->validate();)
 
     if (!fTextContext) {
-        fTextContext = fContext->textContext(fSurfaceProps, fRenderTarget);
+        fTextContext = fDrawingMgr->textContext(fSurfaceProps, fRenderTarget);
     }
 
     fTextContext->drawTextBlob(this, fRenderTarget,
                                clip, skPaint, viewMatrix, blob, x, y, filter, clipBounds);
 }
 
 void GrDrawContext::drawPathsFromRange(const GrPipelineBuilder* pipelineBuilder,
                                        const SkMatrix& viewMatrix,
                                        const SkMatrix& localMatrix,
                                        GrColor color,
                                        GrPathRange* range,
                                        GrPathRangeDraw* draw,
                                        int /*GrPathRendering::FillType*/ fill) {
     RETURN_IF_ABANDONED
     SkDEBUGCODE(this->validate();)
 
     this->getDrawTarget()->drawPathsFromRange(*pipelineBuilder, viewMatrix, localMatrix, color,
                                               range, draw, (GrPathRendering::FillType) fill);
 }
 
 void GrDrawContext::discard() {
     RETURN_IF_ABANDONED
     SkDEBUGCODE(this->validate();)
 
-    AutoCheckFlush acf(fContext);
+    AutoCheckFlush acf(fDrawingMgr);
     this->getDrawTarget()->discard(fRenderTarget);
 }
 
 void GrDrawContext::clear(const SkIRect* rect,
                           const GrColor color,
                           bool canIgnoreRect) {
     RETURN_IF_ABANDONED
     SkDEBUGCODE(this->validate();)
 
-    AutoCheckFlush acf(fContext);
+    AutoCheckFlush acf(fDrawingMgr);
     this->getDrawTarget()->clear(rect, color, canIgnoreRect, fRenderTarget);
 }
 
 
 void GrDrawContext::drawPaint(const GrClip& clip,
                               const GrPaint& origPaint,
                               const SkMatrix& viewMatrix) {
     RETURN_IF_ABANDONED
     SkDEBUGCODE(this->validate();)
 
@@ skipping 23 matching lines @@
         }
         inverse.mapRect(&r);
         this->drawRect(clip, *paint, viewMatrix, r);
     } else {
         SkMatrix localMatrix;
         if (!viewMatrix.invert(&localMatrix)) {
             SkDebugf("Could not invert matrix\n");
             return;
         }
 
-        AutoCheckFlush acf(fContext);
+        AutoCheckFlush acf(fDrawingMgr);
 
         GrPipelineBuilder pipelineBuilder(*paint, fRenderTarget, clip);
         this->getDrawTarget()->drawNonAARect(pipelineBuilder,
                                              paint->getColor(),
                                              SkMatrix::I(),
                                              r,
                                              localMatrix);
     }
 }
 
@@ skipping 11 matching lines @@
     SkDEBUGCODE(this->validate();)
 
     if (strokeInfo && strokeInfo->isDashed()) {
         SkPath path;
         path.setIsVolatile(true);
         path.addRect(rect);
         this->drawPath(clip, paint, viewMatrix, path, *strokeInfo);
         return;
     }
 
-    AutoCheckFlush acf(fContext);
+    AutoCheckFlush acf(fDrawingMgr);
 
     GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
 
     SkScalar width = nullptr == strokeInfo ? -1 : strokeInfo->getWidth();
 
     // Check if this is a full RT draw and can be replaced with a clear. We don't bother checking
     // cases where the RT is fully inside a stroke.
     if (width < 0) {
         SkRect rtRect;
         pipelineBuilder.getRenderTarget()->getBoundsRect(&rtRect);
@@ skipping 68 matching lines @@
 }
 
 void GrDrawContext::drawNonAARectToRect(const GrClip& clip,
                                         const GrPaint& paint,
                                         const SkMatrix& viewMatrix,
                                         const SkRect& rectToDraw,
                                         const SkRect& localRect) {
     RETURN_IF_ABANDONED
     SkDEBUGCODE(this->validate();)
 
-    AutoCheckFlush acf(fContext);
+    AutoCheckFlush acf(fDrawingMgr);
 
     GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
     this->getDrawTarget()->drawNonAARect(pipelineBuilder,
                                          paint.getColor(),
                                          viewMatrix,
                                          rectToDraw,
                                          localRect);
 }
 
 void GrDrawContext::drawNonAARectWithLocalMatrix(const GrClip& clip,
                                                  const GrPaint& paint,
                                                  const SkMatrix& viewMatrix,
                                                  const SkRect& rectToDraw,
                                                  const SkMatrix& localMatrix) {
     RETURN_IF_ABANDONED
     SkDEBUGCODE(this->validate();)
 
-    AutoCheckFlush acf(fContext);
+    AutoCheckFlush acf(fDrawingMgr);
 
     GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
     this->getDrawTarget()->drawNonAARect(pipelineBuilder,
                                          paint.getColor(),
                                          viewMatrix,
                                          rectToDraw,
                                          localMatrix);
 }
 
 void GrDrawContext::drawVertices(const GrClip& clip,
                                  const GrPaint& paint,
                                  const SkMatrix& viewMatrix,
                                  GrPrimitiveType primitiveType,
                                  int vertexCount,
                                  const SkPoint positions[],
                                  const SkPoint texCoords[],
                                  const GrColor colors[],
                                  const uint16_t indices[],
                                  int indexCount) {
     RETURN_IF_ABANDONED
     SkDEBUGCODE(this->validate();)
 
-    AutoCheckFlush acf(fContext);
+    AutoCheckFlush acf(fDrawingMgr);
 
     GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
 
     // TODO clients should give us bounds
     SkRect bounds;
     if (!bounds.setBoundsCheck(positions, vertexCount)) {
         SkDebugf("drawVertices call empty bounds\n");
         return;
     }
 
@@ skipping 20 matching lines @@
 void GrDrawContext::drawAtlas(const GrClip& clip,
                               const GrPaint& paint,
                               const SkMatrix& viewMatrix,
                               int spriteCount,
                               const SkRSXform xform[],
                               const SkRect texRect[],
                               const SkColor colors[]) {
     RETURN_IF_ABANDONED
     SkDEBUGCODE(this->validate();)
 
-    AutoCheckFlush acf(fContext);
+    AutoCheckFlush acf(fDrawingMgr);
     
     GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
     
     GrDrawAtlasBatch::Geometry geometry;
     geometry.fColor = paint.getColor();
     SkAutoTUnref<GrDrawBatch> batch(GrDrawAtlasBatch::Create(geometry, viewMatrix, spriteCount,
                                                              xform, texRect, colors));
     
     this->getDrawTarget()->drawBatch(pipelineBuilder, batch);
 }
@@ skipping 13 matching lines @@
     }
 
     if (strokeInfo.isDashed()) {
         SkPath path;
         path.setIsVolatile(true);
         path.addRRect(rrect);
         this->drawPath(clip, paint, viewMatrix, path, strokeInfo);
         return;
     }
 
-    AutoCheckFlush acf(fContext);
+    AutoCheckFlush acf(fDrawingMgr);
 
     GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
     GrColor color = paint.getColor();
 
     if (!GrOvalRenderer::DrawRRect(this->getDrawTarget(),
                                    pipelineBuilder,
                                    color,
                                    viewMatrix,
                                    paint.isAntiAlias(),
                                    rrect,
@@ skipping 13 matching lines @@
                                const SkMatrix& viewMatrix,
                                const SkRRect& outer,
                                const SkRRect& inner) {
     RETURN_IF_ABANDONED
     SkDEBUGCODE(this->validate();)
 
     if (outer.isEmpty()) {
        return;
     }
 
-    AutoCheckFlush acf(fContext);
+    AutoCheckFlush acf(fDrawingMgr);
 
     GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
     GrColor color = paint.getColor();
     if (!GrOvalRenderer::DrawDRRect(this->getDrawTarget(),
                                     pipelineBuilder,
                                     color,
                                     viewMatrix,
                                     paint.isAntiAlias(),
                                     outer,
                                     inner)) {
@@ skipping 24 matching lines @@
     }
 
     if (strokeInfo.isDashed()) {
         SkPath path;
         path.setIsVolatile(true);
         path.addOval(oval);
         this->drawPath(clip, paint, viewMatrix, path, strokeInfo);
         return;
     }
 
-    AutoCheckFlush acf(fContext);
+    AutoCheckFlush acf(fDrawingMgr);
 
     GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
     GrColor color = paint.getColor();
 
     if (!GrOvalRenderer::DrawOval(this->getDrawTarget(),
                                   pipelineBuilder,
                                   color,
                                   viewMatrix,
                                   paint.isAntiAlias(),
                                   oval,
@@ skipping 54 matching lines @@
     }
 
     return allEq || allGoE1;
 }
 
 void GrDrawContext::drawBatch(const GrClip& clip,
                               const GrPaint& paint, GrDrawBatch* batch) {
     RETURN_IF_ABANDONED
     SkDEBUGCODE(this->validate();)
 
-    AutoCheckFlush acf(fContext);
+    AutoCheckFlush acf(fDrawingMgr);
 
     GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
     this->getDrawTarget()->drawBatch(pipelineBuilder, batch);
 }
 
 void GrDrawContext::drawPath(const GrClip& clip,
                              const GrPaint& paint,
                              const SkMatrix& viewMatrix,
                              const SkPath& path,
                              const GrStrokeInfo& strokeInfo) {
     RETURN_IF_ABANDONED
     SkDEBUGCODE(this->validate();)
 
     if (path.isEmpty()) {
        if (path.isInverseFillType()) {
            this->drawPaint(clip, paint, viewMatrix);
        }
        return;
     }
 
     GrColor color = paint.getColor();
 
     // Note that internalDrawPath may sw-rasterize the path into a scratch texture.
     // Scratch textures can be recycled after they are returned to the texture
     // cache. This presents a potential hazard for buffered drawing. However,
     // the writePixels that uploads to the scratch will perform a flush so we're
     // OK.
-    AutoCheckFlush acf(fContext);
+    AutoCheckFlush acf(fDrawingMgr);
 
     GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
     if (!strokeInfo.isDashed()) {
         bool useCoverageAA = paint.isAntiAlias() &&
                 !pipelineBuilder.getRenderTarget()->isUnifiedMultisampled();
 
         if (useCoverageAA && strokeInfo.getWidth() < 0 && !path.isConvex()) {
             // Concave AA paths are expensive - try to avoid them for special cases
             SkRect rects[2];
 
@@ skipping 43 matching lines @@
 
     GrPathRendererChain::DrawType type =
         useCoverageAA ? GrPathRendererChain::kColorAntiAlias_DrawType :
                         GrPathRendererChain::kColor_DrawType;
 
     const SkPath* pathPtr = &path;
     SkTLazy<SkPath> tmpPath;
     const GrStrokeInfo* strokeInfoPtr = &strokeInfo;
 
     // Try a 1st time without stroking the path and without allowing the SW renderer
-    GrPathRenderer* pr = fContext->getPathRenderer(target, pipelineBuilder, viewMatrix, *pathPtr,
-                                                    *strokeInfoPtr, false, type);
+    GrPathRenderer* pr = fDrawingMgr->getContext()->getPathRenderer(target, pipelineBuilder,
+                                                                    viewMatrix, *pathPtr,
+                                                                    *strokeInfoPtr, false, type);
 
     GrStrokeInfo dashlessStrokeInfo(strokeInfo, false);
     if (nullptr == pr && strokeInfo.isDashed()) {
         // It didn't work above, so try again with dashed stroke converted to a dashless stroke.
         if (!strokeInfo.applyDashToPath(tmpPath.init(), &dashlessStrokeInfo, *pathPtr)) {
             return;
         }
         pathPtr = tmpPath.get();
         if (pathPtr->isEmpty()) {
             return;
         }
         strokeInfoPtr = &dashlessStrokeInfo;
-        pr = fContext->getPathRenderer(target, pipelineBuilder, viewMatrix, *pathPtr, *strokeInfoPtr,
-                                       false, type);
+        pr = fDrawingMgr->getContext()->getPathRenderer(target, pipelineBuilder, viewMatrix,
+                                                        *pathPtr, *strokeInfoPtr,
+                                                        false, type);
     }
 
     if (nullptr == pr) {
         if (!GrPathRenderer::IsStrokeHairlineOrEquivalent(*strokeInfoPtr, viewMatrix, nullptr) &&
             !strokeInfoPtr->isFillStyle()) {
             // It didn't work above, so try again with stroke converted to a fill.
             if (!tmpPath.isValid()) {
                 tmpPath.init();
             }
             dashlessStrokeInfo.setResScale(SkScalarAbs(viewMatrix.getMaxScale()));
             if (!dashlessStrokeInfo.applyToPath(tmpPath.get(), *pathPtr)) {
                 return;
             }
             pathPtr = tmpPath.get();
             if (pathPtr->isEmpty()) {
                 return;
             }
             dashlessStrokeInfo.setFillStyle();
             strokeInfoPtr = &dashlessStrokeInfo;
         }
 
         // This time, allow SW renderer
-        pr = fContext->getPathRenderer(target, pipelineBuilder, viewMatrix, *pathPtr, *strokeInfoPtr,
-                                       true, type);
+        pr = fDrawingMgr->getContext()->getPathRenderer(target, pipelineBuilder, viewMatrix,
+                                                        *pathPtr, *strokeInfoPtr,
+                                                        true, type);
     }
 
     if (nullptr == pr) {
 #ifdef SK_DEBUG
         SkDebugf("Unable to find path renderer compatible with path.\n");
 #endif
         return;
     }
 
     GrPathRenderer::DrawPathArgs args;
     args.fTarget = target;
-    args.fResourceProvider = fContext->resourceProvider();
+    args.fResourceProvider = fDrawingMgr->getContext()->resourceProvider();
     args.fPipelineBuilder = pipelineBuilder;
     args.fColor = color;
     args.fViewMatrix = &viewMatrix;
     args.fPath = pathPtr;
     args.fStroke = strokeInfoPtr;
     args.fAntiAlias = useCoverageAA;
     pr->drawPath(args);
 }
 
 void GrDrawContext::drawBatch(GrPipelineBuilder* pipelineBuilder, GrDrawBatch* batch) {
     RETURN_IF_ABANDONED
     SkDEBUGCODE(this->validate();)
 
     this->getDrawTarget()->drawBatch(*pipelineBuilder, batch);
 }