Move more of SkPath into SkPathRef

src/core/SkPath.cpp

 
 /*
  * 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.
  */
 
 
 #include "SkBuffer.h"
 #include "SkErrorInternals.h"
 #include "SkMath.h"
 #include "SkPath.h"
 #include "SkPathRef.h"
 #include "SkRRect.h"
 #include "SkThread.h"
 
 SK_DEFINE_INST_COUNT(SkPath);
 
-// This value is just made-up for now. When count is 4, calling memset was much
-// slower than just writing the loop. This seems odd, and hopefully in the
-// future this we appear to have been a fluke...
-#define MIN_COUNT_FOR_MEMSET_TO_BE_FAST 16
-
 ////////////////////////////////////////////////////////////////////////////
 
 /**
  *  Path.bounds is defined to be the bounds of all the control points.
  *  If we called bounds.join(r) we would skip r if r was empty, which breaks
  *  our promise. Hence we have a custom joiner that doesn't look at emptiness
  */
 static void joinNoEmptyChecks(SkRect* dst, const SkRect& src) {
     dst->fLeft = SkMinScalar(dst->fLeft, src.fLeft);
     dst->fTop = SkMinScalar(dst->fTop, src.fTop);
     dst->fRight = SkMaxScalar(dst->fRight, src.fRight);
     dst->fBottom = SkMaxScalar(dst->fBottom, src.fBottom);
 }
 
 static bool is_degenerate(const SkPath& path) {
     SkPath::Iter iter(path, false);
     SkPoint pts[4];
     return SkPath::kDone_Verb == iter.next(pts);
 }
 
