Make GrClipMaskManager stateless and push GrPipelineBuilder construction downstack

src/gpu/batches/GrMSAAPathRenderer.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrMSAAPathRenderer.h"
 
+#include "GrAuditTrail.h"
 #include "GrBatchFlushState.h"
+#include "GrClip.h"
 #include "GrDefaultGeoProcFactory.h"
 #include "GrPathStencilSettings.h"
 #include "GrPathUtils.h"
 #include "GrPipelineBuilder.h"
 #include "GrMesh.h"
 #include "SkGeometry.h"
 #include "SkTraceEvent.h"
 #include "glsl/GrGLSLGeometryProcessor.h"
 #include "glsl/GrGLSLFragmentShaderBuilder.h"
 #include "glsl/GrGLSLVertexShaderBuilder.h"
@@ skipping 538 matching lines @@
     SkMatrix fViewMatrix;
     int fMaxLineVertices;
     int fMaxQuadVertices;
     int fMaxLineIndices;
     int fMaxQuadIndices;
     bool fIsIndexed;
 
     typedef GrVertexBatch INHERITED;
 };
 
-bool GrMSAAPathRenderer::internalDrawPath(GrDrawTarget* target,
-                                          GrPipelineBuilder* pipelineBuilder,
+bool GrMSAAPathRenderer::internalDrawPath(GrDrawContext* drawContext,
+                                          const GrPaint& paint,
+                                          const GrUserStencilSettings* userStencilSettings,
                                           const GrClip& clip,
                                           GrColor color,
                                           const SkMatrix& viewMatrix,
                                           const SkPath& path,
                                           bool stencilOnly) {
-
-    const GrXPFactory* xpFactory = pipelineBuilder->getXPFactory();
-    SkAutoTUnref<const GrXPFactory> backupXPFactory(SkSafeRef(xpFactory));
-    // face culling doesn't make sense here
-    SkASSERT(GrPipelineBuilder::kBoth_DrawFace == pipelineBuilder->getDrawFace());
-
     int                          passCount = 0;
     const GrUserStencilSettings* passes[3];
     GrPipelineBuilder::DrawFace  drawFace[3];
     bool                         reverse = false;
     bool                         lastPassIsBounds;
 
     if (single_pass_path(path)) {
         passCount = 1;
         if (stencilOnly) {
             passes[0] = &gDirectToStencil;
@@ skipping 44 matching lines @@
                     }
                 }
                 break;
             default:
                 SkDEBUGFAIL("Unknown path fFill!");
                 return false;
         }
     }
 
     SkRect devBounds;
