move SkPath direction-as-computed into SkPathPriv

src/core/SkStroke.cpp

 /*
  * Copyright 2008 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkStrokerPriv.h"
 #include "SkGeometry.h"
-#include "SkPath.h"
+#include "SkPathPriv.h"
 
 enum {
     kTangent_RecursiveLimit,
     kCubic_RecursiveLimit,
     kConic_RecursiveLimit,
     kQuad_RecursiveLimit
 };
 
 // quads with extreme widths (e.g. (0,1) (1,6) (0,3) width=5e7) recurse to point of failure
 // largest seen for normal cubics : 5, 26
@@ skipping 1316 matching lines @@
                 stroker.close(lastSegment == SkPath::kLine_Verb);
                 break;
             case SkPath::kDone_Verb:
                 goto DONE;
         }
     }
 DONE:
     stroker.done(dst, lastSegment == SkPath::kLine_Verb);
 
     if (fDoFill) {
-        if (src.cheapIsDirection(SkPath::kCCW_Direction)) {
+        if (SkPathPriv::CheapIsFirstDirection(src, SkPathPriv::kCCW_FirstDirection)) {
             dst->reverseAddPath(src);
         } else {
             dst->addPath(src);
         }
     } else {
         //  Seems like we can assume that a 2-point src would always result in
         //  a convex stroke, but testing has proved otherwise.
         //  TODO: fix the stroker to make this assumption true (without making
         //  it slower that the work that will be done in computeConvexity())
 #if 0
@@ skipping 14 matching lines @@
     }
 
     // our answer should preserve the inverseness of the src
     if (src.isInverseFillType()) {
         SkASSERT(!dst->isInverseFillType());
         dst->toggleInverseFillType();
     }
 }
 
 static SkPath::Direction reverse_direction(SkPath::Direction dir) {
-    SkASSERT(SkPath::kUnknown_Direction != dir);
-    return SkPath::kCW_Direction == dir ? SkPath::kCCW_Direction : SkPath::kCW_Direction;
+    static const SkPath::Direction gOpposite[] = { SkPath::kCCW_Direction, SkPath::kCW_Direction };
+    return gOpposite[dir];
 }
 
 static void addBevel(SkPath* path, const SkRect& r, const SkRect& outer, SkPath::Direction dir) {
     SkPoint pts[8];
 
     if (SkPath::kCW_Direction == dir) {
         pts[0].set(r.fLeft, outer.fTop);
         pts[1].set(r.fRight, outer.fTop);
         pts[2].set(outer.fRight, r.fTop);
         pts[3].set(outer.fRight, r.fBottom);
@@ skipping 56 matching lines @@
         default:
             break;
     }
 
     if (fWidth < SkMinScalar(rw, rh) && !fDoFill) {
         r = rect;
         r.inset(radius, radius);
         dst->addRect(r, reverse_direction(dir));
     }
 }