-class SkAutoDisableOvalCheck {
-public:
-    SkAutoDisableOvalCheck(SkPath* path) : fPath(path) {
-        fSaved = fPath->fIsOval;
-    }
-
-    ~SkAutoDisableOvalCheck() {
-        fPath->fIsOval = fSaved;
-    }
-
-private:
-    SkPath* fPath;
-    bool    fSaved;
-};
-
-class SkAutoDisableDirectionCheck {
-public:
-    SkAutoDisableDirectionCheck(SkPath* path) : fPath(path) {
-        fSaved = static_cast<SkPath::Direction>(fPath->fDirection);
-    }
-
-    ~SkAutoDisableDirectionCheck() {
-        fPath->fDirection = fSaved;
-    }
-
-private:
-    SkPath*              fPath;
-    SkPath::Direction    fSaved;
-};
-
 /*  This guy's constructor/destructor bracket a path editing operation. It is
     used when we know the bounds of the amount we are going to add to the path
     (usually a new contour, but not required).
 
     It captures some state about the path up front (i.e. if it already has a
     cached bounds), and then if it can, it updates the cache bounds explicitly,
     avoiding the need to revisit all of the points in getBounds().
 
     It also notes if the path was originally degenerate, and if so, sets
     isConvex to true. Thus it can only be used if the contour being added is
-    convex (which is always true since we only allow the addition of rects).
+    convex.
  */
 class SkAutoPathBoundsUpdate {
 public:
     SkAutoPathBoundsUpdate(SkPath* path, const SkRect& r) : fRect(r) {
         this->init(path);
     }
 
     SkAutoPathBoundsUpdate(SkPath* path, SkScalar left, SkScalar top,
                            SkScalar right, SkScalar bottom) {
         fRect.set(left, top, right, bottom);
@@ skipping 37 matching lines @@
     - we insert a Move(0,0) if Line | Quad | Cubic is our first command
 
     The iterator does more cleanup, especially if forceClose == true
     1. If we encounter degenerate segments, remove them
     2. if we encounter Close, return a cons'd up Line() first (if the curr-pt != start-pt)
     3. if we encounter Move without a preceeding Close, and forceClose is true, goto #2
     4. if we encounter Line | Quad | Cubic after Close, cons up a Move
 */
 
 ////////////////////////////////////////////////////////////////////////////
-
-// flag to require a moveTo if we begin with something else, like lineTo etc.
-#define INITIAL_LASTMOVETOINDEX_VALUE   ~0
-
 SkPath::SkPath()
     : fPathRef(SkPathRef::CreateEmpty())
 #ifdef SK_BUILD_FOR_ANDROID
     , fGenerationID(0)
 #endif
 {
     this->resetFields();
 }
 
 void SkPath::resetFields() {
     //fPathRef is assumed to have been emptied by the caller.
-    fLastMoveToIndex = INITIAL_LASTMOVETOINDEX_VALUE;
     fFillType = kWinding_FillType;
-    fSegmentMask = 0;
-    fConvexity = kUnknown_Convexity;
-    fDirection = kUnknown_Direction;
-    fIsOval = false;
 #ifdef SK_BUILD_FOR_ANDROID
     GEN_ID_INC;
     // We don't touch fSourcePath.  It's used to track texture garbage collection, so we don't
     // want to muck with it if it's been set to something non-NULL.
 #endif
 }
 
 SkPath::SkPath(const SkPath& that)
     : fPathRef(SkRef(that.fPathRef.get())) {
     this->copyFields(that);
@@ skipping 18 matching lines @@
         GEN_ID_INC;  // Similar to swap, we can't just copy this or it could go back in time.
         fSourcePath = that.fSourcePath;
 #endif
     }
     SkDEBUGCODE(this->validate();)
     return *this;
 }
 
 void SkPath::copyFields(const SkPath& that) {
     //fPathRef is assumed to have been set by the caller.
-    fLastMoveToIndex = that.fLastMoveToIndex;
     fFillType        = that.fFillType;
-    fSegmentMask     = that.fSegmentMask;
-    fConvexity       = that.fConvexity;
-    fDirection       = that.fDirection;
-    fIsOval          = that.fIsOval;
 }
 
 bool operator==(const SkPath& a, const SkPath& b) {
-    // note: don't need to look at isConvex or bounds, since just comparing the
-    // raw data is sufficient.
-
-    // We explicitly check fSegmentMask as a quick-reject. We could skip it,
-    // since it is only a cache of info in the fVerbs, but its a fast way to
-    // notice a difference
-
     return &a == &b ||
-        (a.fFillType == b.fFillType && a.fSegmentMask == b.fSegmentMask &&
-         *a.fPathRef.get() == *b.fPathRef.get());
+        (a.fFillType == b.fFillType && *a.fPathRef.get() == *b.fPathRef.get());
 }
 
 void SkPath::swap(SkPath& that) {
     SkASSERT(&that != NULL);
 
     if (this != &that) {
         fPathRef.swap(&that.fPathRef);
-        SkTSwap<int>(fLastMoveToIndex, that.fLastMoveToIndex);
         SkTSwap<uint8_t>(fFillType, that.fFillType);
-        SkTSwap<uint8_t>(fSegmentMask, that.fSegmentMask);
-        SkTSwap<uint8_t>(fConvexity, that.fConvexity);
-        SkTSwap<uint8_t>(fDirection, that.fDirection);
-        SkTSwap<SkBool8>(fIsOval, that.fIsOval);
 #ifdef SK_BUILD_FOR_ANDROID
         // It doesn't really make sense to swap the generation IDs here, because they might go
         // backwards.  To be safe we increment both to mark them both as changed.
         GEN_ID_INC;
         GEN_ID_PTR_INC(&that);
         SkTSwap<const SkPath*>(fSourcePath, that.fSourcePath);
 #endif
     }
 }
 
@@ skipping 159 matching lines @@
   Single points on the rectangle side.
 
 The direction takes advantage of the corners found since opposite sides
 must travel in opposite directions.
 
 FIXME: Allow colinear quads and cubics to be treated like lines.
 FIXME: If the API passes fill-only, return true if the filled stroke
        is a rectangle, though the caller failed to close the path.
  */
 bool SkPath::isRectContour(bool allowPartial, int* currVerb, const SkPoint** ptsPtr,
-        bool* isClosed, Direction* direction) const {
+                           bool* isClosed, Direction* direction) const {
     int corners = 0;
     SkPoint first, last;
     const SkPoint* pts = *ptsPtr;
     const SkPoint* savePts = NULL;
     first.set(0, 0);
     last.set(0, 0);
     int firstDirection = 0;
     int lastDirection = 0;
     int nextDirection = 0;
     bool closedOrMoved = false;
@@ skipping 199 matching lines @@
     return false;
 }
 
 void SkPath::setLastPt(SkScalar x, SkScalar y) {
     SkDEBUGCODE(this->validate();)
 
     int count = fPathRef->countPoints();
     if (count == 0) {
         this->moveTo(x, y);
     } else {
-        fIsOval = false;
+        fPathRef->setIsOval(false);
         SkPathRef::Editor ed(&fPathRef);
         ed.atPoint(count-1)->set(x, y);
         GEN_ID_INC;
     }
 }
 
 void SkPath::setConvexity(Convexity c) {
-    if (fConvexity != c) {
-        fConvexity = c;
+    if (fPathRef->getConvexity() != static_cast<SkPathRef::Convexity>(c)) {
+        fPathRef->setConvexity(static_cast<SkPathRef::Convexity>(c));
         GEN_ID_INC;
     }
 }
 
 //////////////////////////////////////////////////////////////////////////////
 //  Construction methods
 
 #define DIRTY_AFTER_EDIT                 \
     do {                                 \
         fConvexity = kUnknown_Convexity; \
         fDirection = kUnknown_Direction; \
         fIsOval = false;                 \
     } while (0)
 
 void SkPath::incReserve(U16CPU inc) {
     SkDEBUGCODE(this->validate();)
     SkPathRef::Editor(&fPathRef, inc, inc);
     SkDEBUGCODE(this->validate();)
 }
 
 void SkPath::moveTo(SkScalar x, SkScalar y) {
     SkDEBUGCODE(this->validate();)
 
     SkPathRef::Editor ed(&fPathRef);
 
-    // remember our index
-    fLastMoveToIndex = ed.pathRef()->countPoints();
-
-    ed.growForVerb(kMove_Verb)->set(x, y);
+    ed.growForVerb(SkPathRef::kMove_Verb)->set(x, y);
 
     GEN_ID_INC;
 }
 
 void SkPath::rMoveTo(SkScalar x, SkScalar y) {
     SkPoint pt;
     this->getLastPt(&pt);
     this->moveTo(pt.fX + x, pt.fY + y);
 }
 
-void SkPath::injectMoveToIfNeeded() {
-    if (fLastMoveToIndex < 0) {
-        SkScalar x, y;
-        if (fPathRef->countVerbs() == 0) {
-            x = y = 0;
-        } else {
-            const SkPoint& pt = fPathRef->atPoint(~fLastMoveToIndex);
-            x = pt.fX;
-            y = pt.fY;
-        }
-        this->moveTo(x, y);
-    }
-}
-
 void SkPath::lineTo(SkScalar x, SkScalar y) {
     SkDEBUGCODE(this->validate();)
 
-    this->injectMoveToIfNeeded();
-
     SkPathRef::Editor ed(&fPathRef);
-    ed.growForVerb(kLine_Verb)->set(x, y);
-    fSegmentMask |= kLine_SegmentMask;
+    ed.growForVerb(SkPathRef::kLine_Verb)->set(x, y);
 
     GEN_ID_INC;
-    DIRTY_AFTER_EDIT;
 }
 
 void SkPath::rLineTo(SkScalar x, SkScalar y) {
-    this->injectMoveToIfNeeded();  // This can change the result of this->getLastPt().
-    SkPoint pt;
-    this->getLastPt(&pt);
-    this->lineTo(pt.fX + x, pt.fY + y);
+    SkDEBUGCODE(this->validate();)
+
+    SkPathRef::Editor ed(&fPathRef);
+    SkPoint* dst = ed.growForVerb(SkPathRef::kLine_Verb);
+
+    // growForVerb can change the result of this->getPoint().
+    SkASSERT(this->countPoints() >= 2);
+    SkPoint pt = this->getPoint(this->countPoints() - 2);
+
+    dst->set(pt.fX + x, pt.fY + y);
+    GEN_ID_INC;
 }
 
 void SkPath::quadTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2) {
     SkDEBUGCODE(this->validate();)
 
-    this->injectMoveToIfNeeded();
-
     SkPathRef::Editor ed(&fPathRef);
-    SkPoint* pts = ed.growForVerb(kQuad_Verb);
+    SkPoint* pts = ed.growForVerb(SkPathRef::kQuad_Verb);
     pts[0].set(x1, y1);
     pts[1].set(x2, y2);
-    fSegmentMask |= kQuad_SegmentMask;
 
     GEN_ID_INC;
-    DIRTY_AFTER_EDIT;
 }
 
 void SkPath::rQuadTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2) {
-    this->injectMoveToIfNeeded();  // This can change the result of this->getLastPt().
-    SkPoint pt;
-    this->getLastPt(&pt);
-    this->quadTo(pt.fX + x1, pt.fY + y1, pt.fX + x2, pt.fY + y2);
+    SkDEBUGCODE(this->validate();)
+
+    SkPathRef::Editor ed(&fPathRef);
+    SkPoint* pts = ed.growForVerb(SkPathRef::kQuad_Verb);
+
+    // growForVerb can change the result of this->getPoint().
+    SkASSERT(this->countPoints() >= 3);
+    SkPoint pt = this->getPoint(this->countPoints() - 3);
+
+    pts[0].set(pt.fX + x1, pt.fY + y1);
+    pts[1].set(pt.fX + x2, pt.fY + y2);
+
+    GEN_ID_INC;
 }
 
 void SkPath::conicTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2,
                      SkScalar w) {
     // check for <= 0 or NaN with this test
     if (!(w > 0)) {
         this->lineTo(x2, y2);
     } else if (!SkScalarIsFinite(w)) {
         this->lineTo(x1, y1);
         this->lineTo(x2, y2);
     } else if (SK_Scalar1 == w) {
         this->quadTo(x1, y1, x2, y2);
     } else {
         SkDEBUGCODE(this->validate();)
 
-        this->injectMoveToIfNeeded();
-
         SkPathRef::Editor ed(&fPathRef);
         SkPoint* pts = ed.growForConic(w);
         pts[0].set(x1, y1);
         pts[1].set(x2, y2);
-        fSegmentMask |= kConic_SegmentMask;
 
         GEN_ID_INC;
-        DIRTY_AFTER_EDIT;
     }
 }
 
 void SkPath::rConicTo(SkScalar dx1, SkScalar dy1, SkScalar dx2, SkScalar dy2,
                       SkScalar w) {
-    this->injectMoveToIfNeeded();  // This can change the result of this->getLastPt().
-    SkPoint pt;
-    this->getLastPt(&pt);
-    this->conicTo(pt.fX + dx1, pt.fY + dy1, pt.fX + dx2, pt.fY + dy2, w);
+    // check for <= 0 or NaN with this test
+    if (!(w > 0)) {
+        this->rLineTo(dx2, dy2);
+    } else if (!SkScalarIsFinite(w)) {
+        this->rLineTo(dx1, dy1);
+        this->rLineTo(dx2, dy2);
+    } else if (SK_Scalar1 == w) {
+        this->rQuadTo(dx1, dy1, dx2, dy2);
+    } else {
+        SkDEBUGCODE(this->validate();)
+
+        SkPathRef::Editor ed(&fPathRef);
+        SkPoint* pts = ed.growForConic(w);
+
+        // growForConic can change the result of this->getPoint().
+        SkASSERT(this->countPoints() >= 3);
+        SkPoint pt = this->getPoint(this->countPoints() - 3);
+
+        pts[0].set(pt.fX + dx1, pt.fY + dy1);
+        pts[1].set(pt.fX + dx2, pt.fY + dy2);
+
+        GEN_ID_INC;
+    }
 }
 
 void SkPath::cubicTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2,
                      SkScalar x3, SkScalar y3) {
     SkDEBUGCODE(this->validate();)
 
-    this->injectMoveToIfNeeded();
-
     SkPathRef::Editor ed(&fPathRef);
-    SkPoint* pts = ed.growForVerb(kCubic_Verb);
+    SkPoint* pts = ed.growForVerb(SkPathRef::kCubic_Verb);
     pts[0].set(x1, y1);
     pts[1].set(x2, y2);
     pts[2].set(x3, y3);
-    fSegmentMask |= kCubic_SegmentMask;
 
     GEN_ID_INC;
-    DIRTY_AFTER_EDIT;
 }
 
 void SkPath::rCubicTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2,
                       SkScalar x3, SkScalar y3) {
-    this->injectMoveToIfNeeded();  // This can change the result of this->getLastPt().
-    SkPoint pt;
-    this->getLastPt(&pt);
-    this->cubicTo(pt.fX + x1, pt.fY + y1, pt.fX + x2, pt.fY + y2,
-                  pt.fX + x3, pt.fY + y3);
+    SkDEBUGCODE(this->validate();)
+
+    SkPathRef::Editor ed(&fPathRef);
+    SkPoint* pts = ed.growForVerb(SkPathRef::kCubic_Verb);
+
+    // growForVerb can change the result of this->getPoint().
+    SkASSERT(this->countPoints() >= 4);
+    SkPoint pt = this->getPoint(this->countPoints() - 4);
+
+    pts[0].set(pt.fX + x1, pt.fY + y1);
+    pts[1].set(pt.fX + x2, pt.fY + y2);
+    pts[2].set(pt.fX + x3, pt.fY + y3);
+
+    GEN_ID_INC;
 }
 
 void SkPath::close() {
     SkDEBUGCODE(this->validate();)
 
     int count = fPathRef->countVerbs();
     if (count > 0) {
         switch (fPathRef->atVerb(count - 1)) {
             case kLine_Verb:
             case kQuad_Verb:
             case kConic_Verb:
             case kCubic_Verb:
             case kMove_Verb: {
                 SkPathRef::Editor ed(&fPathRef);
-                ed.growForVerb(kClose_Verb);
+                ed.growForVerb(SkPathRef::kClose_Verb);
                 GEN_ID_INC;
                 break;
             }
             case kClose_Verb:
                 // don't add a close if it's the first verb or a repeat
                 break;
             default:
                 SkDEBUGFAIL("unexpected verb");
                 break;
         }
     }
-
-    // signal that we need a moveTo to follow us (unless we're done)
-#if 0
-    if (fLastMoveToIndex >= 0) {
-        fLastMoveToIndex = ~fLastMoveToIndex;
-    }
-#else
-    fLastMoveToIndex ^= ~fLastMoveToIndex >> (8 * sizeof(fLastMoveToIndex) - 1);
-#endif
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static void assert_known_direction(int dir) {
     SkASSERT(SkPath::kCW_Direction == dir || SkPath::kCCW_Direction == dir);
 }
 
 void SkPath::addRect(const SkRect& rect, Direction dir) {
     this->addRect(rect.fLeft, rect.fTop, rect.fRight, rect.fBottom, dir);
 }
 
 void SkPath::addRect(SkScalar left, SkScalar top, SkScalar right,
                      SkScalar bottom, Direction dir) {
     assert_known_direction(dir);
-    fDirection = this->hasOnlyMoveTos() ? dir : kUnknown_Direction;
-    SkAutoDisableDirectionCheck addc(this);
+    Direction newDir = this->hasOnlyMoveTos() ? dir : kUnknown_Direction;
 
     SkAutoPathBoundsUpdate apbu(this, left, top, right, bottom);
 
     this->incReserve(5);
 
     this->moveTo(left, top);
     if (dir == kCCW_Direction) {
         this->lineTo(left, bottom);
         this->lineTo(right, bottom);
         this->lineTo(right, top);
     } else {
         this->lineTo(right, top);
         this->lineTo(right, bottom);
         this->lineTo(left, bottom);
     }
     this->close();
+
+    fPathRef->setDirection(static_cast<SkPathRef::Direction>(newDir));
 }
 
 void SkPath::addPoly(const SkPoint pts[], int count, bool close) {
     SkDEBUGCODE(this->validate();)
     if (count <= 0) {
         return;
     }
 
-    SkPathRef::Editor ed(&fPathRef);
-    fLastMoveToIndex = ed.pathRef()->countPoints();
-    uint8_t* vb;
-    SkPoint* p;
     // +close makes room for the extra kClose_Verb
-    ed.grow(count + close, count, &vb, &p);
+    SkPathRef::Editor ed(&fPathRef, count+close, count);
 
-    memcpy(p, pts, count * sizeof(SkPoint));
-    vb[~0] = kMove_Verb;
+    ed.growForVerb(SkPathRef::kMove_Verb)->set(pts[0].fX, pts[0].fY);
+
     if (count > 1) {
-        // cast to unsigned, so if MIN_COUNT_FOR_MEMSET_TO_BE_FAST is defined to
-        // be 0, the compiler will remove the test/branch entirely.
-        if ((unsigned)count >= MIN_COUNT_FOR_MEMSET_TO_BE_FAST) {
-            memset(vb - count, kLine_Verb, count - 1);
-        } else {
-            for (int i = 1; i < count; ++i) {
-                vb[~i] = kLine_Verb;
-            }
-        }
-        fSegmentMask |= kLine_SegmentMask;
+        SkPoint* p = ed.growForLines(count - 1);
+
+        memcpy(p, &pts[1], (count-1) * sizeof(SkPoint));
     }
+
     if (close) {
-        vb[~count] = kClose_Verb;
+        ed.growForVerb(SkPathRef::kClose_Verb);
     }
 
     GEN_ID_INC;
-    DIRTY_AFTER_EDIT;
     SkDEBUGCODE(this->validate();)
 }
 
 static void add_corner_arc(SkPath* path, const SkRect& rect,
                            SkScalar rx, SkScalar ry, int startAngle,
                            SkPath::Direction dir, bool forceMoveTo) {
     // These two asserts are not sufficient, since really we want to know
     // that the pair of radii (e.g. left and right, or top and bottom) sum
     // to <= dimension, but we don't have that data here, so we just have
     // these conservative asserts.
@@ skipping 75 matching lines @@
             *verbs == kCubic_Verb) {
             return false;
         }
         ++verbs;
     }
     return true;
 }
 
 #define CUBIC_ARC_FACTOR    ((SK_ScalarSqrt2 - SK_Scalar1) * 4 / 3)
 
