GrDrawContext now holds GrRenderTarget pointer

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 20 matching lines @@
 class AutoCheckFlush {
 public:
     AutoCheckFlush(GrContext* context) : fContext(context) { SkASSERT(context); }
     ~AutoCheckFlush() { fContext->flushIfNecessary(); }
 
 private:
     GrContext* fContext;
 };
 
 GrDrawContext::GrDrawContext(GrContext* context,
+                             GrRenderTarget* rt,
                              GrDrawTarget* drawTarget,
                              const SkSurfaceProps* surfaceProps)
     : fContext(context)
+    , fRenderTarget(rt)
     , fDrawTarget(SkRef(drawTarget))
     , fTextContext(nullptr)
     , fSurfaceProps(SkSurfacePropsCopyOrDefault(surfaceProps)) {
+    SkDEBUGCODE(this->validate();)
 }
 
 GrDrawContext::~GrDrawContext() {
     SkSafeUnref(fDrawTarget);
 }
 
-void GrDrawContext::copySurface(GrRenderTarget* dst, GrSurface* src,
-                                const SkIRect& srcRect, const SkIPoint& dstPoint) {
+#ifdef SK_DEBUG
+void GrDrawContext::validate() const {
+    SkASSERT(fRenderTarget);
+    ASSERT_OWNED_RESOURCE(fRenderTarget);
+}
+#endif
+
+void GrDrawContext::copySurface(GrSurface* src, const SkIRect& srcRect, const SkIPoint& dstPoint) {
     RETURN_IF_ABANDONED
+    SkDEBUGCODE(this->validate();)
 
-    if (!this->prepareToDraw(dst)) {
-        return;
-    }
-
-    fDrawTarget->copySurface(dst, src, srcRect, dstPoint);
+    fDrawTarget->copySurface(fRenderTarget, src, srcRect, dstPoint);
 }
 
 
-void GrDrawContext::drawText(GrRenderTarget* rt, const GrClip& clip, const GrPaint& grPaint,
+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, rt);
+        fTextContext = fContext->textContext(fSurfaceProps, fRenderTarget);
     }
 
-    fTextContext->drawText(this, rt, clip, grPaint, skPaint, viewMatrix,
+    fTextContext->drawText(this, fRenderTarget, clip, grPaint, skPaint, viewMatrix,
                            text, byteLength, x, y, clipBounds);
 
 }
-void GrDrawContext::drawPosText(GrRenderTarget* rt, const GrClip& clip, const GrPaint& grPaint,
+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, rt);
+        fTextContext = fContext->textContext(fSurfaceProps, fRenderTarget);
     }
 
-    fTextContext->drawPosText(this, rt, clip, grPaint, skPaint, viewMatrix, text, byteLength,
+    fTextContext->drawPosText(this, fRenderTarget, clip, grPaint, skPaint, viewMatrix, text, byteLength,
                               pos, scalarsPerPosition, offset, clipBounds);
 
 }
-void GrDrawContext::drawTextBlob(GrRenderTarget* rt, const GrClip& clip, const SkPaint& skPaint,
+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, rt);
+        fTextContext = fContext->textContext(fSurfaceProps, fRenderTarget);
     }
 
-    fTextContext->drawTextBlob(this, rt,
+    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();)
 
     fDrawTarget->drawPathsFromRange(*pipelineBuilder, viewMatrix, localMatrix, color, range, draw,
                                     (GrPathRendering::FillType) fill);
 }
 
