move SkPath direction-as-computed into SkPathPriv

include/core/SkPath.h

 /*
  * Copyright 2006 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.
  */
 
 #ifndef SkPath_DEFINED
 #define SkPath_DEFINED
 
@@ skipping 474 matching lines @@
     void arcTo(const SkPoint p1, const SkPoint p2, SkScalar radius) {
         this->arcTo(p1.fX, p1.fY, p2.fX, p2.fY, radius);
     }
 
     /** Close the current contour. If the current point is not equal to the
         first point of the contour, a line segment is automatically added.
     */
     void close();
 
     enum Direction {
-        /** Direction either has not been or could not be computed */
-        kUnknown_Direction,
         /** clockwise direction for adding closed contours */
         kCW_Direction,
         /** counter-clockwise direction for adding closed contours */
         kCCW_Direction,
     };
 
     /**
-     *  Return the opposite of the specified direction. kUnknown is its own
-     *  opposite.
-     */
-    static Direction OppositeDirection(Direction dir) {
-        static const Direction gOppositeDir[] = {
-            kUnknown_Direction, kCCW_Direction, kCW_Direction
-        };
-        return gOppositeDir[dir];
-    }
-
-    /**
      *  Returns whether or not a fill type is inverted
      *
      *  kWinding_FillType        -> false
      *  kEvenOdd_FillType        -> false
      *  kInverseWinding_FillType -> true
      *  kInverseEvenOdd_FillType -> true
      */
     static bool IsInverseFillType(FillType fill) {
         SK_COMPILE_ASSERT(0 == kWinding_FillType, fill_type_mismatch);
         SK_COMPILE_ASSERT(1 == kEvenOdd_FillType, fill_type_mismatch);
@@ skipping 12 matching lines @@
      */
     static FillType ConvertToNonInverseFillType(FillType fill) {
         SK_COMPILE_ASSERT(0 == kWinding_FillType, fill_type_mismatch);
         SK_COMPILE_ASSERT(1 == kEvenOdd_FillType, fill_type_mismatch);
         SK_COMPILE_ASSERT(2 == kInverseWinding_FillType, fill_type_mismatch);
         SK_COMPILE_ASSERT(3 == kInverseEvenOdd_FillType, fill_type_mismatch);
         return (FillType)(fill & 1);
     }
 
     /**
-     *  Tries to quickly compute the direction of the first non-degenerate
-     *  contour. If it can be computed, return true and set dir to that
-     *  direction. If it cannot be (quickly) determined, return false and ignore
-     *  the dir parameter. If the direction was determined, it is cached to make
-     *  subsequent calls return quickly.
-     */
-    bool cheapComputeDirection(Direction* dir) const;
-
-    /**
-     *  Returns true if the path's direction can be computed via
-     *  cheapComputDirection() and if that computed direction matches the
-     *  specified direction. If dir is kUnknown, returns true if the direction
-     *  cannot be computed.
-     */
-    bool cheapIsDirection(Direction dir) const {
-        Direction computedDir = kUnknown_Direction;
-        (void)this->cheapComputeDirection(&computedDir);
-        return computedDir == dir;
-    }
-
-    /**
      *  Returns true if the path specifies a rectangle.
      *
      *  If this returns false, then all output parameters are ignored, and left
      *  unchanged. If this returns true, then each of the output parameters
      *  are checked for NULL. If they are not, they return their value.
      *
      *  @param rect If not null, set to the bounds of the rectangle.
      *              Note : this bounds may be smaller than the path's bounds, since it is just
      *              the bounds of the "drawable" parts of the path. e.g. a trailing MoveTo would
      *              be ignored in this rect, but not by the path's bounds
@@ skipping 13 matching lines @@
 
         @param rect If not null, returns the path as a pair of nested rectangles
         @param dirs If not null, returns the direction of the rects
         @return true if the path describes a pair of nested rectangles
     */
     bool isNestedFillRects(SkRect rect[2], Direction dirs[2] = NULL) const;
 
     /**
      *  Add a closed rectangle contour to the path
      *  @param rect The rectangle to add as a closed contour to the path
-     *  @param dir  The direction to wind the rectangle's contour. Cannot be
-     *              kUnknown_Direction.
+     *  @param dir  The direction to wind the rectangle's contour.
      */
     void addRect(const SkRect& rect, Direction dir = kCW_Direction);
 
     /**
      *  Add a closed rectangle contour to the path
      *
      *  @param left     The left side of a rectangle to add as a closed contour
      *                  to the path
      *  @param top      The top of a rectangle to add as a closed contour to the
      *                  path
      *  @param right    The right side of a rectangle to add as a closed contour
      *                  to the path
      *  @param bottom   The bottom of a rectangle to add as a closed contour to
      *                  the path
-     *  @param dir  The direction to wind the rectangle's contour. Cannot be
-     *              kUnknown_Direction.
+     *  @param dir  The direction to wind the rectangle's contour.
      */
     void addRect(SkScalar left, SkScalar top, SkScalar right, SkScalar bottom,
                  Direction dir = kCW_Direction);
 
     /**
      *  Add a closed oval contour to the path
      *
      *  @param oval The bounding oval to add as a closed contour to the path
-     *  @param dir  The direction to wind the oval's contour. Cannot be
-     *              kUnknown_Direction.
+     *  @param dir  The direction to wind the oval's contour.
      */
     void addOval(const SkRect& oval, Direction dir = kCW_Direction);
 
     /**
      *  Add a closed circle contour to the path
      *
      *  @param x        The x-coordinate of the center of a circle to add as a
      *                  closed contour to the path
      *  @param y        The y-coordinate of the center of a circle to add as a
      *                  closed contour to the path
      *  @param radius   The radius of a circle to add as a closed contour to the
      *                  path
-     *  @param dir  The direction to wind the circle's contour. Cannot be
-     *              kUnknown_Direction.
+     *  @param dir  The direction to wind the circle's contour.
      */
     void addCircle(SkScalar x, SkScalar y, SkScalar radius,
                    Direction dir = kCW_Direction);
 
     /** Add the specified arc to the path as a new contour.
 
         @param oval The bounds of oval used to define the size of the arc
         @param startAngle Starting angle (in degrees) where the arc begins
         @param sweepAngle Sweep angle (in degrees) measured clockwise
     */
     void addArc(const SkRect& oval, SkScalar startAngle, SkScalar sweepAngle);
 
     /**
      *  Add a closed round-rectangle contour to the path
      *  @param rect The bounds of a round-rectangle to add as a closed contour
      *  @param rx   The x-radius of the rounded corners on the round-rectangle
      *  @param ry   The y-radius of the rounded corners on the round-rectangle
-     *  @param dir  The direction to wind the rectangle's contour. Cannot be
-     *              kUnknown_Direction.
+     *  @param dir  The direction to wind the rectangle's contour.
      */
     void addRoundRect(const SkRect& rect, SkScalar rx, SkScalar ry,
                       Direction dir = kCW_Direction);
 
     /**
      *  Add a closed round-rectangle contour to the path. Each corner receives
      *  two radius values [X, Y]. The corners are ordered top-left, top-right,
      *  bottom-right, bottom-left.
      *  @param rect The bounds of a round-rectangle to add as a closed contour
      *  @param radii Array of 8 scalars, 4 [X,Y] pairs for each corner
-     *  @param dir  The direction to wind the rectangle's contour. Cannot be
-     *              kUnknown_Direction.
+     *  @param dir  The direction to wind the rectangle's contour.
      * Note: The radii here now go through the same constraint handling as the
      *       SkRRect radii (i.e., either radii at a corner being 0 implies a
      *       sqaure corner and oversized radii are proportionally scaled down).
      */
     void addRoundRect(const SkRect& rect, const SkScalar radii[],
                       Direction dir = kCW_Direction);
 
     /**
      *  Add an SkRRect contour to the path
      *  @param rrect The rounded rect to add as a closed contour
-     *  @param dir   The winding direction for the new contour. Cannot be
-     *               kUnknown_Direction.
+     *  @param dir   The winding direction for the new contour.
      */
     void addRRect(const SkRRect& rrect, Direction dir = kCW_Direction);
 
     /**
      *  Add a new contour made of just lines. This is just a fast version of
      *  the following:
      *      this->moveTo(pts[0]);
      *      for (int i = 1; i < count; ++i) {
      *          this->lineTo(pts[i]);
      *      }
@@ skipping 273 matching lines @@
         kConvexity_SerializationShift = 16, // requires 8 bits
         kFillType_SerializationShift = 8,   // requires 8 bits
         // 8 free bits at 0
     };
 
     SkAutoTUnref<SkPathRef> fPathRef;
 
     int                 fLastMoveToIndex;
     uint8_t             fFillType;
     mutable uint8_t     fConvexity;
-    mutable uint8_t     fDirection;
+    mutable uint8_t     fFirstDirection;    // SkPathPriv::FirstDirection
     mutable SkBool8     fIsVolatile;
 
     /** Resets all fields other than fPathRef to their initial 'empty' values.
      *  Assumes the caller has already emptied fPathRef.
      *  On Android increments fGenerationID without reseting it.
      */
     void resetFields();
 
     /** Sets all fields other than fPathRef to the values in 'that'.
      *  Assumes the caller has already set fPathRef.
      *  Doesn't change fGenerationID or fSourcePath on Android.
      */
     void copyFields(const SkPath& that);
 
     friend class Iter;
-
+    friend class SkPathPriv;
     friend class SkPathStroker;
 
     /*  Append, in reverse order, the first contour of path, ignoring path's
         last point. If no moveTo() call has been made for this contour, the
         first point is automatically set to (0,0).
     */
     void reversePathTo(const SkPath&);
 
     // called before we add points for lineTo, quadTo, cubicTo, checking to see
     // if we need to inject a leading moveTo first
@@ skipping 29 matching lines @@
     void setPt(int index, SkScalar x, SkScalar y);
 
     friend class SkAutoPathBoundsUpdate;
     friend class SkAutoDisableOvalCheck;
     friend class SkAutoDisableDirectionCheck;
     friend class SkBench_AddPathTest; // perf test reversePathTo
     friend class PathTest_Private; // unit test reversePathTo
 };
 
 #endif