Add choke point for modifying non-AA rect draws (e.g., applying clipping)

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 "GrBatchTest.h"
 #include "GrColor.h"
 #include "GrDrawContext.h"
@@ skipping 224 matching lines @@
         this->drawRect(clip, *paint, viewMatrix, r);
     } else {
         SkMatrix localMatrix;
         if (!viewMatrix.invert(&localMatrix)) {
             SkDebugf("Could not invert matrix\n");
             return;
         }
 
         AutoCheckFlush acf(fDrawingManager);
 
-        SkAutoTUnref<GrDrawBatch> batch(
-                GrRectBatchFactory::CreateNonAAFill(paint->getColor(), SkMatrix::I(), r, nullptr,
-                                                    &localMatrix));
-        GrPipelineBuilder pipelineBuilder(*paint); // Create a pipeline builder without hwaa.
-        this->getDrawTarget()->drawBatch(pipelineBuilder, this, clip, batch);
+        this->drawNonAAFilledRect(clip, *paint, SkMatrix::I(), r, nullptr, &localMatrix, nullptr);
     }
 }
 
 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;
 }
 
 static bool view_matrix_ok_for_aa_fill_rect(const SkMatrix& viewMatrix) {
     return viewMatrix.preservesRightAngles();
 }
 
 static bool should_apply_coverage_aa(const GrPaint& paint, GrRenderTarget* rt,
                                      bool* useHWAA = nullptr) {
     if (!paint.isAntiAlias()) {
         if (useHWAA) {
             *useHWAA = false;
         }
         return false;
     } else {
         if (useHWAA) {
             *useHWAA = rt->isUnifiedMultisampled();
         }
         return !rt->isUnifiedMultisampled();
     }
 }
 