-void GrDrawContext::discard(GrRenderTarget* renderTarget) {
+void GrDrawContext::discard() {
     RETURN_IF_ABANDONED
-    SkASSERT(renderTarget);
+    SkDEBUGCODE(this->validate();)
+
     AutoCheckFlush acf(fContext);
-    if (!this->prepareToDraw(renderTarget)) {
-        return;
-    }
-    fDrawTarget->discard(renderTarget);
+    fDrawTarget->discard(fRenderTarget);
 }
 
-void GrDrawContext::clear(GrRenderTarget* renderTarget,
-                          const SkIRect* rect,
+void GrDrawContext::clear(const SkIRect* rect,
                           const GrColor color,
                           bool canIgnoreRect) {
     RETURN_IF_ABANDONED
-    SkASSERT(renderTarget);
+    SkDEBUGCODE(this->validate();)
 
     AutoCheckFlush acf(fContext);
-    if (!this->prepareToDraw(renderTarget)) {
-        return;
-    }
-    fDrawTarget->clear(rect, color, canIgnoreRect, renderTarget);
+    fDrawTarget->clear(rect, color, canIgnoreRect, fRenderTarget);
 }
 
 
-void GrDrawContext::drawPaint(GrRenderTarget* rt,
-                              const GrClip& clip,
+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
     // don't overflow fixed-point implementations
     SkRect r;
     r.setLTRB(0, 0,
-              SkIntToScalar(rt->width()),
-              SkIntToScalar(rt->height()));
+              SkIntToScalar(fRenderTarget->width()),
+              SkIntToScalar(fRenderTarget->height()));
     SkTCopyOnFirstWrite<GrPaint> paint(origPaint);
 
     // by definition this fills the entire clip, no need for AA
     if (paint->isAntiAlias()) {
         paint.writable()->setAntiAlias(false);
     }
 
     bool isPerspective = viewMatrix.hasPerspective();
 
     // We attempt to map r by the inverse matrix and draw that. mapRect will
     // map the four corners and bound them with a new rect. This will not
     // produce a correct result for some perspective matrices.
     if (!isPerspective) {
         SkMatrix inverse;
         if (!viewMatrix.invert(&inverse)) {
             SkDebugf("Could not invert matrix\n");
             return;
         }
         inverse.mapRect(&r);
-        this->drawRect(rt, clip, *paint, viewMatrix, r);
+        this->drawRect(clip, *paint, viewMatrix, r);
     } else {
         SkMatrix localMatrix;
         if (!viewMatrix.invert(&localMatrix)) {
             SkDebugf("Could not invert matrix\n");
             return;
         }
 
         AutoCheckFlush acf(fContext);
-        if (!this->prepareToDraw(rt)) {
-            return;
-        }
 
-        GrPipelineBuilder pipelineBuilder(*paint, rt, clip);
+        GrPipelineBuilder pipelineBuilder(*paint, fRenderTarget, clip);
         fDrawTarget->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(GrRenderTarget* rt,
-                             const GrClip& clip,
+void GrDrawContext::drawRect(const GrClip& clip,
                              const GrPaint& paint,
                              const SkMatrix& viewMatrix,
                              const SkRect& rect,
                              const GrStrokeInfo* strokeInfo) {
     RETURN_IF_ABANDONED
+    SkDEBUGCODE(this->validate();)
+
     if (strokeInfo && strokeInfo->isDashed()) {
         SkPath path;
         path.setIsVolatile(true);
         path.addRect(rect);
-        this->drawPath(rt, clip, paint, viewMatrix, path, *strokeInfo);
+        this->drawPath(clip, paint, viewMatrix, path, *strokeInfo);
         return;
     }
 
     AutoCheckFlush acf(fContext);
-    if (!this->prepareToDraw(rt)) {
-        return;
-    }
 
-    GrPipelineBuilder pipelineBuilder(paint, rt, clip);
+    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);
         SkRect clipSpaceRTRect = rtRect;
         bool checkClip = GrClip::kWideOpen_ClipType != clip.clipType();
@@ skipping 10 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, rt);
+                    fDrawTarget->clear(nullptr, clearColor, true, fRenderTarget);
                     return;
                 }
             }
         }
     }
 
     GrColor color = paint.getColor();
     bool needAA = paint.isAntiAlias() &&
                   !pipelineBuilder.getRenderTarget()->isUnifiedMultisampled();
 
@@ skipping 11 matching lines @@
             SkRect devBoundRect;
             viewMatrix.mapRect(&devBoundRect, rect);
             batch.reset(GrRectBatchFactory::CreateAAFill(color, viewMatrix, rect, devBoundRect));
         }
         fDrawTarget->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 && !rt->isUnifiedMultisampled());
