Remove GrPipelineBuilder from getPathRenderer call

src/gpu/GrPathRenderer.h

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrPathRenderer_DEFINED
 #define GrPathRenderer_DEFINED
 
 #include "GrDrawTarget.h"
-#include "GrPathRendererChain.h"
 #include "GrStencil.h"
 #include "GrStrokeInfo.h"
 
 #include "SkDrawProcs.h"
 #include "SkTArray.h"
 
 class SkPath;
 
 struct GrPoint;
 
@@ skipping 20 matching lines @@
      *                    and calls drawPath(). The path is rendered exactly as the draw state
      *                    indicates including support for simultaneous color and stenciling with
      *                    arbitrary stenciling rules. Pixels partially covered by AA paths are
      *                    affected by the stencil settings.
      * 2) kStencilOnly: The path renderer cannot apply arbitrary stencil rules nor shade and stencil
      *                  simultaneously. The path renderer does support the stencilPath() function
      *                  which performs no color writes and writes a non-zero stencil value to pixels
      *                  covered by the path.
      * 3) kNoSupport: This path renderer cannot be used to stencil the path.
      */
-    typedef GrPathRendererChain::StencilSupport StencilSupport;
-    static const StencilSupport kNoSupport_StencilSupport =
-        GrPathRendererChain::kNoSupport_StencilSupport;
-    static const StencilSupport kStencilOnly_StencilSupport =
-        GrPathRendererChain::kStencilOnly_StencilSupport;
-    static const StencilSupport kNoRestriction_StencilSupport =
-        GrPathRendererChain::kNoRestriction_StencilSupport;
+    enum StencilSupport {
+        kNoSupport_StencilSupport,
+        kStencilOnly_StencilSupport,
+        kNoRestriction_StencilSupport,
+    };
 
     /**
      * This function is to get the stencil support for a particular path. The path's fill must
      * not be an inverse type.
      *
      * @param path      the path that will be drawn
      * @param stroke    the stroke information (width, join, cap).
      */
     StencilSupport getStencilSupport(const SkPath& path, const GrStrokeInfo& stroke) const {
         SkASSERT(!path.isInverseFillType());
         return this->onGetStencilSupport(path, stroke);
     }
 
     /** Args to canDrawPath()
      *
      * fShaderCaps       The shader caps
      * fPipelineBuilder  The pipelineBuilder
      * fViewMatrix       The viewMatrix
      * fPath             The path to draw
      * fStroke           The stroke information (width, join, cap)
      * fAntiAlias        True if anti-aliasing is required.
      */
     struct CanDrawPathArgs {
         const GrShaderCaps*         fShaderCaps;
-        const GrPipelineBuilder*    fPipelineBuilder;// only used by GrStencilAndCoverPathRenderer
         const SkMatrix*             fViewMatrix;
         const SkPath*               fPath;
         const GrStrokeInfo*         fStroke;
         bool                        fAntiAlias;
 
+        // These next two are only used by GrStencilAndCoverPathRenderer
+        bool                        fIsStencilDisabled;
+        bool                        fIsStencilBufferMSAA;
+
         void validate() const {
             SkASSERT(fShaderCaps);
-            SkASSERT(fPipelineBuilder);
             SkASSERT(fViewMatrix);
             SkASSERT(fPath);
             SkASSERT(fStroke);
             SkASSERT(!fPath->isEmpty());
         }
     };
 
     /**
      * Returns true if this path renderer is able to render the path. Returning false allows the
      * caller to fallback to another path renderer This function is called when searching for a path
@@ skipping 40 matching lines @@
 
     /**
      * Draws the path into the draw target. If getStencilSupport() would return kNoRestriction then
      * the subclass must respect the stencil settings of the GrPipelineBuilder.
      */
     bool drawPath(const DrawPathArgs& args) {
         SkDEBUGCODE(args.validate();)
 #ifdef SK_DEBUG
         CanDrawPathArgs canArgs;
         canArgs.fShaderCaps = args.fTarget->caps()->shaderCaps();
-        canArgs.fPipelineBuilder = args.fPipelineBuilder;
         canArgs.fViewMatrix = args.fViewMatrix;
         canArgs.fPath = args.fPath;
         canArgs.fStroke = args.fStroke;
         canArgs.fAntiAlias = args.fAntiAlias;
+
+        canArgs.fIsStencilDisabled = args.fPipelineBuilder->getStencil().isDisabled();
+        canArgs.fIsStencilBufferMSAA = 
+                          args.fPipelineBuilder->getRenderTarget()->isStencilBufferMultisampled();
         SkASSERT(this->canDrawPath(canArgs));
         SkASSERT(args.fPipelineBuilder->getStencil().isDisabled() ||
                  kNoRestriction_StencilSupport == this->getStencilSupport(*args.fPath,
                                                                           *args.fStroke));
 #endif
         return this->onDrawPath(args);
     }
 
     /* Args to stencilPath().
      *
@@ skipping 111 matching lines @@
         drawArgs.fStroke = args.fStroke;
         drawArgs.fAntiAlias = false;
         this->drawPath(drawArgs);
     }
 
 
     typedef SkRefCnt INHERITED;
 };
 
 #endif