Add IndexType parameter to GrDrawTarget::drawPaths

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
 
@@ skipping 16 matching lines @@
  * 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,
-    };
+    typedef GrPathRange::PathIndexType PathIndexType;
 
     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
     };
 
     static inline int PathTransformSize(PathTransformType type) {
         switch (type) {
             case kNone_PathTransformType:
                 return 0;
             case kTranslateX_PathTransformType:
             case kTranslateY_PathTransformType:
                 return 1;
             case kTranslate_PathTransformType:
                 return 2;
             case kAffine_PathTransformType:
                 return 6;
 
             default:
                 SkFAIL("Unknown path transform type");
                 return 0;
         }
     }
 
+    // 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,
+    };
+
     /**
      * Creates a new gpu path, based on the specified path and stroke and returns it.
      * The caller owns a ref on the returned path which must be balanced by a call to unref.
      *
      * @param skPath the path geometry.
      * @param stroke the path stroke.
      * @return a new path.
      */
     virtual GrPath* createPath(const SkPath&, const SkStrokeRec&) = 0;
 
@@ skipping 32 matching lines @@
      *                     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*, 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,
+    virtual void drawPaths(const GrPathRange*, const void* indices, PathIndexType,
+                           const float transformValues[], PathTransformType, int count,
                            const GrStencilSettings&) = 0;
 protected:
     GrPathRendering() { }
 
 private:
     GrPathRendering& operator=(const GrPathRendering&);
 };
 
 #endif