Loosen requirement that there be only one GrDrawTarget

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"
@@ skipping 19 matching lines @@
 
 class AutoCheckFlush {
 public:
     AutoCheckFlush(GrContext* context) : fContext(context) { SkASSERT(context); }
     ~AutoCheckFlush() { fContext->flushIfNecessary(); }
 
 private:
     GrContext* fContext;
 };
 
+// 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,
                              GrRenderTarget* rt,
-                             GrDrawTarget* drawTarget,
                              const SkSurfaceProps* surfaceProps)
     : fContext(context)
     , fRenderTarget(rt)
-    , fDrawTarget(SkRef(drawTarget))
+    , fDrawTarget(SkSafeRef(rt->getLastDrawTarget()))
     , fTextContext(nullptr)
     , fSurfaceProps(SkSurfacePropsCopyOrDefault(surfaceProps)) {
     SkDEBUGCODE(this->validate();)
 }
 
-GrDrawContext::~GrDrawContext() {
-    SkSafeUnref(fDrawTarget);
-}
-
 #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);
+        fRenderTarget->setLastDrawTarget(fDrawTarget);
+    }
+
+    return fDrawTarget;
+}
+
 void GrDrawContext::copySurface(GrSurface* src, const SkIRect& srcRect, const SkIPoint& dstPoint) {
     RETURN_IF_ABANDONED
     SkDEBUGCODE(this->validate();)
 
-    fDrawTarget->copySurface(fRenderTarget, src, srcRect, dstPoint);
+    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();)
@@ skipping 41 matching lines @@
 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();)
 
-    fDrawTarget->drawPathsFromRange(*pipelineBuilder, viewMatrix, localMatrix, color, range, draw,
-                                    (GrPathRendering::FillType) fill);
+    this->getDrawTarget()->drawPathsFromRange(*pipelineBuilder, viewMatrix, localMatrix, color,
+                                              range, draw, (GrPathRendering::FillType) fill);
 }
 
 void GrDrawContext::discard() {
     RETURN_IF_ABANDONED
     SkDEBUGCODE(this->validate();)
 
     AutoCheckFlush acf(fContext);
-    fDrawTarget->discard(fRenderTarget);
+    this->getDrawTarget()->discard(fRenderTarget);
 }
 
 void GrDrawContext::clear(const SkIRect* rect,
                           const GrColor color,
                           bool canIgnoreRect) {
     RETURN_IF_ABANDONED
     SkDEBUGCODE(this->validate();)
 
     AutoCheckFlush acf(fContext);
-    fDrawTarget->clear(rect, color, canIgnoreRect, fRenderTarget);
+    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();)
 
     // set rect to be big enough to fill the space, but not super-huge, so we
@@ skipping 25 matching lines @@
     } else {
         SkMatrix localMatrix;
         if (!viewMatrix.invert(&localMatrix)) {
             SkDebugf("Could not invert matrix\n");
             return;
         }
 
         AutoCheckFlush acf(fContext);
 
         GrPipelineBuilder pipelineBuilder(*paint, fRenderTarget, clip);
-        fDrawTarget->drawNonAARect(pipelineBuilder,
-                                   paint->getColor(),
-                                   SkMatrix::I(),
-                                   r,
-                                   localMatrix);
+        this->getDrawTarget()->drawNonAARect(pipelineBuilder,
+                                             paint->getColor(),
+                                             SkMatrix::I(),
+                                             r,
+                                             localMatrix);
     }
 }
 
 static inline bool rect_contains_inclusive(const SkRect& rect, const SkPoint& point) {
     return point.fX >= rect.fLeft && point.fX <= rect.fRight &&
            point.fY >= rect.fTop && point.fY <= rect.fBottom;
 }
 
 void GrDrawContext::drawRect(const GrClip& clip,
                              const GrPaint& paint,
@@ skipping 37 matching lines @@
             // Does the rect bound the RT?
             SkPoint srcSpaceRTQuad[4];
             invM.mapRectToQuad(srcSpaceRTQuad, rtRect);
             if (rect_contains_inclusive(rect, srcSpaceRTQuad[0]) &&
                 rect_contains_inclusive(rect, srcSpaceRTQuad[1]) &&
                 rect_contains_inclusive(rect, srcSpaceRTQuad[2]) &&
                 rect_contains_inclusive(rect, srcSpaceRTQuad[3])) {
                 // Will it blend?
                 GrColor clearColor;
                 if (paint.isConstantBlendedColor(&clearColor)) {
-                    fDrawTarget->clear(nullptr, clearColor, true, fRenderTarget);
+                    this->getDrawTarget()->clear(nullptr, clearColor, true, fRenderTarget);
                     return;
                 }
             }
         }
     }
 
     GrColor color = paint.getColor();
     bool needAA = paint.isAntiAlias() &&
                   !pipelineBuilder.getRenderTarget()->isUnifiedMultisampled();
 
     // The fill path can handle rotation but not skew
     // The stroke path needs the rect to remain axis aligned (no rotation or skew)
     // None of our AA draw rect calls can handle perspective yet
     bool canApplyAA = width >=0 ? viewMatrix.rectStaysRect() : viewMatrix.preservesRightAngles();
 
     if (needAA && canApplyAA) {
         SkASSERT(!viewMatrix.hasPerspective());
         SkAutoTUnref<GrDrawBatch> batch;
         if (width >= 0) {
             batch.reset(GrRectBatchFactory::CreateAAStroke(color, viewMatrix, rect, *strokeInfo));
         } else {
             SkRect devBoundRect;
             viewMatrix.mapRect(&devBoundRect, rect);
             batch.reset(GrRectBatchFactory::CreateAAFill(color, viewMatrix, rect, devBoundRect));
         }
-        fDrawTarget->drawBatch(pipelineBuilder, batch);
+        this->getDrawTarget()->drawBatch(pipelineBuilder, batch);
         return;
     }
 
     if (width >= 0) {
         // Non-AA hairlines are snapped to pixel centers to make which pixels are hit deterministic
         bool snapToPixelCenters = (0 == width && !fRenderTarget->isUnifiedMultisampled());
         SkAutoTUnref<GrDrawBatch> batch(GrRectBatchFactory::CreateNonAAStroke(
                                         color, viewMatrix, rect, width, snapToPixelCenters));
 
         // Depending on sub-pixel coordinates and the particular GPU, we may lose a corner of
         // hairline rects. We jam all the vertices to pixel centers to avoid this, but not when MSAA
         // is enabled because it can cause ugly artifacts.
         pipelineBuilder.setState(GrPipelineBuilder::kSnapVerticesToPixelCenters_Flag,
                                  snapToPixelCenters);
-        fDrawTarget->drawBatch(pipelineBuilder, batch);
+        this->getDrawTarget()->drawBatch(pipelineBuilder, batch);
     } else {
         // filled BW rect
-        fDrawTarget->drawNonAARect(pipelineBuilder, color, viewMatrix, rect);
+        this->getDrawTarget()->drawNonAARect(pipelineBuilder, color, viewMatrix, rect);
     }
 }
 
 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);
 
     GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
