move SkPath direction-as-computed into SkPathPriv

src/pathops/SkOpBuilder.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkMatrix.h"
 #include "SkOpEdgeBuilder.h"
-#include "SkPath.h"
+#include "SkPathPriv.h"
 #include "SkPathOps.h"
 #include "SkPathOpsCommon.h"
 
 static bool one_contour(const SkPath& path) {
     SkChunkAlloc allocator(256);
     int verbCount = path.countVerbs();
     uint8_t* verbs = (uint8_t*) allocator.alloc(sizeof(uint8_t) * verbCount,
             SkChunkAlloc::kThrow_AllocFailType);
     (void) path.getVerbs(verbs, verbCount);
     for (int index = 1; index < verbCount; ++index) {
         if (verbs[index] == SkPath::kMove_Verb) {
             return false;
         }
     }
     return true;
 }
 
 void FixWinding(SkPath* path) {
     SkPath::FillType fillType = path->getFillType();
     if (fillType == SkPath::kInverseEvenOdd_FillType) {
         fillType = SkPath::kInverseWinding_FillType;
     } else if (fillType == SkPath::kEvenOdd_FillType) {
         fillType = SkPath::kWinding_FillType;
     }
-    SkPath::Direction dir;
-    if (one_contour(*path) && path->cheapComputeDirection(&dir)) {
-        if (dir != SkPath::kCCW_Direction) {
+    SkPathPriv::FirstDirection dir;
+    if (one_contour(*path) && SkPathPriv::CheapComputeFirstDirection(*path, &dir)) {
+        if (dir != SkPathPriv::kCCW_FirstDirection) {
             SkPath temp;
             temp.reverseAddPath(*path);
             *path = temp;
         }
         path->setFillType(fillType);
         return;
     }
     SkChunkAlloc allocator(4096);
     SkOpContourHead contourHead;
     SkOpGlobalState globalState(NULL, &contourHead);
@@ skipping 51 matching lines @@
     fOps.reset();
 }
 
 /* OPTIMIZATION: Union doesn't need to be all-or-nothing. A run of three or more convex
    paths with union ops could be locally resolved and still improve over doing the
    ops one at a time. */
 bool SkOpBuilder::resolve(SkPath* result) {
     SkPath original = *result;
     int count = fOps.count();
     bool allUnion = true;
-    SkPath::Direction firstDir;
+    SkPathPriv::FirstDirection firstDir;
     for (int index = 0; index < count; ++index) {
         SkPath* test = &fPathRefs[index];
         if (kUnion_SkPathOp != fOps[index] || test->isInverseFillType()) {
             allUnion = false;
             break;
         }
         // If all paths are convex, track direction, reversing as needed.
         if (test->isConvex()) {
-            SkPath::Direction dir;
-            if (!test->cheapComputeDirection(&dir)) {
+            SkPathPriv::FirstDirection dir;
+            if (!SkPathPriv::CheapComputeFirstDirection(*test, &dir)) {
                 allUnion = false;
                 break;
             }
             if (index == 0) {
                 firstDir = dir;
             } else if (firstDir != dir) {
                 SkPath temp;
                 temp.reverseAddPath(*test);
                 *test = temp;
             }
@@ skipping 32 matching lines @@
         FixWinding(&fPathRefs[index]);
         sum.addPath(fPathRefs[index]);
     }
     reset();
     bool success = Simplify(sum, result);
     if (!success) {
         *result = original;
     }
     return success;
 }