-GrDrawBatch* GrDrawContext::getFillRectBatch(const GrPaint& paint,
-                                             const SkMatrix& viewMatrix,
-                                             const SkRect& rect,
-                                             bool* useHWAA) {
+bool GrDrawContext::drawFilledRect(const GrClip& clip,
+                                   const GrPaint& paint,
+                                   const SkMatrix& viewMatrix,
+                                   const SkRect& rect,
+                                   const GrUserStencilSettings* ss) {
+
+    SkAutoTUnref<GrDrawBatch> batch;
+    bool useHWAA;
+
     if (InstancedRendering* ir = this->getDrawTarget()->instancedRendering()) {
-        if (GrDrawBatch* batch = ir->recordRect(rect, viewMatrix, paint.getColor(),
-                                                paint.isAntiAlias(), fInstancedPipelineInfo,
-                                                useHWAA)) {
-            return batch;
+        batch.reset(ir->recordRect(rect, viewMatrix, paint.getColor(),
+                                   paint.isAntiAlias(), fInstancedPipelineInfo,
+                                   &useHWAA));
+        if (batch) {
+            GrPipelineBuilder pipelineBuilder(paint, useHWAA);
+            if (ss) {
+                pipelineBuilder.setUserStencil(ss);
+            }
+            this->getDrawTarget()->drawBatch(pipelineBuilder, this, clip, batch);
+            return true;
         }
     }
 
-    if (should_apply_coverage_aa(paint, fRenderTarget.get(), useHWAA)) {
+    if (should_apply_coverage_aa(paint, fRenderTarget.get(), &useHWAA)) {
         // The fill path can handle rotation but not skew.
         if (view_matrix_ok_for_aa_fill_rect(viewMatrix)) {
             SkRect devBoundRect;
             viewMatrix.mapRect(&devBoundRect, rect);
-            return GrRectBatchFactory::CreateAAFill(paint.getColor(), viewMatrix,
-                                                    rect, devBoundRect);
+
+            batch.reset(GrRectBatchFactory::CreateAAFill(paint.getColor(), viewMatrix,
+                                                         rect, devBoundRect));
+            if (batch) {
+                GrPipelineBuilder pipelineBuilder(paint, useHWAA);
+                if (ss) {
+                    pipelineBuilder.setUserStencil(ss);
+                }
+                this->getDrawTarget()->drawBatch(pipelineBuilder, this, clip, batch);
+                return true;
+            }
         }
     } else {
-        // filled BW rect
-        return GrRectBatchFactory::CreateNonAAFill(paint.getColor(), viewMatrix, rect,
-                                                   nullptr, nullptr);
+        this->drawNonAAFilledRect(clip, paint, viewMatrix, rect, nullptr, nullptr, ss);
+        return true;
     }
 
-    return nullptr;
+    return false;
 }
 
 void GrDrawContext::drawRect(const GrClip& clip,
                              const GrPaint& paint,
                              const SkMatrix& viewMatrix,
                              const SkRect& rect,
                              const GrStyle* style) {
     if (!style) {
         style = &GrStyle::SimpleFill();
     }
     ASSERT_SINGLE_OWNER
     RETURN_IF_ABANDONED
     SkDEBUGCODE(this->validate();)
     GR_AUDIT_TRAIL_AUTO_FRAME(fAuditTrail, "GrDrawContext::drawRect");
 
     // Path effects should've been devolved to a path in SkGpuDevice
     SkASSERT(!style->pathEffect());
 
     AutoCheckFlush acf(fDrawingManager);
 
     const SkStrokeRec& stroke = style->strokeRec();
-    bool useHWAA;
-    bool snapToPixelCenters = false;
-    SkAutoTUnref<GrDrawBatch> batch;
-    if (stroke.getStyle() == SkStrokeRec::kFill_Style) {
+    if (stroke.getStyle() == SkStrokeRec::kFill_Style &&
+        !fContext->caps()->useDrawInsteadOfClear()) {
         // 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.
         SkRect rtRect;
         fRenderTarget->getBoundsRect(&rtRect);
         // Does the clip contain the entire RT?
         if (clip.quickContains(rtRect)) {
             SkMatrix invM;
             if (!viewMatrix.invert(&invM)) {
                 return;
             }
             // 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)) {
                     this->getDrawTarget()->clear(nullptr, clearColor, true, this);
                     return;
                 }
             }
         }
-        batch.reset(this->getFillRectBatch(paint, viewMatrix, rect, &useHWAA));
+
+        if (this->drawFilledRect(clip, paint, viewMatrix, rect, nullptr)) {
+            return;
+        }
     } else if (stroke.getStyle() == SkStrokeRec::kStroke_Style ||
                stroke.getStyle() == SkStrokeRec::kHairline_Style) {
         if ((!rect.width() || !rect.height()) &&
             SkStrokeRec::kHairline_Style != stroke.getStyle()) {
             SkScalar r = stroke.getWidth() / 2;
             // TODO: Move these stroke->fill fallbacks to GrShape?
             switch (stroke.getJoin()) {
                 case SkPaint::kMiter_Join:
                     this->drawRect(clip, paint, viewMatrix,
                                    {rect.fLeft - r, rect.fTop - r,
@@ skipping 13 matching lines @@
                                        {rect.fLeft - r, rect.fTop, rect.fRight + r, rect.fBottom},
                                        &GrStyle::SimpleFill());
                     } else {
                         this->drawRect(clip, paint, viewMatrix,
                                        {rect.fLeft, rect.fTop - r, rect.fRight, rect.fBottom + r},
                                        &GrStyle::SimpleFill());
                     }
                     return;
                 }
         }
+
+        bool useHWAA;
+        bool snapToPixelCenters = false;
+        SkAutoTUnref<GrDrawBatch> batch;
+
         GrColor color = paint.getColor();
         if (should_apply_coverage_aa(paint, fRenderTarget.get(), &useHWAA)) {
             // The stroke path needs the rect to remain axis aligned (no rotation or skew).
             if (viewMatrix.rectStaysRect()) {
                 batch.reset(GrRectBatchFactory::CreateAAStroke(color, viewMatrix, rect, stroke));
             }
         } else {
             // 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.
             snapToPixelCenters = stroke.getStyle() == SkStrokeRec::kHairline_Style &&
                                  !fRenderTarget->isUnifiedMultisampled();
             batch.reset(GrRectBatchFactory::CreateNonAAStroke(color, viewMatrix, rect,
                                                               stroke, snapToPixelCenters));
         }
-    }
 
-    if (batch) {
-        GrPipelineBuilder pipelineBuilder(paint, useHWAA);
+        if (batch) {
+            GrPipelineBuilder pipelineBuilder(paint, useHWAA);
 
-        if (snapToPixelCenters) {
-            pipelineBuilder.setState(GrPipelineBuilder::kSnapVerticesToPixelCenters_Flag,
-                                     snapToPixelCenters);
+            if (snapToPixelCenters) {
+                pipelineBuilder.setState(GrPipelineBuilder::kSnapVerticesToPixelCenters_Flag,
+                                         snapToPixelCenters);
+            }
+
+            this->getDrawTarget()->drawBatch(pipelineBuilder, this, clip, batch);
+            return;
         }
-
-        this->getDrawTarget()->drawBatch(pipelineBuilder, this, clip, batch);
-        return;
     }
 
     SkPath path;
     path.setIsVolatile(true);
     path.addRect(rect);
     this->internalDrawPath(clip, paint, viewMatrix, path, *style);
 }
 
 void GrDrawContextPriv::clearStencilClip(const SkIRect& rect, bool insideClip) {
     ASSERT_SINGLE_OWNER_PRIV
@@ skipping 26 matching lines @@
     GR_AUDIT_TRAIL_AUTO_FRAME(fDrawContext->fAuditTrail, "GrDrawContext::stencilRect");
 
     AutoCheckFlush acf(fDrawContext->fDrawingManager);
 
     GrPaint paint;
     paint.setAntiAlias(useHWAA);
     paint.setXPFactory(GrDisableColorXPFactory::Make());
 
     SkASSERT(!useHWAA || fDrawContext->isStencilBufferMultisampled());
 
-    GrPipelineBuilder pipelineBuilder(paint, useHWAA);
-    pipelineBuilder.setUserStencil(ss);
-
-    SkAutoTUnref<GrDrawBatch> batch(
-        GrRectBatchFactory::CreateNonAAFill(SK_ColorWHITE, viewMatrix, rect, nullptr, nullptr));
-
-    fDrawContext->getDrawTarget()->drawBatch(pipelineBuilder, fDrawContext, clip, batch);
+    fDrawContext->drawFilledRect(clip, paint, viewMatrix, rect, ss);
 }
 
 bool GrDrawContextPriv::drawAndStencilRect(const GrFixedClip& clip,
                                            const GrUserStencilSettings* ss,
                                            SkRegion::Op op,
                                            bool invert,
                                            bool doAA,
                                            const SkMatrix& viewMatrix,
                                            const SkRect& rect) {
     ASSERT_SINGLE_OWNER_PRIV
     RETURN_FALSE_IF_ABANDONED_PRIV
     SkDEBUGCODE(fDrawContext->validate();)
     GR_AUDIT_TRAIL_AUTO_FRAME(fDrawContext->fAuditTrail, "GrDrawContext::drawAndStencilRect");
 
     AutoCheckFlush acf(fDrawContext->fDrawingManager);
 
     GrPaint paint;
     paint.setAntiAlias(doAA);
     paint.setCoverageSetOpXPFactory(op, invert);
 
-    bool useHWAA;
-    SkAutoTUnref<GrDrawBatch> batch(
-        fDrawContext->getFillRectBatch(paint, viewMatrix, rect, &useHWAA));
-    if (batch) {
-        GrPipelineBuilder pipelineBuilder(paint, useHWAA);
-        pipelineBuilder.setUserStencil(ss);
-
-        fDrawContext->getDrawTarget()->drawBatch(pipelineBuilder, fDrawContext, clip, batch);
+    if (fDrawContext->drawFilledRect(clip, paint, viewMatrix, rect, ss)) {
         return true;
     }
 
     SkPath path;
     path.setIsVolatile(true);
     path.addRect(rect);
     return this->drawAndStencilPath(clip, ss, op, invert, doAA, viewMatrix, path);
 }
 
 void GrDrawContext::fillRectToRect(const GrClip& clip,
@@ skipping 17 matching lines @@
             GrPipelineBuilder pipelineBuilder(paint, useHWAA);
             this->getDrawTarget()->drawBatch(pipelineBuilder, this, clip, batch);
             return;
         }
     }
 
     if (should_apply_coverage_aa(paint, fRenderTarget.get(), &useHWAA) &&
         view_matrix_ok_for_aa_fill_rect(viewMatrix)) {
         batch.reset(GrAAFillRectBatch::CreateWithLocalRect(paint.getColor(), viewMatrix, rectToDraw,
                                                            localRect));
+        if (batch) {
+            GrPipelineBuilder pipelineBuilder(paint, useHWAA);
+            this->drawBatch(pipelineBuilder, clip, batch);
+            return;
+        }
     } else {
-        batch.reset(GrRectBatchFactory::CreateNonAAFill(paint.getColor(), viewMatrix, rectToDraw,
-                                                        &localRect, nullptr));
+        this->drawNonAAFilledRect(clip, paint, viewMatrix, rectToDraw, &localRect,
+                                  nullptr, nullptr);
     }
 
-    if (batch) {
-        GrPipelineBuilder pipelineBuilder(paint, useHWAA);
-        this->drawBatch(pipelineBuilder, clip, batch);
-    }
 }
 
 void GrDrawContext::fillRectWithLocalMatrix(const GrClip& clip,
                                             const GrPaint& paint,
                                             const SkMatrix& viewMatrix,
                                             const SkRect& rectToDraw,
                                             const SkMatrix& localMatrix) {
     ASSERT_SINGLE_OWNER
     RETURN_IF_ABANDONED
     SkDEBUGCODE(this->validate();)
@@ skipping 10 matching lines @@
             GrPipelineBuilder pipelineBuilder(paint, useHWAA);
             this->getDrawTarget()->drawBatch(pipelineBuilder, this, clip, batch);
             return;
         }
     }
 
     if (should_apply_coverage_aa(paint, fRenderTarget.get(), &useHWAA) &&
         view_matrix_ok_for_aa_fill_rect(viewMatrix)) {
         batch.reset(GrAAFillRectBatch::Create(paint.getColor(), viewMatrix, localMatrix,
                                               rectToDraw));
+        GrPipelineBuilder pipelineBuilder(paint, useHWAA);
+        this->getDrawTarget()->drawBatch(pipelineBuilder, this, clip, batch);
     } else {
-        batch.reset(GrRectBatchFactory::CreateNonAAFill(paint.getColor(), viewMatrix, rectToDraw,
-                                                        nullptr, &localMatrix));
+        this->drawNonAAFilledRect(clip, paint, viewMatrix, rectToDraw, nullptr,
+                                  &localMatrix, nullptr);
     }
 
-    GrPipelineBuilder pipelineBuilder(paint, useHWAA);
-    this->getDrawTarget()->drawBatch(pipelineBuilder, this, clip, batch);
 }
 
 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 276 matching lines @@
 
     SkAutoTUnref<GrDrawBatch> batch(GrNinePatch::CreateNonAA(paint.getColor(), viewMatrix,
                                                              imageWidth, imageHeight,
                                                              center, dst));
 
     GrPipelineBuilder pipelineBuilder(paint, this->mustUseHWAA(paint));
     this->getDrawTarget()->drawBatch(pipelineBuilder, this, clip, batch);
 }
 
 