-    fDrawTarget->drawNonAARect(pipelineBuilder,
-                               paint.getColor(),
-                               viewMatrix,
-                               rectToDraw,
-                               localRect);
+    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);
 
     GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
-    fDrawTarget->drawNonAARect(pipelineBuilder,
-                               paint.getColor(),
-                               viewMatrix,
-                               rectToDraw,
-                               localMatrix);
+    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[],
@@ skipping 21 matching lines @@
         bounds.outset(0.5f, 0.5f);
     }
 
     GrDrawVerticesBatch::Geometry geometry;
     geometry.fColor = paint.getColor();
     SkAutoTUnref<GrDrawBatch> batch(GrDrawVerticesBatch::Create(geometry, primitiveType, viewMatrix,
                                                                 positions, vertexCount, indices,
                                                                 indexCount, colors, texCoords,
                                                                 bounds));
 
-    fDrawTarget->drawBatch(pipelineBuilder, batch);
+    this->getDrawTarget()->drawBatch(pipelineBuilder, batch);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 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);
     
     GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
     
     GrDrawAtlasBatch::Geometry geometry;
     geometry.fColor = paint.getColor();
     SkAutoTUnref<GrDrawBatch> batch(GrDrawAtlasBatch::Create(geometry, viewMatrix, spriteCount,
                                                              xform, texRect, colors));
     