-void SkPath::addRoundRect(const SkRect& rect, SkScalar rx, SkScalar ry,
-                          Direction dir) {
+void SkPath::addRoundRect(const SkRect& rect, SkScalar rx, SkScalar ry, Direction dir) {
     assert_known_direction(dir);
 
     if (rx < 0 || ry < 0) {
         SkErrorInternals::SetError( kInvalidArgument_SkError,
                                     "I got %f and %f as radii to SkPath::AddRoundRect, "
                                     "but negative radii are not allowed.",
                                     SkScalarToDouble(rx), SkScalarToDouble(ry) );
         return;
     }
 
     SkScalar    w = rect.width();
     SkScalar    halfW = SkScalarHalf(w);
     SkScalar    h = rect.height();
     SkScalar    halfH = SkScalarHalf(h);
 
     if (halfW <= 0 || halfH <= 0) {
         return;
     }
 
     bool skip_hori = rx >= halfW;
     bool skip_vert = ry >= halfH;
 
     if (skip_hori && skip_vert) {
         this->addOval(rect, dir);
         return;
     }
 
-    fDirection = this->hasOnlyMoveTos() ? dir : kUnknown_Direction;
+    Direction newDir = this->hasOnlyMoveTos() ? dir : kUnknown_Direction;
 
     SkAutoPathBoundsUpdate apbu(this, rect);
-    SkAutoDisableDirectionCheck(this);
 
     if (skip_hori) {
         rx = halfW;
     } else if (skip_vert) {
         ry = halfH;
     }
 
     SkScalar    sx = SkScalarMul(rx, CUBIC_ARC_FACTOR);
     SkScalar    sy = SkScalarMul(ry, CUBIC_ARC_FACTOR);
 
@@ skipping 44 matching lines @@
             this->lineTo(rect.fLeft, rect.fTop + ry);       // left
         }
         this->cubicTo(rect.fLeft, rect.fTop + ry - sy,
                       rect.fLeft + rx - sx, rect.fTop,
                       rect.fLeft + rx, rect.fTop);          // top-left
         if (!skip_hori) {
             this->lineTo(rect.fRight - rx, rect.fTop);      // top
         }
     }
     this->close();
