Separate user and raw stencil settings

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 "GrStencil.h"
 #include "GrStyle.h"
 
 #include "SkDrawProcs.h"
 #include "SkTArray.h"
 
 class SkPath;
 struct GrPoint;
 
 /**
  *  Base class for drawing paths into a GrDrawTarget.
@@ skipping 52 matching lines @@
      * fAntiAlias        True if anti-aliasing is required.
      */
     struct CanDrawPathArgs {
         const GrShaderCaps*         fShaderCaps;
         const SkMatrix*             fViewMatrix;
         const SkPath*               fPath;
         const GrStyle*              fStyle;
         bool                        fAntiAlias;
 
         // These next two are only used by GrStencilAndCoverPathRenderer
-        bool                        fIsStencilDisabled;
+        bool                        fHasUserStencilSettings;
         bool                        fIsStencilBufferMSAA;
 
         void validate() const {
             SkASSERT(fShaderCaps);
             SkASSERT(fViewMatrix);
             SkASSERT(fPath);
             SkASSERT(fStyle);
             SkASSERT(!fPath->isEmpty());
         }
     };
@@ skipping 52 matching lines @@
     bool drawPath(const DrawPathArgs& args) {
         SkDEBUGCODE(args.validate();)
 #ifdef SK_DEBUG
         CanDrawPathArgs canArgs;
         canArgs.fShaderCaps = args.fTarget->caps()->shaderCaps();
         canArgs.fViewMatrix = args.fViewMatrix;
         canArgs.fPath = args.fPath;
         canArgs.fStyle = args.fStyle;
         canArgs.fAntiAlias = args.fAntiAlias;
 
-        canArgs.fIsStencilDisabled = args.fPipelineBuilder->getStencil().isDisabled();
+        canArgs.fHasUserStencilSettings = args.fPipelineBuilder->hasUserStencilSettings();
         canArgs.fIsStencilBufferMSAA =
                           args.fPipelineBuilder->getRenderTarget()->isStencilBufferMultisampled();
         SkASSERT(this->canDrawPath(canArgs));
-        if (!args.fPipelineBuilder->getStencil().isDisabled()) {
+        if (args.fPipelineBuilder->hasUserStencilSettings()) {
             SkASSERT(kNoRestriction_StencilSupport == this->getStencilSupport(*args.fPath));
             SkASSERT(args.fStyle->isSimpleFill());
         }
 #endif
         return this->onDrawPath(args);
     }
 
     /* Args to stencilPath().
      *
      * fTarget                The target that the path will be rendered to.
@@ skipping 80 matching lines @@
     /**
      * Subclass implementation of canDrawPath()
      */
     virtual bool onCanDrawPath(const CanDrawPathArgs& args) const = 0;
 
     /**
      * Subclass implementation of stencilPath(). Subclass must override iff it ever returns
      * kStencilOnly in onGetStencilSupport().
      */
     virtual void onStencilPath(const StencilPathArgs& args) {
-        static constexpr GrStencilSettings kIncrementStencil(
-             kReplace_StencilOp,
-             kReplace_StencilOp,
-             kAlways_StencilFunc,
-             0xffff,
-             0xffff,
-             0xffff);
-        args.fPipelineBuilder->setStencil(kIncrementStencil);
+        static constexpr GrUserStencilSettings kIncrementStencil(
+            GrUserStencilSettings::StaticInit<
+                 0xffff,
+                 GrUserStencilTest::kAlways,
+                 0xffff,
+                 GrUserStencilOp::kReplace,
+                 GrUserStencilOp::kReplace,
+                 0xffff>()
+        );
+        args.fPipelineBuilder->setUserStencil(&kIncrementStencil);
         args.fPipelineBuilder->setDisableColorXPFactory();
         DrawPathArgs drawArgs;
         drawArgs.fTarget = args.fTarget;
         drawArgs.fResourceProvider = args.fResourceProvider;
         drawArgs.fPipelineBuilder = args.fPipelineBuilder;
         drawArgs.fColor = 0xFFFFFFFF;
         drawArgs.fViewMatrix = args.fViewMatrix;
         drawArgs.fPath = args.fPath;
         drawArgs.fStyle = &GrStyle::SimpleFill();
         drawArgs.fAntiAlias = false;
         drawArgs.fGammaCorrect = false;
         this->drawPath(drawArgs);
     }
 
     typedef SkRefCnt INHERITED;
 };
 
 #endif