-    fDrawTarget->drawBatch(pipelineBuilder, batch);
+    this->getDrawTarget()->drawBatch(pipelineBuilder, batch);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void GrDrawContext::drawRRect(const GrClip& clip,
                               const GrPaint& paint,
                               const SkMatrix& viewMatrix,
                               const SkRRect& rrect,
                               const GrStrokeInfo& strokeInfo) {
     RETURN_IF_ABANDONED
     SkDEBUGCODE(this->validate();)
 
     if (rrect.isEmpty()) {
        return;
     }
 
     if (strokeInfo.isDashed()) {
         SkPath path;
         path.setIsVolatile(true);
         path.addRRect(rrect);
         this->drawPath(clip, paint, viewMatrix, path, strokeInfo);
         return;
     }
 
     AutoCheckFlush acf(fContext);
 
     GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
     GrColor color = paint.getColor();
 
-    if (!GrOvalRenderer::DrawRRect(fDrawTarget,
+    if (!GrOvalRenderer::DrawRRect(this->getDrawTarget(),
                                    pipelineBuilder,
                                    color,
                                    viewMatrix,
                                    paint.isAntiAlias(),
                                    rrect,
                                    strokeInfo)) {
         SkPath path;
         path.setIsVolatile(true);
         path.addRRect(rrect);
-        this->internalDrawPath(fDrawTarget, &pipelineBuilder, viewMatrix, color,
+        this->internalDrawPath(this->getDrawTarget(), &pipelineBuilder, viewMatrix, color,
                                paint.isAntiAlias(), path, strokeInfo);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void GrDrawContext::drawDRRect(const GrClip& clip,
                                const GrPaint& paint,
                                const SkMatrix& viewMatrix,
                                const SkRRect& outer,
                                const SkRRect& inner) {
     RETURN_IF_ABANDONED
     SkDEBUGCODE(this->validate();)
 
     if (outer.isEmpty()) {
        return;
     }
 
     AutoCheckFlush acf(fContext);
 
     GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
     GrColor color = paint.getColor();
-    if (!GrOvalRenderer::DrawDRRect(fDrawTarget,
+    if (!GrOvalRenderer::DrawDRRect(this->getDrawTarget(),
                                     pipelineBuilder,
                                     color,
                                     viewMatrix,
                                     paint.isAntiAlias(),
                                     outer,
                                     inner)) {
         SkPath path;
         path.setIsVolatile(true);
         path.addRRect(inner);
         path.addRRect(outer);
         path.setFillType(SkPath::kEvenOdd_FillType);
 
         GrStrokeInfo fillRec(SkStrokeRec::kFill_InitStyle);
-        this->internalDrawPath(fDrawTarget, &pipelineBuilder, viewMatrix, color,
+        this->internalDrawPath(this->getDrawTarget(), &pipelineBuilder, viewMatrix, color,
                                paint.isAntiAlias(), path, fillRec);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void GrDrawContext::drawOval(const GrClip& clip,
                              const GrPaint& paint,
                              const SkMatrix& viewMatrix,
                              const SkRect& oval,
@@ skipping 11 matching lines @@
         path.addOval(oval);
         this->drawPath(clip, paint, viewMatrix, path, strokeInfo);
         return;
     }
 
     AutoCheckFlush acf(fContext);
 
     GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
     GrColor color = paint.getColor();
 
-    if (!GrOvalRenderer::DrawOval(fDrawTarget,
+    if (!GrOvalRenderer::DrawOval(this->getDrawTarget(),
                                   pipelineBuilder,
                                   color,
                                   viewMatrix,
                                   paint.isAntiAlias(),
                                   oval,
                                   strokeInfo)) {
         SkPath path;
         path.setIsVolatile(true);
         path.addOval(oval);
-        this->internalDrawPath(fDrawTarget, &pipelineBuilder, viewMatrix, color,
+        this->internalDrawPath(this->getDrawTarget(), &pipelineBuilder, viewMatrix, color,
                                paint.isAntiAlias(), path, strokeInfo);
     }
 }
 
 // Can 'path' be drawn as a pair of filled nested rectangles?
 static bool is_nested_rects(const SkMatrix& viewMatrix,
                             const SkPath& path,
                             const SkStrokeRec& stroke,
                             SkRect rects[2]) {
     SkASSERT(stroke.isFillStyle());
@@ skipping 42 matching lines @@
 }
 
 void GrDrawContext::drawBatch(const GrClip& clip,
                               const GrPaint& paint, GrDrawBatch* batch) {
     RETURN_IF_ABANDONED
     SkDEBUGCODE(this->validate();)
 
     AutoCheckFlush acf(fContext);
 
     GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
-    fDrawTarget->drawBatch(pipelineBuilder, batch);
+    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();)
 
@@ skipping 18 matching lines @@
         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];
 
             if (is_nested_rects(viewMatrix, path, strokeInfo, rects)) {
                 SkAutoTUnref<GrDrawBatch> batch(GrRectBatchFactory::CreateAAFillNestedRects(
                     color, viewMatrix, rects));
-                fDrawTarget->drawBatch(pipelineBuilder, batch);
+                this->getDrawTarget()->drawBatch(pipelineBuilder, batch);
                 return;
             }
         }
         SkRect ovalRect;
         bool isOval = path.isOval(&ovalRect);
 
         if (isOval && !path.isInverseFillType()) {
-            if (GrOvalRenderer::DrawOval(fDrawTarget,
+            if (GrOvalRenderer::DrawOval(this->getDrawTarget(),
                                          pipelineBuilder,
                                          color,
                                          viewMatrix,
                                          paint.isAntiAlias(),
                                          ovalRect,
                                          strokeInfo)) {
                 return;
             }
         }
     }
-    this->internalDrawPath(fDrawTarget, &pipelineBuilder, viewMatrix, color, paint.isAntiAlias(),
-                           path, strokeInfo);
+    this->internalDrawPath(this->getDrawTarget(), &pipelineBuilder, viewMatrix, color,
+                           paint.isAntiAlias(), path, strokeInfo);
 }
 
 void GrDrawContext::internalDrawPath(GrDrawTarget* target,
                                      GrPipelineBuilder* pipelineBuilder,
                                      const SkMatrix& viewMatrix,
                                      GrColor color,
                                      bool useAA,
                                      const SkPath& path,
                                      const GrStrokeInfo& strokeInfo) {
     RETURN_IF_ABANDONED
@@ skipping 74 matching lines @@
     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();)
 
-    fDrawTarget->drawBatch(*pipelineBuilder, batch);
+    this->getDrawTarget()->drawBatch(*pipelineBuilder, batch);
 }