+
+    fPathRef->setDirection(static_cast<SkPathRef::Direction>(newDir));
 }
 
 void SkPath::addOval(const SkRect& oval, Direction dir) {
     assert_known_direction(dir);
 
     /* If addOval() is called after previous moveTo(),
        this path is still marked as an oval. This is used to
        fit into WebKit's calling sequences.
        We can't simply check isEmpty() in this case, as additional
        moveTo() would mark the path non empty.
      */
-    fIsOval = hasOnlyMoveTos();
-    if (fIsOval) {
-        fDirection = dir;
-    } else {
-        fDirection = kUnknown_Direction;
-    }
-
-    SkAutoDisableOvalCheck adoc(this);
-    SkAutoDisableDirectionCheck addc(this);
+    bool isOval = this->hasOnlyMoveTos();
+    Direction newDir = isOval ? dir : kUnknown_Direction;
 
     SkAutoPathBoundsUpdate apbu(this, oval);
 
     SkScalar    cx = oval.centerX();
     SkScalar    cy = oval.centerY();
     SkScalar    rx = SkScalarHalf(oval.width());
     SkScalar    ry = SkScalarHalf(oval.height());
 
     SkScalar    sx = SkScalarMul(rx, SK_ScalarTanPIOver8);
     SkScalar    sy = SkScalarMul(ry, SK_ScalarTanPIOver8);
@@ skipping 26 matching lines @@
         this->quadTo(      R, cy + sy, cx + mx, cy + my);
         this->quadTo(cx + sx,       B, cx     ,       B);
         this->quadTo(cx - sx,       B, cx - mx, cy + my);
         this->quadTo(      L, cy + sy,       L, cy     );
         this->quadTo(      L, cy - sy, cx - mx, cy - my);
         this->quadTo(cx - sx,       T, cx     ,       T);
         this->quadTo(cx + sx,       T, cx + mx, cy - my);
         this->quadTo(      R, cy - sy,       R, cy     );
     }
     this->close();
-}
 
-bool SkPath::isOval(SkRect* rect) const {
-    if (fIsOval && rect) {
-        *rect = getBounds();
-    }
-
-    return fIsOval;
+    fPathRef->setIsOval(isOval);
+    fPathRef->setDirection(static_cast<SkPathRef::Direction>(newDir));
 }
 
 void SkPath::addCircle(SkScalar x, SkScalar y, SkScalar r, Direction dir) {
     if (r > 0) {
         SkRect  rect;
         rect.set(x - r, y - r, x + r, y + r);
         this->addOval(rect, dir);
     }
 }
 