+void GrDrawContext::drawNonAAFilledRect(const GrClip& clip,
+                                        const GrPaint& paint,
+                                        const SkMatrix& viewMatrix,
+                                        const SkRect& rect,
+                                        const SkRect* localRect,
+                                        const SkMatrix* localMatrix,
+                                        const GrUserStencilSettings* ss) {
+    SkAutoTUnref<GrDrawBatch> batch(
+            GrRectBatchFactory::CreateNonAAFill(paint.getColor(), viewMatrix, rect, localRect,
+                                                localMatrix));
+    GrPipelineBuilder pipelineBuilder(paint, this->mustUseHWAA(paint));
+    if (ss) {
+        pipelineBuilder.setUserStencil(ss);
+    }
+    this->getDrawTarget()->drawBatch(pipelineBuilder, this, clip, batch);
+}
+
 // Can 'path' be drawn as a pair of filled nested rectangles?
 static bool fills_as_nested_rects(const SkMatrix& viewMatrix, const SkPath& path, SkRect rects[2]) {
 
     if (path.isInverseFillType()) {
         return false;
     }
 
     // TODO: this restriction could be lifted if we were willing to apply
     // the matrix to all the points individually rather than just to the rect
     if (!viewMatrix.rectStaysRect()) {
@@ skipping 233 matching lines @@
 
 void GrDrawContext::drawBatch(const GrPipelineBuilder& pipelineBuilder, const GrClip& clip,
                               GrDrawBatch* batch) {
     ASSERT_SINGLE_OWNER
     RETURN_IF_ABANDONED
     SkDEBUGCODE(this->validate();)
     GR_AUDIT_TRAIL_AUTO_FRAME(fAuditTrail, "GrDrawContext::drawBatch");
 
     this->getDrawTarget()->drawBatch(pipelineBuilder, this, clip, batch);
 }