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 "GrDrawingManager.h"
 #include "GrDrawContext.h"
 #include "GrDrawTarget.h"
 #include "GrGpuResourcePriv.h"
 #include "GrPaint.h"
 #include "GrPathRenderer.h"
 #include "GrRenderTarget.h"
 #include "GrRenderTargetPriv.h"
 #include "GrResourceProvider.h"
 #include "GrStencilAttachment.h"
 #include "GrSWMaskHelper.h"
@@ skipping 22 matching lines @@
                                          mat,
                                          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,
-                                   const SkMatrix& viewMatrix,
-                                   const Element* element,
-                                   GrPathRenderer** prOut,
-                                   bool needsStencil) {
+bool GrClipMaskManager::PathNeedsSWRenderer(GrContext* context,
+                                            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;
         }
         return false;
     } else {
         // We shouldn't get here with an empty clip element.
         SkASSERT(Element::kEmpty_Type != element->getType());
@@ skipping 11 matching lines @@
         if (needsStencil) {
             type = element->isAA()
                             ? GrPathRendererChain::kStencilAndColorAntiAlias_DrawType
                             : GrPathRendererChain::kStencilAndColor_DrawType;
         } else {
             type = element->isAA()
                             ? GrPathRendererChain::kColorAntiAlias_DrawType
                             : GrPathRendererChain::kColor_DrawType;    
         }
     
+        GrPathRenderer::CanDrawPathArgs canDrawArgs;
+        canDrawArgs.fShaderCaps = context->caps()->shaderCaps();
+        canDrawArgs.fViewMatrix = &viewMatrix;
+        canDrawArgs.fPath = &path;
+        canDrawArgs.fStroke = &stroke;
+        canDrawArgs.fAntiAlias = element->isAA();
+        canDrawArgs.fIsStencilDisabled = isStencilDisabled;
+        canDrawArgs.fIsStencilBufferMSAA = rt->isStencilBufferMultisampled();
+
         // the 'false' parameter disallows use of the SW path renderer
-        GrPathRenderer* pr = context->getPathRenderer(pipelineBuilder, viewMatrix, path,
-                                                      stroke, false, type);
+        GrPathRenderer* pr = context->drawingManager()->getPathRenderer(canDrawArgs, false, type);
         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 GrPathRenderer* get_path_renderer(GrContext* context,
-                                         GrPipelineBuilder* pipelineBuilder,
-                                         const SkMatrix& viewMatrix,
-                                         const SkClipStack::Element* element) {
+GrPathRenderer* GrClipMaskManager::GetPathRenderer(GrContext* context,
+                                                   GrTexture* texture,
+                                                   const SkMatrix& viewMatrix,
+                                                   const SkClipStack::Element* element) {
     GrPathRenderer* pr;
     static const bool kNeedsStencil = true;
-    path_needs_SW_renderer(context, *pipelineBuilder, viewMatrix, element, &pr, kNeedsStencil);
+    static const bool kStencilIsDisabled = true;
+    PathNeedsSWRenderer(context,
+                        kStencilIsDisabled,
+                        texture->asRenderTarget(),
+                        viewMatrix,
+                        element,
+                        &pr,
+                        kNeedsStencil);
     return pr;
 }
 
 GrClipMaskManager::GrClipMaskManager(GrDrawTarget* drawTarget)
     : fDrawTarget(drawTarget)
     , fClipMode(kIgnoreClip_StencilClipMode) {
 }
 
 GrContext* GrClipMaskManager::getContext() {
     return fDrawTarget->cmmAccess().context();
 }
 
 const GrCaps* GrClipMaskManager::caps() const {
     return fDrawTarget->caps();
 }
 
 GrResourceProvider* GrClipMaskManager::resourceProvider() {
     return fDrawTarget->cmmAccess().resourceProvider();
 }
 /*
  * 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 (PathNeedsSWRenderer(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);
+
+                GrPathRenderer::CanDrawPathArgs canDrawArgs;
+                canDrawArgs.fShaderCaps = this->getContext()->caps()->shaderCaps();
+                canDrawArgs.fViewMatrix = &viewMatrix;
+                canDrawArgs.fPath = &path;
+                canDrawArgs.fStroke = &stroke;
+                canDrawArgs.fAntiAlias = element->isAA();;
+                canDrawArgs.fIsStencilDisabled = pipelineBuilder->getStencil().isDisabled();
+                canDrawArgs.fIsStencilBufferMSAA = rt->isStencilBufferMultisampled();
+
+                pr = this->getContext()->drawingManager()->getPathRenderer(canDrawArgs, false, type);
             }
             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 82 matching lines @@
     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());
 
-            GrPathRenderer* pr = get_path_renderer(this->getContext(), &pipelineBuilder,
-                                                   translate, element);
+            SkASSERT(pipelineBuilder.getStencil().isDisabled());
+            GrPathRenderer* pr = GetPathRenderer(this->getContext(),
+                                                 texture, translate, element);
             if (Element::kRect_Type != element->getType() && !pr) {
                 // useSWOnlyPath should now filter out all cases where gpu-side mask merging would
                 // be performed (i.e., pr would be NULL for a non-rect path). See skbug.com/4519
                 // for rationale and details.
                 SkASSERT(0);
                 continue;
             }
 
             // draw directly into the result with the stencil set to make the pixels affected
             // by the clip shape be non-zero.
@@ skipping 113 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,
-                                                         clipPath,
-                                                         stroke,
-                                                         false,
-                                                         GrPathRendererChain::kStencilOnly_DrawType,
-                                                         &stencilSupport);
+
+                SkASSERT(pipelineBuilder.getStencil().isDisabled());
+
+                GrPathRenderer::CanDrawPathArgs canDrawArgs;
+                canDrawArgs.fShaderCaps = this->getContext()->caps()->shaderCaps();
+                canDrawArgs.fViewMatrix = &viewMatrix;
+                canDrawArgs.fPath = &clipPath;
+                canDrawArgs.fStroke = &stroke;
+                canDrawArgs.fAntiAlias = false;
+                canDrawArgs.fIsStencilDisabled = pipelineBuilder.getStencil().isDisabled();
+                canDrawArgs.fIsStencilBufferMSAA = rt->isStencilBufferMultisampled();
+
+                pr = this->getContext()->drawingManager()->getPathRenderer(canDrawArgs, false,
+                                                                           GrPathRendererChain::kStencilOnly_DrawType,
+                                                                           &stencilSupport);
                 if (nullptr == pr) {
                     return false;
                 }
             }
 
             int passes;
             GrStencilSettings stencilSettings[GrStencilSettings::kMaxStencilClipPasses];
 
             bool canRenderDirectToStencil =
                 GrPathRenderer::kNoRestriction_StencilSupport == stencilSupport;
@@ skipping 335 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 
 void GrClipMaskManager::adjustPathStencilParams(const GrStencilAttachment* stencilAttachment,
                                                 GrStencilSettings* settings) {
     if (stencilAttachment) {
         int stencilBits = stencilAttachment->bits();
         this->adjustStencilParams(settings, fClipMode, stencilBits);
     }
 }