+        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);
     } else {
         // filled BW rect
         fDrawTarget->drawNonAARect(pipelineBuilder, color, viewMatrix, rect);
     }
 }
 
-void GrDrawContext::drawNonAARectToRect(GrRenderTarget* rt,
-                                        const GrClip& clip,
+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);
-    if (!this->prepareToDraw(rt)) {
-        return;
-    }
 
-    GrPipelineBuilder pipelineBuilder(paint, rt, clip);
+    GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
     fDrawTarget->drawNonAARect(pipelineBuilder,
                                paint.getColor(),
                                viewMatrix,
                                rectToDraw,
                                localRect);
 }
 
-void GrDrawContext::drawNonAARectWithLocalMatrix(GrRenderTarget* rt,
-                                                 const GrClip& clip,
+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);
-    if (!this->prepareToDraw(rt)) {
-        return;
-    }
 
-    GrPipelineBuilder pipelineBuilder(paint, rt, clip);
+    GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
     fDrawTarget->drawNonAARect(pipelineBuilder,
                                paint.getColor(),
                                viewMatrix,
                                rectToDraw,
                                localMatrix);
 }
 
-void GrDrawContext::drawVertices(GrRenderTarget* rt,
-                                 const GrClip& clip,
+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);
-    if (!this->prepareToDraw(rt)) {
-        return;
-    }
 
-    GrPipelineBuilder pipelineBuilder(paint, rt, clip);
+    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;
     }
 
     viewMatrix.mapRect(&bounds);
 
     // If we don't have AA then we outset for a half pixel in each direction to account for
     // snapping
     if (!paint.isAntiAlias()) {
         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);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-void GrDrawContext::drawAtlas(GrRenderTarget* rt,
-                              const GrClip& clip,
+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);
-    if (!this->prepareToDraw(rt)) {
-        return;
-    }
     
-    GrPipelineBuilder pipelineBuilder(paint, rt, clip);
+    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);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-void GrDrawContext::drawRRect(GrRenderTarget*rt,
-                              const GrClip& clip,
+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(rt, clip, paint, viewMatrix, path, strokeInfo);
+        this->drawPath(clip, paint, viewMatrix, path, strokeInfo);
         return;
     }
 
     AutoCheckFlush acf(fContext);
-    if (!this->prepareToDraw(rt)) {
-        return;
-    }
 
-    GrPipelineBuilder pipelineBuilder(paint, rt, clip);
+    GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
     GrColor color = paint.getColor();
