Simplify parameters passed to path renderers

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
@@ skipping 59 matching lines @@
         GrPathRendererChain::kNoSupport_StencilSupport;
     static const StencilSupport kStencilOnly_StencilSupport =
         GrPathRendererChain::kStencilOnly_StencilSupport;
     static const StencilSupport kNoRestriction_StencilSupport =
         GrPathRendererChain::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 target    target that the path will be rendered to
      * @param path      the path that will be drawn
      * @param stroke    the stroke information (width, join, cap).
      */
-    StencilSupport getStencilSupport(const GrDrawTarget* target,
-                                     const GrPipelineBuilder* pipelineBuilder,
-                                     const SkPath& path,
-                                     const GrStrokeInfo& stroke) const {
+    StencilSupport getStencilSupport(const SkPath& path, const GrStrokeInfo& stroke) const {
         SkASSERT(!path.isInverseFillType());
-        return this->onGetStencilSupport(target, pipelineBuilder, path, stroke);
+        return this->onGetStencilSupport(path, stroke);
     }
 
     /** Args to canDrawPath()
      *
-     * fTarget           The target that the path will be rendered to
+     * 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 GrDrawTarget*         fTarget;
-        const GrPipelineBuilder*    fPipelineBuilder;
+        SkAutoTUnref<const GrShaderCaps> fShaderCaps;

[bsalomon, 2015/08/13 13:49:35]

I don't think we need the ref/unref for this. We aren't doing it for the other
params. The caller is by definition holding on to the object (and not
transferring ownership to the called function).

[robertphillips, 2015/08/13 14:57:00]

Done.

+        const GrPipelineBuilder*    fPipelineBuilder;// only used by GrStencilAndCoverPathRenderer
         const SkMatrix*             fViewMatrix;
         const SkPath*               fPath;
         const GrStrokeInfo*         fStroke;
         bool                        fAntiAlias;
     };
 
     /**
      * 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
      * renderer capable of rendering a path.
      *
      * @return  true if the path can be drawn by this object, false otherwise.
      */
     bool canDrawPath(const CanDrawPathArgs& args) const {
-        SkASSERT(args.fTarget);
+        SkASSERT(args.fShaderCaps);
         SkASSERT(args.fPipelineBuilder);
         SkASSERT(args.fViewMatrix);
         SkASSERT(args.fPath);
         SkASSERT(args.fStroke);
         SkASSERT(!args.fPath->isEmpty());
         return this->onCanDrawPath(args);
     }
 
     /**
      * Args to drawPath()
@@ skipping 24 matching lines @@
     bool drawPath(const DrawPathArgs& args) {
         SkASSERT(args.fTarget);
         SkASSERT(args.fPipelineBuilder);
         SkASSERT(args.fViewMatrix);
         SkASSERT(args.fPath);
         SkASSERT(args.fStroke);
 
         SkASSERT(!args.fPath->isEmpty());
 #ifdef SK_DEBUG
         CanDrawPathArgs canArgs;
-        canArgs.fTarget = args.fTarget;
+        canArgs.fShaderCaps.reset(SkRef(args.fTarget->caps()->shaderCaps()));
         canArgs.fPipelineBuilder = args.fPipelineBuilder;
         canArgs.fViewMatrix = args.fViewMatrix;
         canArgs.fPath = args.fPath;
         canArgs.fStroke = args.fStroke;
         canArgs.fAntiAlias = args.fAntiAlias;
         SkASSERT(this->canDrawPath(canArgs));
         SkASSERT(args.fPipelineBuilder->getStencil().isDisabled() ||
-                 kNoRestriction_StencilSupport == this->getStencilSupport(args.fTarget,
-                                                                          args.fPipelineBuilder,
-                                                                          *args.fPath,
+                 kNoRestriction_StencilSupport == this->getStencilSupport(*args.fPath,
                                                                           *args.fStroke));
 #endif
         return this->onDrawPath(args);
     }
 
     /* Args to stencilPath().
      *
      * fTarget                The target that the path will be rendered to.
      * fPipelineBuilder       The pipeline builder.
      * fViewMatrix            Matrix applied to the path.
@@ skipping 15 matching lines @@
      *
      */
     void stencilPath(const StencilPathArgs& args) {
         SkASSERT(args.fTarget);
         SkASSERT(args.fPipelineBuilder);
         SkASSERT(args.fResourceProvider);
         SkASSERT(args.fViewMatrix);
         SkASSERT(args.fPath);
         SkASSERT(args.fStroke);
         SkASSERT(!args.fPath->isEmpty());
-        SkASSERT(kNoSupport_StencilSupport !=
-                 this->getStencilSupport(args.fTarget, args.fPipelineBuilder, *args.fPath,
-                                         *args.fStroke));
+        SkASSERT(kNoSupport_StencilSupport != this->getStencilSupport(*args.fPath, *args.fStroke));
         this->onStencilPath(args);
     }
 
     // Helper for determining if we can treat a thin stroke as a hairline w/ coverage.
     // If we can, we draw lots faster (raster device does this same test).
     static bool IsStrokeHairlineOrEquivalent(const GrStrokeInfo& stroke, const SkMatrix& matrix,
                                              SkScalar* outCoverage) {
         if (stroke.isDashed()) {
             return false;
         }
@@ skipping 21 matching lines @@
                                  const GrSurface* device,
                                  const SkMatrix& matrix,
                                  SkRect* bounds) {
         GetPathDevBounds(path, device->width(), device->height(), matrix, bounds);
     }
 
 private:
     /**
      * Subclass overrides if it has any limitations of stenciling support.
      */
-    virtual StencilSupport onGetStencilSupport(const GrDrawTarget*,
-                                               const GrPipelineBuilder*,
-                                               const SkPath&,
-                                               const GrStrokeInfo&) const {
+    virtual StencilSupport onGetStencilSupport(const SkPath&, const GrStrokeInfo&) const {
         return kNoRestriction_StencilSupport;
     }
 
     /**
      * Subclass implementation of drawPath()
      */
     virtual bool onDrawPath(const DrawPathArgs& args) = 0;
 
     /**
      * Subclass implementation of canDrawPath()
@@ skipping 24 matching lines @@
         drawArgs.fStroke = args.fStroke;
         drawArgs.fAntiAlias = false;
         this->drawPath(drawArgs);
     }
 
 
     typedef SkRefCnt INHERITED;
 };
 
 #endif