Revert of Make GrDrawContext::internalDrawPath cons up its own GrPipelineBuilder

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"
@@ skipping 209 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);
 
+        GrPipelineBuilder pipelineBuilder(*paint, fRenderTarget, clip);
         SkAutoTUnref<GrDrawBatch> batch(
                 GrRectBatchFactory::CreateNonAAFill(paint->getColor(), SkMatrix::I(), r, nullptr,
                                                     &localMatrix));
-        GrPipelineBuilder pipelineBuilder(*paint, fRenderTarget, clip);
         this->getDrawTarget()->drawBatch(pipelineBuilder, batch);
     }
 }
 
 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) {
@@ skipping 12 matching lines @@
     ASSERT_SINGLE_OWNER
     RETURN_IF_ABANDONED
     SkDEBUGCODE(this->validate();)
     GR_AUDIT_TRAIL_AUTO_FRAME(fAuditTrail, "GrDrawContext::drawRect");
 
     // Dashing should've been devolved to a path in SkGpuDevice
     SkASSERT(!strokeInfo || !strokeInfo->isDashed());
 
     AutoCheckFlush acf(fDrawingManager);
 
-    SkScalar width = !strokeInfo ? -1 : strokeInfo->getWidth();
+    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;
         fRenderTarget->getBoundsRect(&rtRect);
         SkRect clipSpaceRTRect = rtRect;
         bool checkClip = GrClip::kWideOpen_ClipType != clip.clipType();
         if (checkClip) {
             clipSpaceRTRect.offset(SkIntToScalar(clip.origin().fX),
@@ skipping 15 matching lines @@
                 // Will it blend?
                 GrColor clearColor;
                 if (paint.isConstantBlendedColor(&clearColor)) {
                     this->getDrawTarget()->clear(nullptr, clearColor, true, fRenderTarget);
                     return;
                 }
             }
         }
     }
 