@@ skipping 177 matching lines @@
 void SkPath::addPath(const SkPath& path, SkScalar dx, SkScalar dy) {
     SkMatrix matrix;
 
     matrix.setTranslate(dx, dy);
     this->addPath(path, matrix);
 }
 
 void SkPath::addPath(const SkPath& path, const SkMatrix& matrix) {
     SkPathRef::Editor(&fPathRef, path.countVerbs(), path.countPoints());
 
-    fIsOval = false;
+    fPathRef->setIsOval(false);
 
     RawIter iter(path);
     SkPoint pts[4];
     Verb    verb;
 
     SkMatrix::MapPtsProc proc = matrix.getMapPtsProc();
 
     while ((verb = iter.next(pts)) != kDone_Verb) {
         switch (verb) {
             case kMove_Verb:
@@ skipping 45 matching lines @@
 // ignore the initial moveto, and stop when the 1st contour ends
 void SkPath::pathTo(const SkPath& path) {
     int i, vcount = path.fPathRef->countVerbs();
     // exit early if the path is empty, or just has a moveTo.
     if (vcount < 2) {
         return;
     }
 
     SkPathRef::Editor(&fPathRef, vcount, path.countPoints());
 
-    fIsOval = false;
+    fPathRef->setIsOval(false);
 
     const uint8_t* verbs = path.fPathRef->verbs();
     // skip the initial moveTo
     const SkPoint*  pts = path.fPathRef->points() + 1;
     const SkScalar* conicWeight = path.fPathRef->conicWeights();
 
     SkASSERT(verbs[~0] == kMove_Verb);
     for (i = 1; i < vcount; i++) {
         switch (verbs[~i]) {
             case kLine_Verb:
@@ skipping 18 matching lines @@
 // ignore the last point of the 1st contour
 void SkPath::reversePathTo(const SkPath& path) {
     int i, vcount = path.fPathRef->countVerbs();
     // exit early if the path is empty, or just has a moveTo.
     if (vcount < 2) {
         return;
     }
 
     SkPathRef::Editor(&fPathRef, vcount, path.countPoints());
 
-    fIsOval = false;
+    fPathRef->setIsOval(false);
 
     const uint8_t*  verbs = path.fPathRef->verbs();
     const SkPoint*  pts = path.fPathRef->points();
     const SkScalar* conicWeights = path.fPathRef->conicWeights();
 
     SkASSERT(verbs[~0] == kMove_Verb);
     for (i = 1; i < vcount; ++i) {
         unsigned v = verbs[~i];
         int n = pts_in_verb(v);
         if (n == 0) {
@@ skipping 20 matching lines @@
                 break;
             default:
                 SkDEBUGFAIL("bad verb");
                 break;
         }
         pts -= pts_in_verb(verbs[~i]);
     }
 }
 
 void SkPath::reverseAddPath(const SkPath& src) {
-    SkPathRef::Editor ed(&fPathRef, src.fPathRef->countPoints(), src.fPathRef->countVerbs());
+    SkPathRef::Editor(&fPathRef, src.fPathRef->countPoints(), src.fPathRef->countVerbs());
 
     const SkPoint* pts = src.fPathRef->pointsEnd();
     // we will iterator through src's verbs backwards
     const uint8_t* verbs = src.fPathRef->verbsMemBegin(); // points at the last verb
     const uint8_t* verbsEnd = src.fPathRef->verbs(); // points just past the first verb
     const SkScalar* conicWeights = src.fPathRef->conicWeightsEnd();
 
-    fIsOval = false;
+    fPathRef->setIsOval(false);
 
     bool needMove = true;
     bool needClose = false;
     while (verbs < verbsEnd) {
         uint8_t v = *(verbs++);
         int n = pts_in_verb(v);
 
         if (needMove) {
             --pts;
             this->moveTo(pts->fX, pts->fY);
@@ skipping 104 matching lines @@
                     break;
                 default:
                     SkDEBUGFAIL("unknown verb");
                     break;
             }
         }
 
         dst->swap(tmp);
         SkPathRef::Editor ed(&dst->fPathRef);
         matrix.mapPoints(ed.points(), ed.pathRef()->countPoints());
-        dst->fDirection = kUnknown_Direction;
+        dst->setDirection(kUnknown_Direction);
     } else {
         SkPathRef::CreateTransformedCopy(&dst->fPathRef, *fPathRef.get(), matrix);
 
         if (this != dst) {
             dst->fFillType = fFillType;
-            dst->fSegmentMask = fSegmentMask;
-            dst->fConvexity = fConvexity;
         }
 
 #ifdef SK_BUILD_FOR_ANDROID
         if (!matrix.isIdentity() && !dst->hasComputedBounds()) {
             GEN_ID_PTR_INC(dst);
         }
 #endif
 
-        if (kUnknown_Direction == fDirection) {
-            dst->fDirection = kUnknown_Direction;
-        } else {
-            SkScalar det2x2 =
-                SkScalarMul(matrix.get(SkMatrix::kMScaleX), matrix.get(SkMatrix::kMScaleY)) -
-                SkScalarMul(matrix.get(SkMatrix::kMSkewX), matrix.get(SkMatrix::kMSkewY));
-            if (det2x2 < 0) {
-                dst->fDirection = SkPath::OppositeDirection(static_cast<Direction>(fDirection));
-            } else if (det2x2 > 0) {
-                dst->fDirection = fDirection;
-            } else {
-                dst->fDirection = kUnknown_Direction;
-            }
-        }
-
-        // It's an oval only if it stays a rect.
-        dst->fIsOval = fIsOval && matrix.rectStaysRect();
-
         SkDEBUGCODE(dst->validate();)
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 
 enum SegmentState {
     kEmptyContour_SegmentState,   // The current contour is empty. We may be
                                   // starting processing or we may have just
@@ skipping 11 matching lines @@
     fForceClose = fCloseLine = false;
     fSegmentState = kEmptyContour_SegmentState;
 #endif
     // need to init enough to make next() harmlessly return kDone_Verb
     fVerbs = NULL;
     fVerbStop = NULL;
     fNeedClose = false;
 }
 
 SkPath::Iter::Iter(const SkPath& path, bool forceClose) {
-    this->setPath(path, forceClose);
+    this->setPathRef(path.fPathRef.get(), forceClose);
+}
+
+SkPath::Iter::Iter(const SkPathRef* pathRef, bool forceClose) {
+    this->setPathRef(pathRef, forceClose);
 }
 
 void SkPath::Iter::setPath(const SkPath& path, bool forceClose) {
-    fPts = path.fPathRef->points();
-    fVerbs = path.fPathRef->verbs();
-    fVerbStop = path.fPathRef->verbsMemBegin();
-    fConicWeights = path.fPathRef->conicWeights() - 1; // begin one behind
+    this->setPathRef(path.fPathRef.get(), forceClose);
+}
+
+void SkPath::Iter::setPathRef(const SkPathRef* pathRef, bool forceClose) {
+    fPts = pathRef->points();
+    fVerbs = pathRef->verbs();
+    fVerbStop = pathRef->verbsMemBegin();
+    fConicWeights = pathRef->conicWeights() - 1; // begin one behind
     fLastPt.fX = fLastPt.fY = 0;
     fMoveTo.fX = fMoveTo.fY = 0;
     fForceClose = SkToU8(forceClose);
     fNeedClose = false;
     fSegmentState = kEmptyContour_SegmentState;
 }
 
 bool SkPath::Iter::isClosedContour() const {
     if (fVerbs == NULL || fVerbs == fVerbStop) {
         return false;
@@ skipping 293 matching lines @@
 uint32_t SkPath::writeToMemory(void* storage) const {
     SkDEBUGCODE(this->validate();)
 
     if (NULL == storage) {
         const int byteCount = sizeof(int32_t) + fPathRef->writeSize();
         return SkAlign4(byteCount);
     }
 
     SkWBuffer   buffer(storage);
 
-    int32_t packed = ((fIsOval & 1) << kIsOval_SerializationShift) |
-                     (fConvexity << kConvexity_SerializationShift) |
-                     (fFillType << kFillType_SerializationShift) |
-                     (fSegmentMask << kSegmentMask_SerializationShift) |
-                     (fDirection << kDirection_SerializationShift)
+    int32_t packed = (fFillType << kFillType_SerializationShift)
 #ifndef DELETE_THIS_CODE_WHEN_SKPS_ARE_REBUILT_AT_V14_AND_ALL_OTHER_INSTANCES_TOO
                      | (0x1 << kNewFormat_SerializationShift);
 #endif
 
     buffer.write32(packed);
 
     fPathRef->writeToBuffer(&buffer);
 
     buffer.padToAlign4();
     return SkToU32(buffer.pos());
 }
 
 uint32_t SkPath::readFromMemory(const void* storage) {
     SkRBuffer   buffer(storage);
 
     uint32_t packed = buffer.readS32();
-    fIsOval = (packed >> kIsOval_SerializationShift) & 1;
-    fConvexity = (packed >> kConvexity_SerializationShift) & 0xFF;
     fFillType = (packed >> kFillType_SerializationShift) & 0xFF;
-    fSegmentMask = (packed >> kSegmentMask_SerializationShift) & 0xF;
-    fDirection = (packed >> kDirection_SerializationShift) & 0x3;
 #ifndef DELETE_THIS_CODE_WHEN_SKPS_ARE_REBUILT_AT_V14_AND_ALL_OTHER_INSTANCES_TOO
     bool newFormat = (packed >> kNewFormat_SerializationShift) & 1;
 #endif
 
     fPathRef.reset(SkPathRef::CreateFromBuffer(&buffer
 #ifndef DELETE_THIS_CODE_WHEN_SKPS_ARE_REBUILT_AT_V14_AND_ALL_OTHER_INSTANCES_TOO
         , newFormat, packed)
 #endif
         );
 
@@ skipping 79 matching lines @@
 }
 
 void SkPath::dump() const {
     this->dump(false);
 }
 
 #ifdef SK_DEBUG
 void SkPath::validate() const {
     SkASSERT(this != NULL);
     SkASSERT((fFillType & ~3) == 0);
-
-#ifdef SK_DEBUG_PATH
-    if (!fBoundsIsDirty) {
-        SkRect bounds;
-
-        bool isFinite = compute_pt_bounds(&bounds, *fPathRef.get());
-        SkASSERT(SkToBool(fIsFinite) == isFinite);
-
-        if (fPathRef->countPoints() <= 1) {
-            // if we're empty, fBounds may be empty but translated, so we can't
-            // necessarily compare to bounds directly
-            // try path.addOval(2, 2, 2, 2) which is empty, but the bounds will
-            // be [2, 2, 2, 2]
-            SkASSERT(bounds.isEmpty());
-            SkASSERT(fBounds.isEmpty());
-        } else {
-            if (bounds.isEmpty()) {
-                SkASSERT(fBounds.isEmpty());
-            } else {
-                if (!fBounds.isEmpty()) {
-                    SkASSERT(fBounds.contains(bounds));
-                }
-            }
-        }
-    }
-
-    uint32_t mask = 0;
-    const uint8_t* verbs = const_cast<const SkPathRef*>(fPathRef.get())->verbs();
-    for (int i = 0; i < fPathRef->countVerbs(); i++) {
-        switch (verbs[~i]) {
-            case kLine_Verb:
-                mask |= kLine_SegmentMask;
-                break;
-            case kQuad_Verb:
-                mask |= kQuad_SegmentMask;
-                break;
-            case kConic_Verb:
-                mask |= kConic_SegmentMask;
-                break;
-            case kCubic_Verb:
-                mask |= kCubic_SegmentMask;
-            case kMove_Verb:  // these verbs aren't included in the segment mask.
-            case kClose_Verb:
-                break;
-            case kDone_Verb:
-                SkDEBUGFAIL("Done verb shouldn't be recorded.");
-                break;
-            default:
-                SkDEBUGFAIL("Unknown Verb");
-                break;
-        }
-    }
-    SkASSERT(mask == fSegmentMask);
-#endif // SK_DEBUG_PATH
 }
 #endif // SK_DEBUG
 
 ///////////////////////////////////////////////////////////////////////////////
 
-static int sign(SkScalar x) { return x < 0; }
-#define kValueNeverReturnedBySign   2
-
-static int CrossProductSign(const SkVector& a, const SkVector& b) {
-    return SkScalarSignAsInt(SkPoint::CrossProduct(a, b));
-}
-
-// only valid for a single contour
-struct Convexicator {
-    Convexicator()
-    : fPtCount(0)
-    , fConvexity(SkPath::kConvex_Convexity)
-    , fDirection(SkPath::kUnknown_Direction) {
-        fSign = 0;
-        // warnings
-        fCurrPt.set(0, 0);
-        fVec0.set(0, 0);
-        fVec1.set(0, 0);
-        fFirstVec.set(0, 0);
-
-        fDx = fDy = 0;
-        fSx = fSy = kValueNeverReturnedBySign;
-    }
-
-    SkPath::Convexity getConvexity() const { return fConvexity; }
-
-    /** The direction returned is only valid if the path is determined convex */
-    SkPath::Direction getDirection() const { return fDirection; }
-
-    void addPt(const SkPoint& pt) {
-        if (SkPath::kConcave_Convexity == fConvexity) {
-            return;
-        }
-
-        if (0 == fPtCount) {
-            fCurrPt = pt;
-            ++fPtCount;
-        } else {
-            SkVector vec = pt - fCurrPt;
-            if (vec.fX || vec.fY) {
-                fCurrPt = pt;
-                if (++fPtCount == 2) {
-                    fFirstVec = fVec1 = vec;
-                } else {
-                    SkASSERT(fPtCount > 2);
-                    this->addVec(vec);
-                }
-
-                int sx = sign(vec.fX);
-                int sy = sign(vec.fY);
-                fDx += (sx != fSx);
-                fDy += (sy != fSy);
-                fSx = sx;
-                fSy = sy;
-
-                if (fDx > 3 || fDy > 3) {
-                    fConvexity = SkPath::kConcave_Convexity;
-                }
-            }
-        }
-    }
-
-    void close() {
-        if (fPtCount > 2) {
-            this->addVec(fFirstVec);
-        }
-    }
-
-private:
-    void addVec(const SkVector& vec) {
-        SkASSERT(vec.fX || vec.fY);
-        fVec0 = fVec1;
-        fVec1 = vec;
-        int sign = CrossProductSign(fVec0, fVec1);
-        if (0 == fSign) {
-            fSign = sign;
-            if (1 == sign) {
-                fDirection = SkPath::kCW_Direction;
-            } else if (-1 == sign) {
-                fDirection = SkPath::kCCW_Direction;
-            }
-        } else if (sign) {
-            if (fSign != sign) {
-                fConvexity = SkPath::kConcave_Convexity;
-                fDirection = SkPath::kUnknown_Direction;
-            }
-        }
-    }
-
-    SkPoint             fCurrPt;
-    SkVector            fVec0, fVec1, fFirstVec;
-    int                 fPtCount;   // non-degenerate points
-    int                 fSign;
-    SkPath::Convexity   fConvexity;
-    SkPath::Direction   fDirection;
-    int                 fDx, fDy, fSx, fSy;
-};
-
-SkPath::Convexity SkPath::internalGetConvexity() const {
-    SkASSERT(kUnknown_Convexity == fConvexity);
-    SkPoint         pts[4];
-    SkPath::Verb    verb;
-    SkPath::Iter    iter(*this, true);
-
-    int             contourCount = 0;
-    int             count;
-    Convexicator    state;
-
-    while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
-        switch (verb) {
-            case kMove_Verb:
-                if (++contourCount > 1) {
-                    fConvexity = kConcave_Convexity;
-                    return kConcave_Convexity;
-                }
-                pts[1] = pts[0];
-                count = 1;
-                break;
-            case kLine_Verb: count = 1; break;
-            case kQuad_Verb: count = 2; break;
-            case kConic_Verb: count = 2; break;
-            case kCubic_Verb: count = 3; break;
-            case kClose_Verb:
-                state.close();
-                count = 0;
-                break;
-            default:
-                SkDEBUGFAIL("bad verb");
-                fConvexity = kConcave_Convexity;
-                return kConcave_Convexity;
-        }
-
-        for (int i = 1; i <= count; i++) {
-            state.addPt(pts[i]);
-        }
-        // early exit
-        if (kConcave_Convexity == state.getConvexity()) {
-            fConvexity = kConcave_Convexity;
-            return kConcave_Convexity;
-        }
-    }
-    fConvexity = state.getConvexity();
-    if (kConvex_Convexity == fConvexity && kUnknown_Direction == fDirection) {
-        fDirection = state.getDirection();
-    }
-    return static_cast<Convexity>(fConvexity);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-class ContourIter {
-public:
-    ContourIter(const SkPathRef& pathRef);
-
-    bool done() const { return fDone; }
-    // if !done() then these may be called
-    int count() const { return fCurrPtCount; }
-    const SkPoint* pts() const { return fCurrPt; }
-    void next();
-
-private:
-    int fCurrPtCount;
-    const SkPoint* fCurrPt;
-    const uint8_t* fCurrVerb;
-    const uint8_t* fStopVerbs;
-    const SkScalar* fCurrConicWeight;
-    bool fDone;
-    SkDEBUGCODE(int fContourCounter;)
-};
-
-ContourIter::ContourIter(const SkPathRef& pathRef) {
-    fStopVerbs = pathRef.verbsMemBegin();
-    fDone = false;
-    fCurrPt = pathRef.points();
-    fCurrVerb = pathRef.verbs();
-    fCurrConicWeight = pathRef.conicWeights();
-    fCurrPtCount = 0;
-    SkDEBUGCODE(fContourCounter = 0;)
-    this->next();
-}
-
-void ContourIter::next() {
-    if (fCurrVerb <= fStopVerbs) {
-        fDone = true;
-    }
-    if (fDone) {
-        return;
-    }
-
-    // skip pts of prev contour
-    fCurrPt += fCurrPtCount;
-
-    SkASSERT(SkPath::kMove_Verb == fCurrVerb[~0]);
-    int ptCount = 1;    // moveTo
-    const uint8_t* verbs = fCurrVerb;
-
-    for (--verbs; verbs > fStopVerbs; --verbs) {
-        switch (verbs[~0]) {
-            case SkPath::kMove_Verb:
-                goto CONTOUR_END;
-            case SkPath::kLine_Verb:
-                ptCount += 1;
-                break;
-            case SkPath::kConic_Verb:
-                fCurrConicWeight += 1;
-                // fall-through
-            case SkPath::kQuad_Verb:
-                ptCount += 2;
-                break;
-            case SkPath::kCubic_Verb:
-                ptCount += 3;
-                break;
-            case SkPath::kClose_Verb:
-                break;
-            default:
-                SkDEBUGFAIL("unexpected verb");
-                break;
-        }
-    }
-CONTOUR_END:
-    fCurrPtCount = ptCount;
-    fCurrVerb = verbs;
-    SkDEBUGCODE(++fContourCounter;)
-}
-
-// returns cross product of (p1 - p0) and (p2 - p0)
-static SkScalar cross_prod(const SkPoint& p0, const SkPoint& p1, const SkPoint& p2) {
-    SkScalar cross = SkPoint::CrossProduct(p1 - p0, p2 - p0);
-    // We may get 0 when the above subtracts underflow. We expect this to be
-    // very rare and lazily promote to double.
-    if (0 == cross) {
-        double p0x = SkScalarToDouble(p0.fX);
-        double p0y = SkScalarToDouble(p0.fY);
-
-        double p1x = SkScalarToDouble(p1.fX);
-        double p1y = SkScalarToDouble(p1.fY);
-
-        double p2x = SkScalarToDouble(p2.fX);
-        double p2y = SkScalarToDouble(p2.fY);
-
-        cross = SkDoubleToScalar((p1x - p0x) * (p2y - p0y) -
-                                 (p1y - p0y) * (p2x - p0x));
-
-    }
-    return cross;
-}
-
-// Returns the first pt with the maximum Y coordinate
-static int find_max_y(const SkPoint pts[], int count) {
-    SkASSERT(count > 0);
-    SkScalar max = pts[0].fY;
-    int firstIndex = 0;
-    for (int i = 1; i < count; ++i) {
-        SkScalar y = pts[i].fY;
-        if (y > max) {
-            max = y;
-            firstIndex = i;
-        }
-    }
-    return firstIndex;
-}
-
-static int find_diff_pt(const SkPoint pts[], int index, int n, int inc) {
-    int i = index;
-    for (;;) {
-        i = (i + inc) % n;
-        if (i == index) {   // we wrapped around, so abort
-            break;
-        }
-        if (pts[index] != pts[i]) { // found a different point, success!
-            break;
-        }
-    }
-    return i;
-}
-
-/**
- *  Starting at index, and moving forward (incrementing), find the xmin and
- *  xmax of the contiguous points that have the same Y.
- */
-static int find_min_max_x_at_y(const SkPoint pts[], int index, int n,
-                               int* maxIndexPtr) {
-    const SkScalar y = pts[index].fY;
-    SkScalar min = pts[index].fX;
-    SkScalar max = min;
-    int minIndex = index;
-    int maxIndex = index;
-    for (int i = index + 1; i < n; ++i) {
-        if (pts[i].fY != y) {
-            break;
-        }
-        SkScalar x = pts[i].fX;
-        if (x < min) {
-            min = x;
-            minIndex = i;
-        } else if (x > max) {
-            max = x;
-            maxIndex = i;
-        }
-    }
-    *maxIndexPtr = maxIndex;
-    return minIndex;
-}
-
-static void crossToDir(SkScalar cross, SkPath::Direction* dir) {
-    if (dir) {
-        *dir = cross > 0 ? SkPath::kCW_Direction : SkPath::kCCW_Direction;
-    }
-}
-
-#if 0
-#include "SkString.h"
-#include "../utils/SkParsePath.h"
-static void dumpPath(const SkPath& path) {
-    SkString str;
-    SkParsePath::ToSVGString(path, &str);
-    SkDebugf("%s\n", str.c_str());
-}
-#endif
-
-namespace {
-// for use with convex_dir_test
-double mul(double a, double b) { return a * b; }
-SkScalar mul(SkScalar a, SkScalar b) { return SkScalarMul(a, b); }
-double toDouble(SkScalar a) { return SkScalarToDouble(a); }
-SkScalar toScalar(SkScalar a) { return a; }
-
-// determines the winding direction of a convex polygon with the precision
-// of T. CAST_SCALAR casts an SkScalar to T.
-template <typename T, T (CAST_SCALAR)(SkScalar)>
-bool convex_dir_test(int n, const SkPoint pts[], SkPath::Direction* dir) {
-    // we find the first three points that form a non-degenerate
-    // triangle. If there are no such points then the path is
-    // degenerate. The first is always point 0. Now we find the second
-    // point.
-    int i = 0;
-    enum { kX = 0, kY = 1 };
-    T v0[2];
-    while (1) {
-        v0[kX] = CAST_SCALAR(pts[i].fX) - CAST_SCALAR(pts[0].fX);
-        v0[kY] = CAST_SCALAR(pts[i].fY) - CAST_SCALAR(pts[0].fY);
-        if (v0[kX] || v0[kY]) {
-            break;
-        }
-        if (++i == n - 1) {
-            return false;
-        }
-    }
-    // now find a third point that is not colinear with the first two
-    // points and check the orientation of the triangle (which will be
-    // the same as the orientation of the path).
-    for (++i; i < n; ++i) {
-        T v1[2];
-        v1[kX] = CAST_SCALAR(pts[i].fX) - CAST_SCALAR(pts[0].fX);
-        v1[kY] = CAST_SCALAR(pts[i].fY) - CAST_SCALAR(pts[0].fY);
-        T cross = mul(v0[kX], v1[kY]) - mul(v0[kY], v1[kX]);
-        if (0 != cross) {
-            *dir = cross > 0 ? SkPath::kCW_Direction : SkPath::kCCW_Direction;
-            return true;
-        }
-    }
-    return false;
-}
-}
-
-/*
- *  We loop through all contours, and keep the computed cross-product of the
- *  contour that contained the global y-max. If we just look at the first
- *  contour, we may find one that is wound the opposite way (correctly) since
- *  it is the interior of a hole (e.g. 'o'). Thus we must find the contour
- *  that is outer most (or at least has the global y-max) before we can consider
- *  its cross product.
- */
-bool SkPath::cheapComputeDirection(Direction* dir) const {
-//    dumpPath(*this);
-    // don't want to pay the cost for computing this if it
-    // is unknown, so we don't call isConvex()
-
-    if (kUnknown_Direction != fDirection) {
-        *dir = static_cast<Direction>(fDirection);
-        return true;
-    }
-    const Convexity conv = this->getConvexityOrUnknown();
-
-    ContourIter iter(*fPathRef.get());
-
-    // initialize with our logical y-min
-    SkScalar ymax = this->getBounds().fTop;
-    SkScalar ymaxCross = 0;
-
-    for (; !iter.done(); iter.next()) {
-        int n = iter.count();
-        if (n < 3) {
-            continue;
-        }
-
-        const SkPoint* pts = iter.pts();
-        SkScalar cross = 0;
-        if (kConvex_Convexity == conv) {
-            // We try first at scalar precision, and then again at double
-            // precision. This is because the vectors computed between distant
-            // points may lose too much precision.
-            if (convex_dir_test<SkScalar, toScalar>(n, pts, dir)) {
-                fDirection = *dir;
-                return true;
-            }
-            if (convex_dir_test<double, toDouble>(n, pts, dir)) {
-                fDirection = *dir;
-                return true;
-            } else {
-                return false;
-            }
-        } else {
-            int index = find_max_y(pts, n);
-            if (pts[index].fY < ymax) {
-                continue;
-            }
-
-            // If there is more than 1 distinct point at the y-max, we take the
-            // x-min and x-max of them and just subtract to compute the dir.
-            if (pts[(index + 1) % n].fY == pts[index].fY) {
-                int maxIndex;
-                int minIndex = find_min_max_x_at_y(pts, index, n, &maxIndex);
-                if (minIndex == maxIndex) {
-                    goto TRY_CROSSPROD;
-                }
-                SkASSERT(pts[minIndex].fY == pts[index].fY);
-                SkASSERT(pts[maxIndex].fY == pts[index].fY);
-                SkASSERT(pts[minIndex].fX <= pts[maxIndex].fX);
-                // we just subtract the indices, and let that auto-convert to
-                // SkScalar, since we just want - or + to signal the direction.
-                cross = minIndex - maxIndex;
-            } else {
-                TRY_CROSSPROD:
-                // Find a next and prev index to use for the cross-product test,
-                // but we try to find pts that form non-zero vectors from pts[index]
-                //
-                // Its possible that we can't find two non-degenerate vectors, so
-                // we have to guard our search (e.g. all the pts could be in the
-                // same place).
-
-                // we pass n - 1 instead of -1 so we don't foul up % operator by
-                // passing it a negative LH argument.
-                int prev = find_diff_pt(pts, index, n, n - 1);
-                if (prev == index) {
-                    // completely degenerate, skip to next contour
-                    continue;
-                }
-                int next = find_diff_pt(pts, index, n, 1);
-                SkASSERT(next != index);
-                cross = cross_prod(pts[prev], pts[index], pts[next]);
-                // if we get a zero and the points are horizontal, then we look at the spread in
-                // x-direction. We really should continue to walk away from the degeneracy until
-                // there is a divergence.
-                if (0 == cross && pts[prev].fY == pts[index].fY && pts[next].fY == pts[index].fY) {
-                    // construct the subtract so we get the correct Direction below
-                    cross = pts[index].fX - pts[next].fX;
-                }
-            }
-
-            if (cross) {
-                // record our best guess so far
-                ymax = pts[index].fY;
-                ymaxCross = cross;
-            }
-        }
-    }
-    if (ymaxCross) {
-        crossToDir(ymaxCross, dir);
-        fDirection = *dir;
-        return true;
-    } else {
-        return false;
-    }
-}
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static SkScalar eval_cubic_coeff(SkScalar A, SkScalar B, SkScalar C,
                                  SkScalar D, SkScalar t) {
     return SkScalarMulAdd(SkScalarMulAdd(SkScalarMulAdd(A, t, B), t, C), t, D);
 }
 
 static SkScalar eval_cubic_pts(SkScalar c0, SkScalar c1, SkScalar c2, SkScalar c3,
                                SkScalar t) {
@@ skipping 234 matching lines @@
     switch (this->getFillType()) {
         case SkPath::kEvenOdd_FillType:
         case SkPath::kInverseEvenOdd_FillType:
             w &= 1;
             break;
         default:
             break;
     }
     return SkToBool(w);
 }