move SkPath direction-as-computed into SkPathPriv

src/gpu/GrPathUtils.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 "GrPathUtils.h"
 
 #include "GrTypes.h"
@@ skipping 347 matching lines @@
 // a is the first control point of the cubic.
 // ab is the vector from a to the second control point.
 // dc is the vector from the fourth to the third control point.
 // d is the fourth control point.
 // p is the candidate quadratic control point.
 // this assumes that the cubic doesn't inflect and is simple
 bool is_point_within_cubic_tangents(const SkPoint& a,
                                     const SkVector& ab,
                                     const SkVector& dc,
                                     const SkPoint& d,
-                                    SkPath::Direction dir,
+                                    SkPathPriv::FirstDirection dir,
                                     const SkPoint p) {
     SkVector ap = p - a;
     SkScalar apXab = ap.cross(ab);
-    if (SkPath::kCW_Direction == dir) {
+    if (SkPathPriv::kCW_FirstDirection == dir) {
         if (apXab > 0) {
             return false;
         }
     } else {
-        SkASSERT(SkPath::kCCW_Direction == dir);
+        SkASSERT(SkPathPriv::kCCW_FirstDirection == dir);
         if (apXab < 0) {
             return false;
         }
     }
 
     SkVector dp = p - d;
     SkScalar dpXdc = dp.cross(dc);
-    if (SkPath::kCW_Direction == dir) {
+    if (SkPathPriv::kCW_FirstDirection == dir) {
         if (dpXdc < 0) {
             return false;
         }
     } else {
-        SkASSERT(SkPath::kCCW_Direction == dir);
+        SkASSERT(SkPathPriv::kCCW_FirstDirection == dir);
         if (dpXdc > 0) {
             return false;
         }
     }
     return true;
 }
 
 void convert_noninflect_cubic_to_quads(const SkPoint p[4],
                                        SkScalar toleranceSqd,
                                        bool constrainWithinTangents,
-                                       SkPath::Direction dir,
+                                       SkPathPriv::FirstDirection dir,
                                        SkTArray<SkPoint, true>* quads,
                                        int sublevel = 0) {
 
     // Notation: Point a is always p[0]. Point b is p[1] unless p[1] == p[0], in which case it is
     // p[2]. Point d is always p[3]. Point c is p[2] unless p[2] == p[3], in which case it is p[1].
 
     SkVector ab = p[1] - p[0];
     SkVector dc = p[2] - p[3];
 
     if (ab.isZero()) {
@@ skipping 127 matching lines @@
                                       constrainWithinTangents,
                                       dir,
                                       quads,
                                       sublevel + 1);
 }
 }
 
 void GrPathUtils::convertCubicToQuads(const SkPoint p[4],
                                       SkScalar tolScale,
                                       bool constrainWithinTangents,
-                                      SkPath::Direction dir,
+                                      SkPathPriv::FirstDirection dir,
                                       SkTArray<SkPoint, true>* quads) {
     SkPoint chopped[10];
     int count = SkChopCubicAtInflections(p, chopped);
 
     // base tolerance is 1 pixel.
     static const SkScalar kTolerance = SK_Scalar1;
     const SkScalar tolSqd = SkScalarSquare(SkScalarMul(tolScale, kTolerance));
 
     for (int i = 0; i < count; ++i) {
         SkPoint* cubic = chopped + 3*i;
@@ skipping 247 matching lines @@
         set_loop_klm(d, controlK, controlL, controlM);
     } else if (kCusp_SkCubicType == cType) {
         SkASSERT(0.f == d[0]);
         set_cusp_klm(d, controlK, controlL, controlM);
     } else if (kQuadratic_SkCubicType == cType) {
         set_quadratic_klm(d, controlK, controlL, controlM);
     }
 
     calc_cubic_klm(p, controlK, controlL, controlM, klm, &klm[3], &klm[6]);
 }