-    bool snapToPixelCenters = false;
+    GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
+    GrColor color = paint.getColor();
+
     SkAutoTUnref<GrDrawBatch> batch;
     if (should_apply_coverage_aa(paint, fRenderTarget)) {
         if (width >= 0) {
             // The stroke path needs the rect to remain axis aligned (no rotation or skew).
             if (viewMatrix.rectStaysRect()) {
-                batch.reset(GrRectBatchFactory::CreateAAStroke(paint.getColor(), viewMatrix, rect,
+                batch.reset(GrRectBatchFactory::CreateAAStroke(color, viewMatrix, rect,
                                                                *strokeInfo));
             }
         } else {
             // The fill path can handle rotation but not skew.
             if (view_matrix_ok_for_aa_fill_rect(viewMatrix)) {
                 SkRect devBoundRect;
                 viewMatrix.mapRect(&devBoundRect, rect);
-                batch.reset(GrRectBatchFactory::CreateAAFill(paint.getColor(), viewMatrix, rect,
+                batch.reset(GrRectBatchFactory::CreateAAFill(color, viewMatrix, rect,
                                                              devBoundRect));
             }
         }
+        if (!batch) {
+            SkPath path;
+            path.setIsVolatile(true);
+            path.addRect(rect);
+            this->internalDrawPath(&pipelineBuilder, viewMatrix, color, true, path, *strokeInfo);
+            SkASSERT(paint.isAntiAlias());
+            return;
+        }
     } else if (width >= 0) {
         // Non-AA hairlines are snapped to pixel centers to make which pixels are hit deterministic
-        snapToPixelCenters = (0 == width && !fRenderTarget->isUnifiedMultisampled());
-        batch.reset(GrRectBatchFactory::CreateNonAAStroke(paint.getColor(), viewMatrix, rect,
-                                                          width, snapToPixelCenters));
+        bool snapToPixelCenters = (0 == width && !fRenderTarget->isUnifiedMultisampled());
+        batch.reset(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.
+        // 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);
     } else {
         // filled BW rect
-        batch.reset(GrRectBatchFactory::CreateNonAAFill(paint.getColor(), viewMatrix, rect,
-                                                        nullptr, nullptr));
+        batch.reset(GrRectBatchFactory::CreateNonAAFill(color, viewMatrix, rect, nullptr, nullptr));
     }
-
-    if (batch) {
-        GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
-
-        if (snapToPixelCenters) {
-            pipelineBuilder.setState(GrPipelineBuilder::kSnapVerticesToPixelCenters_Flag,
-                                     snapToPixelCenters);
-        }
-
-        this->getDrawTarget()->drawBatch(pipelineBuilder, batch);
-        return;
-    }
-    
-    SkPath path;
-    path.setIsVolatile(true);
-    path.addRect(rect);
-    this->internalDrawPath(clip, paint, viewMatrix, path,
-                           strokeInfo ? *strokeInfo : GrStrokeInfo::FillInfo());
+    this->getDrawTarget()->drawBatch(pipelineBuilder, batch);
 }
 
 void GrDrawContext::fillRectToRect(const GrClip& clip,
                                    const GrPaint& paint,
                                    const SkMatrix& viewMatrix,
                                    const SkRect& rectToDraw,
                                    const SkRect& localRect) {
     ASSERT_SINGLE_OWNER
     RETURN_IF_ABANDONED
     SkDEBUGCODE(this->validate();)
     GR_AUDIT_TRAIL_AUTO_FRAME(fAuditTrail, "GrDrawContext::fillRectToRect");
 
     AutoCheckFlush acf(fDrawingManager);
 
+    GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
     SkAutoTUnref<GrDrawBatch> batch;
     if (should_apply_coverage_aa(paint, fRenderTarget) &&
         view_matrix_ok_for_aa_fill_rect(viewMatrix)) {
         batch.reset(GrAAFillRectBatch::CreateWithLocalRect(paint.getColor(), viewMatrix, rectToDraw,
                                                            localRect));
     } else {
         batch.reset(GrRectBatchFactory::CreateNonAAFill(paint.getColor(), viewMatrix, rectToDraw,
                                                         &localRect, nullptr));
     }
 
     if (batch) {
-        GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
         this->drawBatch(&pipelineBuilder, 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();)
     GR_AUDIT_TRAIL_AUTO_FRAME(fAuditTrail, "GrDrawContext::fillRectWithLocalMatrix");
 
     AutoCheckFlush acf(fDrawingManager);
 
+    GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
+
     SkAutoTUnref<GrDrawBatch> batch;
     if (should_apply_coverage_aa(paint, fRenderTarget) &&
         view_matrix_ok_for_aa_fill_rect(viewMatrix)) {
         batch.reset(GrAAFillRectBatch::Create(paint.getColor(), viewMatrix, localMatrix,
                                               rectToDraw));
     } else {
         batch.reset(GrRectBatchFactory::CreateNonAAFill(paint.getColor(), viewMatrix, rectToDraw,
                                                         nullptr, &localMatrix));
     }
-
-    GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
     this->getDrawTarget()->drawBatch(pipelineBuilder, 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[],
                                  const uint16_t indices[],
                                  int indexCount) {
     ASSERT_SINGLE_OWNER
     RETURN_IF_ABANDONED
     SkDEBUGCODE(this->validate();)
     GR_AUDIT_TRAIL_AUTO_FRAME(fAuditTrail, "GrDrawContext::drawVertices");
 
     AutoCheckFlush acf(fDrawingManager);
 
+    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. We also do this for the "hair" primitive types: lines and points since they have
     // a 1 pixel thickness in device space.
     if (!paint.isAntiAlias() || GrIsPrimTypeLines(primitiveType) ||
         kPoints_GrPrimitiveType == primitiveType) {
         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));
 
-    GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
     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[]) {
     ASSERT_SINGLE_OWNER
     RETURN_IF_ABANDONED
     SkDEBUGCODE(this->validate();)
     GR_AUDIT_TRAIL_AUTO_FRAME(fAuditTrail, "GrDrawContext::drawAtlas");
 
     AutoCheckFlush acf(fDrawingManager);
-        
+    
+    GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
+    
     GrDrawAtlasBatch::Geometry geometry;
     geometry.fColor = paint.getColor();
     SkAutoTUnref<GrDrawBatch> batch(GrDrawAtlasBatch::Create(geometry, viewMatrix, spriteCount,
                                                              xform, texRect, colors));
     
-    GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
     this->getDrawTarget()->drawBatch(pipelineBuilder, batch);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void GrDrawContext::drawRRect(const GrClip& clip,
                               const GrPaint& paint,
                               const SkMatrix& viewMatrix,
                               const SkRRect& rrect,
                               const GrStrokeInfo& strokeInfo) {
     ASSERT_SINGLE_OWNER
     RETURN_IF_ABANDONED
     SkDEBUGCODE(this->validate();)
     GR_AUDIT_TRAIL_AUTO_FRAME(fAuditTrail, "GrDrawContext::drawRRect");
 
     if (rrect.isEmpty()) {
        return;
     }
 
     SkASSERT(!strokeInfo.isDashed()); // this should've been devolved to a path in SkGpuDevice
 
     AutoCheckFlush acf(fDrawingManager);
 
+    GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
+    GrColor color = paint.getColor();
+
     if (should_apply_coverage_aa(paint, fRenderTarget)) {
         GrShaderCaps* shaderCaps = fContext->caps()->shaderCaps();
 
-        SkAutoTUnref<GrDrawBatch> batch(GrOvalRenderer::CreateRRectBatch(paint.getColor(),
+        SkAutoTUnref<GrDrawBatch> batch(GrOvalRenderer::CreateRRectBatch(color,
                                                                          viewMatrix,
                                                                          rrect,
                                                                          strokeInfo,
                                                                          shaderCaps));
         if (batch) {
-            GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
             this->getDrawTarget()->drawBatch(pipelineBuilder, batch);
             return;
         }
     }
 
     SkPath path;
     path.setIsVolatile(true);
     path.addRRect(rrect);
-    this->internalDrawPath(clip, paint, viewMatrix, path, strokeInfo);
+    this->internalDrawPath(&pipelineBuilder, viewMatrix, color,
+                           paint.isAntiAlias(), path, strokeInfo);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void GrDrawContext::drawOval(const GrClip& clip,
                              const GrPaint& paint,
                              const SkMatrix& viewMatrix,
                              const SkRect& oval,
                              const GrStrokeInfo& strokeInfo) {
     ASSERT_SINGLE_OWNER
     RETURN_IF_ABANDONED
     SkDEBUGCODE(this->validate();)
     GR_AUDIT_TRAIL_AUTO_FRAME(fAuditTrail, "GrDrawContext::drawOval");
 
     if (oval.isEmpty()) {
        return;
     }
 
     SkASSERT(!strokeInfo.isDashed()); // this should've been devolved to a path in SkGpuDevice
 
     AutoCheckFlush acf(fDrawingManager);
 
+    GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
+    GrColor color = paint.getColor();
+    
     if (should_apply_coverage_aa(paint, fRenderTarget)) {
         GrShaderCaps* shaderCaps = fContext->caps()->shaderCaps();
-        SkAutoTUnref<GrDrawBatch> batch(GrOvalRenderer::CreateOvalBatch(paint.getColor(),
+        SkAutoTUnref<GrDrawBatch> batch(GrOvalRenderer::CreateOvalBatch(color,
                                                                         viewMatrix,
                                                                         oval,
                                                                         strokeInfo,
                                                                         shaderCaps));
         if (batch) {
-            GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
             this->getDrawTarget()->drawBatch(pipelineBuilder, batch);
             return;
         }
     }
 
     SkPath path;
     path.setIsVolatile(true);
     path.addOval(oval);
-    this->internalDrawPath(clip, paint, viewMatrix, path, strokeInfo);
+    this->internalDrawPath(&pipelineBuilder, viewMatrix, color,
+                           paint.isAntiAlias(), path, strokeInfo);
 }
 
 void GrDrawContext::drawImageNine(const GrClip& clip,
                                   const GrPaint& paint,
                                   const SkMatrix& viewMatrix,
                                   int imageWidth,
                                   int imageHeight,
                                   const SkIRect& center,
                                   const SkRect& dst) {
     ASSERT_SINGLE_OWNER
@@ skipping 97 matching lines @@
     SkDEBUGCODE(this->validate();)
     GR_AUDIT_TRAIL_AUTO_FRAME(fAuditTrail, "GrDrawContext::drawPath");
 
     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(fDrawingManager);
 
+    GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
     if (should_apply_coverage_aa(paint, fRenderTarget) && !strokeInfo.isDashed()) {
         if (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(
-                    paint.getColor(), viewMatrix, rects));
-
-                GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
+                    color, viewMatrix, rects));
                 this->getDrawTarget()->drawBatch(pipelineBuilder, batch);
                 return;
             }
         }
         SkRect ovalRect;
         bool isOval = path.isOval(&ovalRect);
 
         if (isOval && !path.isInverseFillType()) {
             GrShaderCaps* shaderCaps = fContext->caps()->shaderCaps();
-            SkAutoTUnref<GrDrawBatch> batch(GrOvalRenderer::CreateOvalBatch(paint.getColor(),
+            SkAutoTUnref<GrDrawBatch> batch(GrOvalRenderer::CreateOvalBatch(color,
                                                                             viewMatrix,
                                                                             ovalRect,
                                                                             strokeInfo,
                                                                             shaderCaps));
             if (batch) {
-                GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
                 this->getDrawTarget()->drawBatch(pipelineBuilder, batch);
                 return;
             }
         }
     }
-
-    // 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.
-    this->internalDrawPath(clip, paint, viewMatrix, path, strokeInfo);
+    this->internalDrawPath(&pipelineBuilder, viewMatrix, color,
+                           paint.isAntiAlias(), path, strokeInfo);
 }
 
-void GrDrawContext::internalDrawPath(const GrClip& clip,
-                                     const GrPaint& paint,
+void GrDrawContext::internalDrawPath(GrPipelineBuilder* pipelineBuilder,
                                      const SkMatrix& viewMatrix,
+                                     GrColor color,
+                                     bool useAA,
                                      const SkPath& path,
                                      const GrStrokeInfo& strokeInfo) {
     ASSERT_SINGLE_OWNER
     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 = should_apply_coverage_aa(paint, fRenderTarget);
-    const bool isStencilDisabled = true;
-    bool isStencilBufferMSAA = fRenderTarget->isStencilBufferMultisampled();
+    bool useCoverageAA = useAA &&
+        !pipelineBuilder->getRenderTarget()->isUnifiedMultisampled();
+    bool isStencilDisabled = pipelineBuilder->getStencil().isDisabled();
+    bool isStencilBufferMSAA = pipelineBuilder->getRenderTarget()->isStencilBufferMultisampled();
 
     const GrPathRendererChain::DrawType type =
         useCoverageAA ? GrPathRendererChain::kColorAntiAlias_DrawType
                       : GrPathRendererChain::kColor_DrawType;
 
     const SkPath* pathPtr = &path;
     SkTLazy<SkPath> tmpPath;
     const GrStrokeInfo* strokeInfoPtr = &strokeInfo;
 
     GrPathRenderer::CanDrawPathArgs canDrawArgs;
@@ skipping 52 matching lines @@
         pr = fDrawingManager->getPathRenderer(canDrawArgs, true, type);
     }
 
     if (nullptr == pr) {
 #ifdef SK_DEBUG
         SkDebugf("Unable to find path renderer compatible with path.\n");
 #endif
         return;
     }
 
-    GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
-
     GrPathRenderer::DrawPathArgs args;
     args.fTarget = this->getDrawTarget();
     args.fResourceProvider = fDrawingManager->getContext()->resourceProvider();
-    args.fPipelineBuilder = &pipelineBuilder;
-    args.fColor = paint.getColor();
+    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) {
     ASSERT_SINGLE_OWNER
     RETURN_IF_ABANDONED
     SkDEBUGCODE(this->validate();)
     GR_AUDIT_TRAIL_AUTO_FRAME(fAuditTrail, "GrDrawContext::drawBatch");
 
     this->getDrawTarget()->drawBatch(*pipelineBuilder, batch);
 }