Beginning to refactor nvpr code

src/gpu/GrPathRendering.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrPathRendering_DEFINED
 #define GrPathRendering_DEFINED
 
 #include "SkPath.h"
 #include "GrPathRange.h"
 
 class SkStrokeRec;
 class SkDescriptor;
 class SkTypeface;
 class GrPath;
 class GrGpu;
+class GrStencilSettings;
 
 /**
  * Abstract class wrapping HW path rendering API.
  *
  * The subclasses of this class use the possible HW API to render paths (as opposed to path
  * rendering implemented in Skia on top of a "3d" HW API).
  * The subclasses hold the global state needed to render paths, including shadow of the global HW
  * API state. Similar to GrGpu.
  *
  * It is expected that the lifetimes of GrGpuXX and GrXXPathRendering are the same. The call context
  * interface (eg.  * the concrete instance of GrGpu subclass) should be provided to the instance
  * during construction.
  */
 class GrPathRendering {
 public:
     virtual ~GrPathRendering() { }
 
+    // No native support for inverse at this time
+    enum FillType {
+        /** Specifies that "inside" is computed by a non-zero sum of signed
+            edge crossings
+        */
+        kWinding_FillType,
+        /** Specifies that "inside" is computed by an odd number of edge
+            crossings
+        */
+        kEvenOdd_FillType,
+    };
+
     enum PathTransformType {
         kNone_PathTransformType,        //!< []
         kTranslateX_PathTransformType,  //!< [kMTransX]
         kTranslateY_PathTransformType,  //!< [kMTransY]
         kTranslate_PathTransformType,   //!< [kMTransX, kMTransY]
         kAffine_PathTransformType,      //!< [kMScaleX, kMSkewX, kMTransX, kMSkewY, kMScaleY, kMTransY]
 
         kLast_PathTransformType = kAffine_PathTransformType
     };
 
@@ skipping 58 matching lines @@
      *
      * @param SkStrokeRec  Common stroke that the GPU will apply to every path. Note that
      *                     if the glyph outlines contain baked-in strokes from the font
      *                     descriptor, the GPU stroke will be applied on top of those
      *                     outlines.
      *
      * @return a new path range populated with glyphs.
      */
     virtual GrPathRange* createGlyphs(const SkTypeface*, const SkDescriptor*, const SkStrokeRec&) = 0;
 
-    virtual void stencilPath(const GrPath*, SkPath::FillType) = 0;
-    virtual void drawPath(const GrPath*, SkPath::FillType) = 0;
+    virtual void stencilPath(const GrPath*, const GrStencilSettings&) = 0;
+    virtual void drawPath(const GrPath*, const GrStencilSettings&) = 0;
     virtual void drawPaths(const GrPathRange*, const uint32_t indices[], int count,
-                           const float transforms[], PathTransformType, SkPath::FillType) = 0;
+                           const float transforms[], PathTransformType,
+                           const GrStencilSettings&) = 0;
 protected:
     GrPathRendering() { }
 
 private:
     GrPathRendering& operator=(const GrPathRendering&);
 };
 
 #endif