+
     if (!GrOvalRenderer::DrawRRect(fDrawTarget,
                                    pipelineBuilder,
                                    color,
                                    viewMatrix,
                                    paint.isAntiAlias(),
                                    rrect,
                                    strokeInfo)) {
         SkPath path;
         path.setIsVolatile(true);
         path.addRRect(rrect);
         this->internalDrawPath(fDrawTarget, &pipelineBuilder, viewMatrix, color,
                                paint.isAntiAlias(), path, strokeInfo);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-void GrDrawContext::drawDRRect(GrRenderTarget* rt,
-                               const GrClip& clip,
+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);
-    if (!this->prepareToDraw(rt)) {
-        return;
-    }
 
-    GrPipelineBuilder pipelineBuilder(paint, rt, clip);
+    GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
     GrColor color = paint.getColor();
     if (!GrOvalRenderer::DrawDRRect(fDrawTarget,
                                     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,
                                paint.isAntiAlias(), path, fillRec);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-void GrDrawContext::drawOval(GrRenderTarget* rt,
-                             const GrClip& clip,
+void GrDrawContext::drawOval(const GrClip& clip,
                              const GrPaint& paint,
                              const SkMatrix& viewMatrix,
                              const SkRect& oval,
                              const GrStrokeInfo& strokeInfo) {
     RETURN_IF_ABANDONED
+    SkDEBUGCODE(this->validate();)
+
     if (oval.isEmpty()) {
        return;
     }
 
     if (strokeInfo.isDashed()) {
         SkPath path;
         path.setIsVolatile(true);
         path.addOval(oval);
-        this->drawPath(rt, clip, paint, viewMatrix, path, strokeInfo);
+        this->drawPath(clip, paint, viewMatrix, path, strokeInfo);
         return;
     }
 
     AutoCheckFlush acf(fContext);
-    if (!this->prepareToDraw(rt)) {
-        return;
-    }
 
-    GrPipelineBuilder pipelineBuilder(paint, rt, clip);
+    GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
     GrColor color = paint.getColor();
+
     if (!GrOvalRenderer::DrawOval(fDrawTarget,
                                   pipelineBuilder,
                                   color,
                                   viewMatrix,
                                   paint.isAntiAlias(),
                                   oval,
                                   strokeInfo)) {
         SkPath path;
         path.setIsVolatile(true);
         path.addOval(oval);
@@ skipping 45 matching lines @@
             allGoE1 = false;
         }
         if (!SkScalarNearlyEqual(margin, temp)) {
             allEq = false;
         }
     }
 
     return allEq || allGoE1;
 }
 
-void GrDrawContext::drawBatch(GrRenderTarget* rt, const GrClip& clip,
+void GrDrawContext::drawBatch(const GrClip& clip,
                               const GrPaint& paint, GrDrawBatch* batch) {
     RETURN_IF_ABANDONED
+    SkDEBUGCODE(this->validate();)
 
     AutoCheckFlush acf(fContext);
-    if (!this->prepareToDraw(rt)) {
-        return;
-    }
 
-    GrPipelineBuilder pipelineBuilder(paint, rt, clip);
+    GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
     fDrawTarget->drawBatch(pipelineBuilder, batch);
 }
 
-void GrDrawContext::drawPath(GrRenderTarget* rt,
-                             const GrClip& clip,
+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(rt, clip, paint, viewMatrix);
+           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);
-    if (!this->prepareToDraw(rt)) {
-        return;
-    }
 
-    GrPipelineBuilder pipelineBuilder(paint, rt, clip);
+    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];
 
             if (is_nested_rects(viewMatrix, path, strokeInfo, rects)) {
                 SkAutoTUnref<GrDrawBatch> batch(GrRectBatchFactory::CreateAAFillNestedRects(
@@ skipping 24 matching lines @@
 void GrDrawContext::internalDrawPath(GrDrawTarget* target,
                                      GrPipelineBuilder* pipelineBuilder,
                                      const SkMatrix& viewMatrix,
                                      GrColor color,
                                      bool useAA,
                                      const SkPath& path,
                                      const GrStrokeInfo& strokeInfo) {
     RETURN_IF_ABANDONED
     SkASSERT(!path.isEmpty());
 
-
     // An Assumption here is that path renderer would use some form of tweaking
     // the src color (either the input alpha or in the frag shader) to implement
     // aa. If we have some future driver-mojo path AA that can do the right
     // thing WRT to the blend then we'll need some query on the PR.
     bool useCoverageAA = useAA &&
         !pipelineBuilder->getRenderTarget()->isUnifiedMultisampled();
 
 
     GrPathRendererChain::DrawType type =
         useCoverageAA ? GrPathRendererChain::kColorAntiAlias_DrawType :
@@ skipping 58 matching lines @@
     args.fResourceProvider = fContext->resourceProvider();
     args.fPipelineBuilder = pipelineBuilder;
     args.fColor = color;
     args.fViewMatrix = &viewMatrix;
     args.fPath = pathPtr;
     args.fStroke = strokeInfoPtr;
     args.fAntiAlias = useCoverageAA;
     pr->drawPath(args);
 }
 
-bool GrDrawContext::prepareToDraw(GrRenderTarget* rt) {
-    RETURN_FALSE_IF_ABANDONED
-
-    ASSERT_OWNED_RESOURCE(rt);
-    SkASSERT(rt);
-    return true;
-}
-
 void GrDrawContext::drawBatch(GrPipelineBuilder* pipelineBuilder, GrDrawBatch* batch) {
     RETURN_IF_ABANDONED
+    SkDEBUGCODE(this->validate();)
 
     fDrawTarget->drawBatch(*pipelineBuilder, batch);
 }