Remove GrPathCmd

src/gpu/GrAAHairLinePathRenderer.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 "GrAAHairLinePathRenderer.h"
 
@@ skipping 201 matching lines @@
 
     int totalQuadCount = 0;
     GrRect bounds;
     GrIRect ibounds;
 
     bool persp = m.hasPerspective();
 
     for (;;) {
         GrPoint pts[4];
         GrPoint devPts[4];
-        GrPathCmd cmd = (GrPathCmd)iter.next(pts);
-        switch (cmd) {
-            case kMove_PathCmd:
+        SkPath::Verb verb = iter.next(pts);
+        switch (verb) {
+            case SkPath::kMove_Verb:
                 break;
-            case kLine_PathCmd:
+            case SkPath::kLine_Verb:
                 m.mapPoints(devPts, pts, 2);
                 bounds.setBounds(devPts, 2);
                 bounds.outset(SK_Scalar1, SK_Scalar1);
                 bounds.roundOut(&ibounds);
                 if (SkIRect::Intersects(devClipBounds, ibounds)) {
                     SkPoint* pts = lines->push_back_n(2);
                     pts[0] = devPts[0];
                     pts[1] = devPts[1];
                 }
                 break;
-            case kQuadratic_PathCmd:
+            case SkPath::kQuad_Verb:
                 m.mapPoints(devPts, pts, 3);
                 bounds.setBounds(devPts, 3);
                 bounds.outset(SK_Scalar1, SK_Scalar1);
                 bounds.roundOut(&ibounds);
                 if (SkIRect::Intersects(devClipBounds, ibounds)) {
                     int subdiv = num_quad_subdivs(devPts);
                     GrAssert(subdiv >= -1);
                     if (-1 == subdiv) {
                         SkPoint* pts = lines->push_back_n(4);
                         pts[0] = devPts[0];
                         pts[1] = devPts[1];
                         pts[2] = devPts[1];
                         pts[3] = devPts[2];
                     } else {
                         // when in perspective keep quads in src space
                         SkPoint* qPts = persp ? pts : devPts;
                         SkPoint* pts = quads->push_back_n(3);
                         pts[0] = qPts[0];
                         pts[1] = qPts[1];
                         pts[2] = qPts[2];
                         quadSubdivCnts->push_back() = subdiv;
                         totalQuadCount += 1 << subdiv;
                     }
                 }
                 break;
-            case kCubic_PathCmd:
+            case SkPath::kCubic_Verb:
                 m.mapPoints(devPts, pts, 4);
                 bounds.setBounds(devPts, 4);
                 bounds.outset(SK_Scalar1, SK_Scalar1);
                 bounds.roundOut(&ibounds);
                 if (SkIRect::Intersects(devClipBounds, ibounds)) {
                     PREALLOC_PTARRAY(32) q;
                     // we don't need a direction if we aren't constraining the subdivision
                     static const SkPath::Direction kDummyDir = SkPath::kCCW_Direction;
                     // We convert cubics to quadratics (for now).
                     // In perspective have to do conversion in src space.
@@ skipping 36 matching lines @@
                                 pts[0] = q[0 + i];
                                 pts[1] = q[1 + i];
                                 pts[2] = q[2 + i];
                                 quadSubdivCnts->push_back() = subdiv;
                                 totalQuadCount += 1 << subdiv;
                             }
                         }
                     }
                 }
                 break;
-            case kClose_PathCmd:
+            case SkPath::kClose_Verb:
                 break;
-            case kEnd_PathCmd:
+            case SkPath::kDone_Verb:
                 return totalQuadCount;
         }
     }
 }
 
 struct Vertex {
     GrPoint fPos;
     union {
         struct {
             SkScalar fA;
@@ skipping 506 matching lines @@
                             4 * lineCnt + kVertsPerQuad*quads, // startV
                             0,                                 // startI
                             kVertsPerQuad*n,                   // vCount
                             kIdxsPerQuad*n);                   // iCount
         quads += n;
     }
     target->resetIndexSource();
 
     return true;
 }