-    GetPathDevBounds(path, pipelineBuilder->getRenderTarget(), viewMatrix, &devBounds);
+    GetPathDevBounds(path, drawContext->width(), drawContext->height(), viewMatrix, &devBounds);
 
     for (int p = 0; p < passCount; ++p) {
-        pipelineBuilder->setDrawFace(drawFace[p]);
-        if (passes[p]) {
-            pipelineBuilder->setUserStencil(passes[p]);
-        }
-
         if (lastPassIsBounds && (p == passCount-1)) {
-            // Reset the XP Factory on pipelineBuilder
-            pipelineBuilder->setXPFactory(backupXPFactory);
             SkRect bounds;
             SkMatrix localMatrix = SkMatrix::I();
             if (reverse) {
-                SkASSERT(pipelineBuilder->getRenderTarget());
                 // draw over the dev bounds (which will be the whole dst surface for inv fill).
                 bounds = devBounds;
                 SkMatrix vmi;
                 // mapRect through persp matrix may not be correct
                 if (!viewMatrix.hasPerspective() && viewMatrix.invert(&vmi)) {
                     vmi.mapRect(&bounds);
                 } else {
                     if (!viewMatrix.invert(&localMatrix)) {
                         return false;
                     }
                 }
             } else {
                 bounds = path.getBounds();
             }
             const SkMatrix& viewM = (reverse && viewMatrix.hasPerspective()) ? SkMatrix::I() :
                                                                                viewMatrix;
             SkAutoTUnref<GrDrawBatch> batch(
                     GrRectBatchFactory::CreateNonAAFill(color, viewM, bounds, nullptr,
                                                         &localMatrix));
-            target->drawBatch(*pipelineBuilder, clip, batch);
-        } else {
-            if (passCount > 1) {
-                pipelineBuilder->setDisableColorXPFactory();
+
+            GrPipelineBuilder pipelineBuilder(paint, drawContext->isUnifiedMultisampled());
+            pipelineBuilder.setRenderTarget(drawContext->accessRenderTarget());
+            pipelineBuilder.setDrawFace(drawFace[p]);
+            if (passes[p]) {
+                pipelineBuilder.setUserStencil(passes[p]);
+            } else {
+                pipelineBuilder.setUserStencil(userStencilSettings);
             }
 
+            drawContext->drawBatch(pipelineBuilder, clip, batch);
+        } else {
             MSAAPathBatch::Geometry geometry;
             geometry.fColor = color;
             geometry.fPath = path;
             geometry.fTolerance = kTolerance;
 
             SkAutoTUnref<MSAAPathBatch> batch(MSAAPathBatch::Create(geometry, viewMatrix, 
                                                                     devBounds));
-            if (batch->isValid()) {
-                target->drawBatch(*pipelineBuilder, clip, batch);
-            }
-            else {
+            if (!batch->isValid()) {
                 return false;
             }
+
+            GrPipelineBuilder pipelineBuilder(paint, drawContext->isUnifiedMultisampled());
+            pipelineBuilder.setRenderTarget(drawContext->accessRenderTarget());
+            pipelineBuilder.setDrawFace(drawFace[p]);
+            if (passes[p]) {
+                pipelineBuilder.setUserStencil(passes[p]);
+            } else {
+                pipelineBuilder.setUserStencil(userStencilSettings);
+            }
+            if (passCount > 1) {
+                pipelineBuilder.setDisableColorXPFactory();
+            }
+
+            drawContext->drawBatch(pipelineBuilder, clip, batch);
         }
     }
     return true;
 }
 
 bool GrMSAAPathRenderer::onCanDrawPath(const CanDrawPathArgs& args) const {
     // This path renderer does not support hairlines. We defer on anything that could be handled
     // as a hairline by another path renderer. Also, arbitrary path effects could produce
     // a hairline result.
     return !IsStrokeHairlineOrEquivalent(*args.fStyle, *args.fViewMatrix, nullptr) &&
            !args.fStyle->strokeRec().isHairlineStyle() &&
            !args.fStyle->hasNonDashPathEffect() && !args.fAntiAlias;
 }
 
 bool GrMSAAPathRenderer::onDrawPath(const DrawPathArgs& args) {
-    GR_AUDIT_TRAIL_AUTO_FRAME(args.fTarget->getAuditTrail(), "GrMSAAPathRenderer::onDrawPath");
+    GR_AUDIT_TRAIL_AUTO_FRAME(args.fDrawContext->auditTrail(),
+                              "GrMSAAPathRenderer::onDrawPath");
     SkPath tmpPath;
     const SkPath* path;
     if (args.fStyle->applies()) {
         SkStrokeRec::InitStyle fill;
         SkScalar styleScale = GrStyle::MatrixToScaleFactor(*args.fViewMatrix);
         if (!args.fStyle->applyToPath(&tmpPath, &fill, *args.fPath, styleScale)) {
             return false;
         }
         // We don't accept styles that are hairlines or have path effects that could produce
         // hairlines.
         SkASSERT(SkStrokeRec::kFill_InitStyle == fill);
         path = &tmpPath;
     } else {
         path = args.fPath;
     }
-    return this->internalDrawPath(args.fTarget,
-                                  args.fPipelineBuilder,
+    return this->internalDrawPath(args.fDrawContext,
+                                  *args.fPaint,
+                                  args.fUserStencilSettings,
                                   *args.fClip,
                                   args.fColor,
                                   *args.fViewMatrix,
                                   *path,
                                   false);
 }
 
 void GrMSAAPathRenderer::onStencilPath(const StencilPathArgs& args) {
-    GR_AUDIT_TRAIL_AUTO_FRAME(args.fTarget->getAuditTrail(),"GrMSAAPathRenderer::onStencilPath");
+    GR_AUDIT_TRAIL_AUTO_FRAME(args.fDrawContext->auditTrail(),
+                              "GrMSAAPathRenderer::onStencilPath");
     SkASSERT(SkPath::kInverseEvenOdd_FillType != args.fPath->getFillType());
     SkASSERT(SkPath::kInverseWinding_FillType != args.fPath->getFillType());
-    this->internalDrawPath(args.fTarget, args.fPipelineBuilder, *args.fClip, GrColor_WHITE,
-                           *args.fViewMatrix, *args.fPath, true);
+
+    GrPaint paint;
+    paint.setXPFactory(GrDisableColorXPFactory::Create());

[bungeman-skia, 2016/06/03 23:57:03]

leak

+    paint.setAntiAlias(args.fIsAA);
+
+    this->internalDrawPath(args.fDrawContext,
+                           paint,
+                           &GrUserStencilSettings::kUnused,
+                           *args.fClip,
+                           GrColor_WHITE,
+                           *args.fViewMatrix,
+                           *args.fPath,
+                           true);
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////