Remove GrPathCmd

src/gpu/GrDefaultPathRenderer.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrDefaultPathRenderer.h"
 
@@ skipping 235 matching lines @@
     GrPoint* vert = base;
 
     GrPoint pts[4];
 
     bool first = true;
     int subpath = 0;
 
     SkPath::Iter iter(path, false);
 
     for (;;) {
-        GrPathCmd cmd = (GrPathCmd)iter.next(pts);
-        switch (cmd) {
-            case kMove_PathCmd:
+        SkPath::Verb verb = iter.next(pts);
+        switch (verb) {
+            case SkPath::kMove_Verb:
                 if (!first) {
                     uint16_t currIdx = (uint16_t) (vert - base);
                     subpathIdxStart = currIdx;
                     ++subpath;
                 }
                 *vert = pts[0];
                 vert++;
                 break;
-            case kLine_PathCmd:
+            case SkPath::kLine_Verb:
                 if (indexed) {
                     uint16_t prevIdx = (uint16_t)(vert - base) - 1;
                     append_countour_edge_indices(isHairline, subpathIdxStart,
                                                  prevIdx, &idx);
                 }
                 *(vert++) = pts[1];
                 break;
-            case kQuadratic_PathCmd: {
+            case SkPath::kQuad_Verb: {
                 // first pt of quad is the pt we ended on in previous step
                 uint16_t firstQPtIdx = (uint16_t)(vert - base) - 1;
                 uint16_t numPts =  (uint16_t)
                     GrPathUtils::generateQuadraticPoints(
                             pts[0], pts[1], pts[2],
                             srcSpaceTolSqd, &vert,
                             GrPathUtils::quadraticPointCount(pts, srcSpaceTol));
                 if (indexed) {
                     for (uint16_t i = 0; i < numPts; ++i) {
                         append_countour_edge_indices(isHairline, subpathIdxStart,
                                                      firstQPtIdx + i, &idx);
                     }
                 }
                 break;
             }
-            case kCubic_PathCmd: {
+            case SkPath::kCubic_Verb: {
                 // first pt of cubic is the pt we ended on in previous step
                 uint16_t firstCPtIdx = (uint16_t)(vert - base) - 1;
                 uint16_t numPts = (uint16_t) GrPathUtils::generateCubicPoints(
                                 pts[0], pts[1], pts[2], pts[3],
                                 srcSpaceTolSqd, &vert,
                                 GrPathUtils::cubicPointCount(pts, srcSpaceTol));
                 if (indexed) {
                     for (uint16_t i = 0; i < numPts; ++i) {
                         append_countour_edge_indices(isHairline, subpathIdxStart,
                                                      firstCPtIdx + i, &idx);
                     }
                 }
                 break;
             }
-            case kClose_PathCmd:
+            case SkPath::kClose_Verb:
                 break;
-            case kEnd_PathCmd:
+            case SkPath::kDone_Verb:
              // uint16_t currIdx = (uint16_t) (vert - base);
                 goto FINISHED;
         }
         first = false;
     }
 FINISHED:
     GrAssert((vert - base) <= maxPts);
     GrAssert((idx - idxBase) <= maxIdxs);
 
     *vertexCnt = vert - base;
@@ skipping 192 matching lines @@
                                   false);
 }
 
 void GrDefaultPathRenderer::onStencilPath(const SkPath& path,
                                           const SkStrokeRec& stroke,
                                           GrDrawTarget* target) {
     GrAssert(SkPath::kInverseEvenOdd_FillType != path.getFillType());
     GrAssert(SkPath::kInverseWinding_FillType != path.getFillType());
     this->internalDrawPath(path, stroke, target, true);
 }