Remove GrPipelineBuilder from getPathRenderer call

src/gpu/GrClipMaskManager.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrClipMaskManager.h"
 #include "GrCaps.h"
 #include "GrDrawContext.h"
@@ skipping 32 matching lines @@
                                          GrTextureDomain::MakeTexelDomain(result, domainTexels),
                                          GrTextureDomain::kDecal_Mode,
                                          GrTextureParams::kNone_FilterMode,
                                          kDevice_GrCoordSet);
 }
 
 // Does the path in 'element' require SW rendering? If so, return true (and,
 // optionally, set 'prOut' to NULL. If not, return false (and, optionally, set
 // 'prOut' to the non-SW path renderer that will do the job).
 static bool path_needs_SW_renderer(GrContext* context,
-                                   const GrPipelineBuilder& pipelineBuilder,
+                                   bool isStencilDisabled,
+                                   const GrRenderTarget* rt,
                                    const SkMatrix& viewMatrix,
                                    const Element* element,
                                    GrPathRenderer** prOut,
                                    bool needsStencil) {
     if (Element::kRect_Type == element->getType()) {
         // rects can always be drawn directly w/o using the software path
         // TODO: skip rrects once we're drawing them directly.
         if (prOut) {
             *prOut = nullptr;
         }
@@ skipping 16 matching lines @@
             type = element->isAA()
                             ? GrPathRendererChain::kStencilAndColorAntiAlias_DrawType
                             : GrPathRendererChain::kStencilAndColor_DrawType;
         } else {
             type = element->isAA()
                             ? GrPathRendererChain::kColorAntiAlias_DrawType
                             : GrPathRendererChain::kColor_DrawType;    
         }
     
         // the 'false' parameter disallows use of the SW path renderer
-        GrPathRenderer* pr = context->getPathRenderer(pipelineBuilder, viewMatrix, path,
-                                                      stroke, false, type);
+        GrPathRenderer* pr = context->getPathRenderer(viewMatrix, path,
+                                                      stroke, false, type,
+                                                      isStencilDisabled,
+                                                      rt->isStencilBufferMultisampled());
         if (prOut) {
             *prOut = pr;
         }
         return SkToBool(!pr);
     }
 }
 
 // Determines whether it is possible to draw the element to both the stencil buffer and the
 // alpha mask simultaneously. If so and the element is a path a compatible path renderer is
 // also returned.
 static bool can_stencil_and_draw_element(GrContext* context,
-                                         GrPipelineBuilder* pipelineBuilder,
                                          GrTexture* texture,
                                          const SkMatrix& viewMatrix,
                                          const SkClipStack::Element* element,
                                          GrPathRenderer** pr) {
-    pipelineBuilder->setRenderTarget(texture->asRenderTarget());
-
     static const bool kNeedsStencil = true;
+    static const bool kStencilIsDisabled = true;
     return !path_needs_SW_renderer(context,
-                                   *pipelineBuilder,
+                                   kStencilIsDisabled,
+                                   texture->asRenderTarget(),
                                    viewMatrix,
                                    element,
                                    pr,
                                    kNeedsStencil);
 }
 
 GrClipMaskManager::GrClipMaskManager(GrDrawTarget* drawTarget)
     : fDrawTarget(drawTarget)
     , fClipMode(kIgnoreClip_StencilClipMode) {
 }
 
 GrContext* GrClipMaskManager::getContext() { return fDrawTarget->cmmAccess().context(); }
 
 /*
  * This method traverses the clip stack to see if the GrSoftwarePathRenderer
  * will be used on any element. If so, it returns true to indicate that the
  * entire clip should be rendered in SW and then uploaded en masse to the gpu.
  */
 bool GrClipMaskManager::useSWOnlyPath(const GrPipelineBuilder& pipelineBuilder,
+                                      const GrRenderTarget* rt,
                                       const SkVector& clipToMaskOffset,
                                       const GrReducedClip::ElementList& elements) {
     // TODO: generalize this function so that when
     // a clip gets complex enough it can just be done in SW regardless
     // of whether it would invoke the GrSoftwarePathRenderer.
 
     // Set the matrix so that rendered clip elements are transformed to mask space from clip
     // space.
     const SkMatrix translate = SkMatrix::MakeTrans(clipToMaskOffset.fX, clipToMaskOffset.fY);
 
     for (GrReducedClip::ElementList::Iter iter(elements.headIter()); iter.get(); iter.next()) {
         const Element* element = iter.get();
 
         SkRegion::Op op = element->getOp();
         bool invert = element->isInverseFilled();
         bool needsStencil = invert || 
                             SkRegion::kIntersect_Op == op || SkRegion::kReverseDifference_Op == op;
 
-        if (path_needs_SW_renderer(this->getContext(), pipelineBuilder, translate,
-                                   element, nullptr, needsStencil)) {
+        if (path_needs_SW_renderer(this->getContext(), pipelineBuilder.getStencil().isDisabled(),
+                                   rt, translate, element, nullptr, needsStencil)) {
             return true;
         }
     }
     return false;
 }
 
 bool GrClipMaskManager::getAnalyticClipProcessor(const GrReducedClip::ElementList& elements,
                                                  bool abortIfAA,
                                                  SkVector& clipToRTOffset,
                                                  const SkRect* drawBounds,
@@ skipping 189 matching lines @@
     // If MSAA is enabled we can do everything in the stencil buffer.
     if (0 == rt->numStencilSamples() && requiresAA) {
         SkAutoTUnref<GrTexture> result;
 
         // The top-left of the mask corresponds to the top-left corner of the bounds.
         SkVector clipToMaskOffset = {
             SkIntToScalar(-clipSpaceIBounds.fLeft),
             SkIntToScalar(-clipSpaceIBounds.fTop)
         };
 
-        if (this->useSWOnlyPath(pipelineBuilder, clipToMaskOffset, elements)) {
+        if (this->useSWOnlyPath(pipelineBuilder, rt, clipToMaskOffset, elements)) {
             // The clip geometry is complex enough that it will be more efficient to create it
             // entirely in software
             result.reset(this->createSoftwareClipMask(genID,
                                                       initialState,
                                                       elements,
                                                       clipToMaskOffset,
                                                       clipSpaceIBounds));
         } else {
             result.reset(this->createAlphaClipMask(genID,
                                                    initialState,
@@ skipping 45 matching lines @@
 }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 bool GrClipMaskManager::drawElement(GrPipelineBuilder* pipelineBuilder,
                                     const SkMatrix& viewMatrix,
                                     GrTexture* target,
                                     const SkClipStack::Element* element,
                                     GrPathRenderer* pr) {
 
-    pipelineBuilder->setRenderTarget(target->asRenderTarget());
+    GrRenderTarget* rt = target->asRenderTarget();
+    pipelineBuilder->setRenderTarget(rt);
 
     // The color we use to draw does not matter since we will always be using a GrCoverageSetOpXP
     // which ignores color.
     GrColor color = GrColor_WHITE;
 
     // TODO: Draw rrects directly here.
     switch (element->getType()) {
         case Element::kEmpty_Type:
             SkDEBUGFAIL("Should never get here with an empty element.");
             break;
@@ skipping 15 matching lines @@
             SkPath path;
             element->asPath(&path);
             if (path.isInverseFillType()) {
                 path.toggleInverseFillType();
             }
             GrStrokeInfo stroke(SkStrokeRec::kFill_InitStyle);
             if (nullptr == pr) {
                 GrPathRendererChain::DrawType type;
                 type = element->isAA() ? GrPathRendererChain::kColorAntiAlias_DrawType :
                                          GrPathRendererChain::kColor_DrawType;
-                pr = this->getContext()->getPathRenderer(*pipelineBuilder, viewMatrix,
-                                                         path, stroke, false, type);
+                pr = this->getContext()->getPathRenderer(viewMatrix,
+                                                         path, stroke, false, type,
+                                                         pipelineBuilder->getStencil().isDisabled(),
+                                                         rt->isStencilBufferMultisampled());
             }
             if (nullptr == pr) {
                 return false;
             }
             GrPathRenderer::DrawPathArgs args;
             args.fTarget = fDrawTarget;
             args.fResourceProvider = this->getContext()->resourceProvider();
             args.fPipelineBuilder = pipelineBuilder;
             args.fColor = color;
             args.fViewMatrix = &viewMatrix;
@@ skipping 124 matching lines @@
 
     // walk through each clip element and perform its set op
     for (GrReducedClip::ElementList::Iter iter = elements.headIter(); iter.get(); iter.next()) {
         const Element* element = iter.get();
         SkRegion::Op op = element->getOp();
         bool invert = element->isInverseFilled();
         if (invert || SkRegion::kIntersect_Op == op || SkRegion::kReverseDifference_Op == op) {
             GrPipelineBuilder pipelineBuilder;
 
             pipelineBuilder.setClip(clip);
+            pipelineBuilder.setRenderTarget(texture->asRenderTarget());
+
+            SkASSERT(pipelineBuilder.getStencil().isDisabled());
             GrPathRenderer* pr = nullptr;
-            bool useTemp = !can_stencil_and_draw_element(this->getContext(), &pipelineBuilder,
+            bool useTemp = !can_stencil_and_draw_element(this->getContext(),
                                                          texture, translate, element, &pr);
 
             // useSWOnlyPath should now filter out all cases where gpu-side mask merging is
             // performed. See skbug.com/4519 for rationale and details.
             SkASSERT(!useTemp);
 
             GrTexture* dst;
             // This is the bounds of the clip element in the space of the alpha-mask. The temporary
             // mask buffer can be substantially larger than the actually clip stack element. We
             // touch the minimum number of pixels necessary and use decal mode to combine it with
@@ skipping 158 matching lines @@
             SkPath clipPath;
             if (Element::kRect_Type == element->getType()) {
                 stencilSupport = GrPathRenderer::kNoRestriction_StencilSupport;
                 fillInverted = false;
             } else {
                 element->asPath(&clipPath);
                 fillInverted = clipPath.isInverseFillType();
                 if (fillInverted) {
                     clipPath.toggleInverseFillType();
                 }
-                pr = this->getContext()->getPathRenderer(pipelineBuilder,
-                                                         viewMatrix,
+
+                SkASSERT(pipelineBuilder.getStencil().isDisabled());
+
+                pr = this->getContext()->getPathRenderer(viewMatrix,
                                                          clipPath,
                                                          stroke,
                                                          false,
                                                          GrPathRendererChain::kStencilOnly_DrawType,
+                                                         true,
+                                                         rt->isStencilBufferMultisampled(),
                                                          &stencilSupport);
                 if (nullptr == pr) {
                     return false;
                 }
             }
 
             int passes;
             GrStencilSettings stencilSettings[GrStencilSettings::kMaxStencilClipPasses];
 
             bool canRenderDirectToStencil =
@@ skipping 337 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 
 void GrClipMaskManager::adjustPathStencilParams(const GrStencilAttachment* stencilAttachment,
                                                 GrStencilSettings* settings) {
     if (stencilAttachment) {
         int stencilBits = stencilAttachment->bits();
         this->adjustStencilParams(settings, fClipMode, stencilBits);
     }
 }