harden pathops for pathological test

src/pathops/SkOpSegment.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "SkIntersections.h"
 #include "SkOpContour.h"
 #include "SkOpSegment.h"
 #include "SkPathWriter.h"
@@ skipping 142 matching lines @@
         }
 next:
         lastDone = span.fDone;
     }
     return topPt;
 }
 
 bool SkOpSegment::activeOp(int index, int endIndex, int xorMiMask, int xorSuMask, SkPathOp op) {
     int sumMiWinding = updateWinding(endIndex, index);
     int sumSuWinding = updateOppWinding(endIndex, index);
+#if DEBUG_LIMIT_WIND_SUM
+    SkASSERT(abs(sumMiWinding) <= DEBUG_LIMIT_WIND_SUM);
+    SkASSERT(abs(sumSuWinding) <= DEBUG_LIMIT_WIND_SUM);
+#endif
     if (fOperand) {
         SkTSwap<int>(sumMiWinding, sumSuWinding);
     }
     return activeOp(xorMiMask, xorSuMask, index, endIndex, op, &sumMiWinding, &sumSuWinding);
 }
 
 bool SkOpSegment::activeOp(int xorMiMask, int xorSuMask, int index, int endIndex, SkPathOp op,
         int* sumMiWinding, int* sumSuWinding) {
     int maxWinding, sumWinding, oppMaxWinding, oppSumWinding;
     setUpWindings(index, endIndex, sumMiWinding, sumSuWinding,
@@ skipping 437 matching lines @@
     span->fChased = false;
     span->fCoincident = false;
     span->fLoop = false;
     span->fNear = false;
     span->fMultiple = false;
     span->fSmall = false;
     span->fTiny = false;
     if ((span->fDone = newT == 1)) {
         ++fDoneSpans;
     }
+    setSpanFlags(pt, newT, span);
+    return insertedAt;
+}
+
+void SkOpSegment::setSpanFlags(const SkPoint& pt, double newT, SkOpSpan* span) {
     int less = -1;
 // FIXME: note that this relies on spans being a continguous array
 // find range of spans with nearly the same point as this one
     // FIXME: SkDPoint::ApproximatelyEqual is better but breaks tests at the moment
     while (&span[less + 1] - fTs.begin() > 0 && AlmostEqualUlps(span[less].fPt, pt)) {
         if (fVerb == SkPath::kCubic_Verb) {
             double tInterval = newT - span[less].fT;
             double tMid = newT - tInterval / 2;
             SkDPoint midPt = dcubic_xy_at_t(fPts, tMid);
             if (!midPt.approximatelyEqual(xyAtT(span))) {
@@ skipping 15 matching lines @@
         }
         ++more;
     }
     ++less;
     --more;
     while (more - 1 > less && span[more].fPt == span[more - 1].fPt
             && span[more].fT == span[more - 1].fT) {
         --more;
     }
     if (less == more) {
-        return insertedAt;
+        return;
     }
     if (precisely_negative(span[more].fT - span[less].fT)) {
-        return insertedAt;
+        return;
     }
 // if the total range of t values is big enough, mark all tiny
     bool tiny = span[less].fPt == span[more].fPt;
     int index = less;
     do {
         fSmall = span[index].fSmall = true;
         fTiny |= span[index].fTiny = tiny;
         if (!span[index].fDone) {
             span[index].fDone = true;
             ++fDoneSpans;
         }
     } while (++index < more);
-    return insertedAt;
+    return;
+}
+
+void SkOpSegment::resetSpanFlags() {
+    fSmall = fTiny = false;
+    fDoneSpans = 0;
+    int start = 0;
+    int last = this->count() - 1;
+    do {
+        SkOpSpan* startSpan = &this->fTs[start];
+        double startT = startSpan->fT;
+        startSpan->fSmall = startSpan->fTiny = false;  // sets range initial
+        bool terminus = startT == 1;
+        if ((startSpan->fDone = !startSpan->fWindValue | terminus)) {
+            ++fDoneSpans;
+        }
+        ++start;  // range initial + 1
+        if (terminus) {
+            continue;
+        }
+        const SkPoint& pt = startSpan->fPt;
+        int end = start;  // range initial + 1
+        while (end <= last) {
+            const SkOpSpan& endSpan = this->span(end);
+            if (!AlmostEqualUlps(endSpan.fPt, pt)) {
+                break;
+            }
+            if (fVerb == SkPath::kCubic_Verb) {
+                double tMid = (startSpan->fT + endSpan.fT) / 2;
+                SkDPoint midEndPt = dcubic_xy_at_t(fPts, tMid);
+                if (!midEndPt.approximatelyEqual(xyAtT(startSpan))) {
+                    break;
+                }
+            }
+            ++end;
+        }
+        if (start == end) {  // end == range final + 1
+            continue;
+        }
+        while (--end >= start) {  // end == range final
+            const SkOpSpan& endSpan = this->span(end);
+            const SkOpSpan& priorSpan = this->span(end - 1);
+            if (endSpan.fPt != priorSpan.fPt || endSpan.fT != priorSpan.fT) {
+                break;  // end == range final + 1
+            }
+        }
+        if (end < start) {  // end == range final + 1
+            continue;
+        }
+        int index = start - 1;  // index == range initial
+        start = end;  // start = range final + 1
+        const SkOpSpan& nextSpan = this->span(end);
+        if (precisely_negative(nextSpan.fT - startSpan->fT)) {
+            while (++index < end) {
+                startSpan = &this->fTs[index];
+                startSpan->fSmall = startSpan->fTiny = false;  // sets range initial + 1
+                if ((startSpan->fDone = !startSpan->fWindValue)) {
+                    ++fDoneSpans;
+                }
+            }
+            continue;
+        }
+        if (!startSpan->fWindValue) {
+            --fDoneSpans;  // added back below
+        }
+        bool tiny = nextSpan.fPt == startSpan->fPt;
+        do {
+            fSmall = startSpan->fSmall = true;  // sets range initial
+            fTiny |= startSpan->fTiny = tiny;
+            startSpan->fDone = true;
+            ++fDoneSpans;
+            startSpan = &this->fTs[++index];
+        } while (index < end);  // loop through tiny small range end (last)
+    } while (start <= last);
 }
 
 // set spans from start to end to decrement by one
 // note this walks other backwards
 // FIXME: there's probably an edge case that can be constructed where
 // two span in one segment are separated by float epsilon on one span but
 // not the other, if one segment is very small. For this
 // case the counts asserted below may or may not be enough to separate the
 // spans. Even if the counts work out, what if the spans aren't correctly
 // sorted? It feels better in such a case to match the span's other span
@@ skipping 87 matching lines @@
             if (originalWindValue != oTst2->fWindValue) {
                 goto skipAdvanceOtherCancel;
             }
             if (!oTst2->fWindValue) {
                 goto skipAdvanceOtherCancel;
             }
             if (endPt == other->fTs[oIdx2].fPt) {
                 break;
             }
         }
+        oFoundEnd = endPt == oTest->fPt;
         do {
             SkASSERT(originalWindValue == oTest->fWindValue);
             if (decrement) {
                 if (binary && !bigger) {
                     oTest->fOppValue--;
                 } else {
                     other->decrementSpan(oTest);
                 }
             } else if (track) {
                 TrackOutsidePair(&oOutsidePts, *oTestPt, *testPt);
@@ skipping 174 matching lines @@
                 }
         skipExactMatches:
                 ;
             }
             ++index;
         }
     }
     debugValidate();
 }
 
+void SkOpSegment::alignRange(int lower, int upper,
+        const SkOpSegment* other, int oLower, int oUpper) {
+    for (int oIndex = oLower; oIndex <= oUpper; ++oIndex) {
+        const SkOpSpan& oSpan = other->span(oIndex);
+        const SkOpSegment* oOther = oSpan.fOther;
+        if (oOther == this) {
+            continue;
+        }
+        SkOpSpan* matchSpan;
+        int matchIndex;
+        const SkOpSpan* refSpan;
+        for (int iIndex = lower; iIndex <= upper; ++iIndex) {
+            const SkOpSpan& iSpan = this->span(iIndex);
+            const SkOpSegment* iOther = iSpan.fOther;
+            if (iOther == other) {
+                continue;
+            }
+            if (iOther == oOther) {
+                goto nextI;
+            }
+        }
+        {
+            // oSpan does not have a match in this
+            int iCount = this->count();
+            const SkOpSpan* iMatch = NULL;
+            double iMatchTDiff;
+            matchIndex = -1;
+            for (int iIndex = 0; iIndex < iCount; ++iIndex) {
+                const SkOpSpan& iSpan = this->span(iIndex);
+                const SkOpSegment* iOther = iSpan.fOther;
+                if (iOther != oOther) {
+                    continue;
+                }
+                double testTDiff = fabs(iSpan.fOtherT - oSpan.fOtherT);
+                if (!iMatch || testTDiff < iMatchTDiff) {
+                    matchIndex = iIndex;
+                    iMatch = &iSpan;
+                    iMatchTDiff = testTDiff;
+                }
+            }
+            if (matchIndex < 0) {
+                continue;  // the entry is missing, & will be picked up later (FIXME: fix it here?)
+            }
+            matchSpan = &this->fTs[matchIndex];
+            refSpan = &this->span(lower);
+            if (!SkDPoint::ApproximatelyEqual(matchSpan->fPt, refSpan->fPt)) {
+                goto nextI;
+            }
+            if (matchIndex != lower - 1 && matchIndex != upper + 1) {
+                // the consecutive spans need to be rearranged to get the missing one close 
+                continue;  // FIXME: more work to do
+            }
+        }
+        {
+            this->fixOtherTIndex();
+            SkScalar newT;
+            if (matchSpan->fT != 0 && matchSpan->fT != 1) {
+                newT = matchSpan->fT = refSpan->fT;
+                matchSpan->fOther->fTs[matchSpan->fOtherIndex].fOtherT = refSpan->fT;
+            } else {  // leave span at the start or end there and adjust the neighbors
+                newT = matchSpan->fT;
+                for (int iIndex = lower; iIndex <= upper; ++iIndex) {
+                    matchSpan = &this->fTs[iIndex];
+                    matchSpan->fT = newT;
+                    matchSpan->fOther->fTs[matchSpan->fOtherIndex].fOtherT = newT;
+                }
+            }
+            this->resetSpanFlags();  // fix up small / tiny / done
+            // align ts of other ranges with adjacent spans that match the aligned points
+            lower = SkTMin(lower, matchIndex);
+            while (lower > 0) {
+                const SkOpSpan& span = this->span(lower - 1);
+                if (span.fT != newT) {
+                    break;
+                }
+                --lower;
+            }
+            upper = SkTMax(upper, matchIndex);
+            int last = this->count() - 1;
+            while (upper < last) {
+                const SkOpSpan& span = this->span(upper + 1);
+                if (span.fT != newT) {
+                    break;
+                }
+                ++upper;
+            }
+            for (int iIndex = lower; iIndex <= upper; ++iIndex) {
+                const SkOpSpan& span = this->span(iIndex);
+                SkOpSegment* aOther = span.fOther;
+                int aLower = span.fOtherIndex;
+                SkScalar aT = span.fOtherT;
+                bool aResetFlags = false;
+                while (aLower > 0) {
+                    SkOpSpan* aSpan = &aOther->fTs[aLower - 1];
+                    for (int iIndex = lower; iIndex <= upper; ++iIndex) {
+                        if (aSpan->fPt == this->fTs[iIndex].fPt) {
+                            goto matchFound;
+                        }
+                    }
+                    break;
+            matchFound:
+                    --aLower;
+                }
+                int aUpper = span.fOtherIndex;
+                int aLast = aOther->count() - 1;
+                while (aUpper < aLast) {
+                    SkOpSpan* aSpan = &aOther->fTs[aUpper + 1];
+                    for (int iIndex = lower; iIndex <= upper; ++iIndex) {
+                        if (aSpan->fPt == this->fTs[iIndex].fPt) {
+                            goto matchFound2;
+                        }
+                    }
+                    break;
+            matchFound2:
+                    ++aUpper;
+                }
+                if (aOther->fTs[aLower].fT == 0) {
+                    aT = 0;
+                } else if (aOther->fTs[aUpper].fT == 1) {
+                    aT = 1;
+                }
+                bool aFixed = false;
+                for (int aIndex = aLower; aIndex <= aUpper; ++aIndex) {
+                    SkOpSpan* aSpan = &aOther->fTs[aIndex];
+                    if (aSpan->fT == aT) {
+                        continue;
+                    }
+                    SkASSERT(way_roughly_equal(aSpan->fT, aT));
+                    if (!aFixed) {
+                        aOther->fixOtherTIndex();
+                        aFixed = true;
+                    }
+                    aSpan->fT = aT;
+                    aSpan->fOther->fTs[aSpan->fOtherIndex].fOtherT = aT;
+                    aResetFlags = true;
+                }
+                if (aResetFlags) {
+                    aOther->resetSpanFlags();
+                }
+            }
+        }
+nextI: ;
+    }
+}
+
 void SkOpSegment::alignSpan(const SkPoint& newPt, double newT, const SkOpSegment* other,
         double otherT, const SkOpSegment* other2, SkOpSpan* oSpan,
         SkTDArray<AlignedSpan>* alignedArray) {
     AlignedSpan* aligned = alignedArray->append();
     aligned->fOldPt = oSpan->fPt;
     aligned->fPt = newPt;
     aligned->fOldT = oSpan->fT;
     aligned->fT = newT;
     aligned->fSegment = this;  // OPTIMIZE: may be unused, can remove
     aligned->fOther1 = other;
@@ skipping 255 matching lines @@
 void SkOpSegment::bumpCoincidentOBlind(int index, int endIndex) {
     do {
         zeroSpan(&fTs[index]);
     } while (++index < endIndex);
 }
 
 // because of the order in which coincidences are resolved, this and other
 // may not have the same intermediate points. Compute the corresponding
 // intermediate T values (using this as the master, other as the follower)
 // and walk other conditionally -- hoping that it catches up in the end
-void SkOpSegment::bumpCoincidentOther(const SkOpSpan& test, int* oIndexPtr,
-        SkTArray<SkPoint, true>* oOutsidePts) {
+bool SkOpSegment::bumpCoincidentOther(const SkOpSpan& test, int* oIndexPtr,
+        SkTArray<SkPoint, true>* oOutsidePts, const SkPoint& oEndPt) {
     int oIndex = *oIndexPtr;
     SkOpSpan* const oTest = &fTs[oIndex];
     SkOpSpan* oEnd = oTest;
     const SkPoint& oStartPt = oTest->fPt;
     double oStartT = oTest->fT;
 #if 0  // FIXME : figure out what disabling this breaks
     const SkPoint& startPt = test.fPt;
     // this is always true since oEnd == oTest && oStartPt == oTest->fPt -- find proper condition
     if (oStartPt == oEnd->fPt || precisely_equal(oStartT, oEnd->fT)) {
         TrackOutside(oOutsidePts, startPt);
     }
 #endif
+    bool foundEnd = false;
     while (oStartPt == oEnd->fPt || precisely_equal(oStartT, oEnd->fT)) {
+        foundEnd |= oEndPt == oEnd->fPt;
         zeroSpan(oEnd);
         oEnd = &fTs[++oIndex];
     }
     *oIndexPtr = oIndex;
+    return foundEnd;
 }
 
 // FIXME: need to test this case:
 // contourA has two segments that are coincident
 // contourB has two segments that are coincident in the same place
 // each ends up with +2/0 pairs for winding count
 // since logic below doesn't transfer count (only increments/decrements) can this be
 // resolved to +4/0 ?
 
 // set spans from start to end to increment the greater by one and decrement
@@ skipping 29 matching lines @@
     // paths with extreme data will fail this test and eject out of pathops altogether later on
     // SkASSERT(AlmostEqualUlps(*testPt, *oTestPt));
     do {
         SkASSERT(test->fT < 1);
         if (oTest->fT == 1) {
             // paths with extreme data may be so mismatched that we fail here
             return false;
         }
 
         // consolidate the winding count even if done
+        bool foundEnd = false;
         if ((test->fWindValue == 0 && test->fOppValue == 0)
                 || (oTest->fWindValue == 0 && oTest->fOppValue == 0)) {
             SkDEBUGCODE(int firstWind = test->fWindValue);
             SkDEBUGCODE(int firstOpp = test->fOppValue);
             do {
                 SkASSERT(firstWind == fTs[index].fWindValue);
                 SkASSERT(firstOpp == fTs[index].fOppValue);
                 ++index;
                 SkASSERT(index < fTs.count());
             } while (*testPt == fTs[index].fPt);
             SkDEBUGCODE(firstWind = oTest->fWindValue);
             SkDEBUGCODE(firstOpp = oTest->fOppValue);
             do {
                 SkASSERT(firstWind == other->fTs[oIndex].fWindValue);
                 SkASSERT(firstOpp == other->fTs[oIndex].fOppValue);
                 ++oIndex;
                 SkASSERT(oIndex < other->fTs.count());
             } while (*oTestPt == other->fTs[oIndex].fPt);
         } else {
             if (!binary || test->fWindValue + oTest->fOppValue >= 0) {
                 if (!bumpCoincidentThis(*oTest, binary, &index, &outsidePts)) {
                     return false;
                 }
-                other->bumpCoincidentOther(*test, &oIndex, &oOutsidePts);
+                foundEnd = other->bumpCoincidentOther(*test, &oIndex, &oOutsidePts, endPt);
             } else {
                 if (!other->bumpCoincidentThis(*test, binary, &oIndex, &oOutsidePts)) {
                     return false;
                 }
-                bumpCoincidentOther(*oTest, &index, &outsidePts);
+                foundEnd = bumpCoincidentOther(*oTest, &index, &outsidePts, endPt);
             }
         }
         test = &fTs[index];
         testPt = &test->fPt;
         testT = test->fT;
         oTest = &other->fTs[oIndex];
         oTestPt = &oTest->fPt;
         if (endPt == *testPt || precisely_equal(endT, testT)) {
             break;
         }
+        if (0 && foundEnd) {  // FIXME: this is likely needed but wait until a test case triggers it
+            break;
+        }
 //        SkASSERT(AlmostEqualUlps(*testPt, *oTestPt));
     } while (endPt != *oTestPt);
     // in rare cases, one may have ended before the other
     if (endPt != *testPt && !precisely_equal(endT, testT)) {
         int lastWind = test[-1].fWindValue;
         int lastOpp = test[-1].fOppValue;
         bool zero = lastWind == 0 && lastOpp == 0;
         do {
             if (test->fWindValue || test->fOppValue) {
                 test->fWindValue = lastWind;
                 test->fOppValue = lastOpp;
                 if (zero) {
+                    SkASSERT(!test->fDone);
                     test->fDone = true;
                     ++fDoneSpans;
                 }
             }
             test = &fTs[++index];
             testPt = &test->fPt;
         } while (endPt != *testPt);
     }
     if (endPt != *oTestPt) {
         // look ahead to see if zeroing more spans will allows us to catch up
@@ skipping 18 matching lines @@
                 }
                 if (++oPeekIndex == oCount) {
                     break;
                 }
                 oPeek = &other->fTs[oPeekIndex];
             } while (endPt == oPeek->fPt);
         }
         if (success) {
             do {
                 if (!binary || test->fWindValue + oTest->fOppValue >= 0) {
-                    other->bumpCoincidentOther(*test, &oIndex, &oOutsidePts);
+                    if (other->bumpCoincidentOther(*test, &oIndex, &oOutsidePts, endPt)) {
+                        break;
+                    }
                 } else {
                     if (!other->bumpCoincidentThis(*test, binary, &oIndex, &oOutsidePts)) {
                         return false;
                     }
                 }
                 oTest = &other->fTs[oIndex];
                 oTestPt = &oTest->fPt;
             } while (endPt != *oTestPt);
         }
     }
@@ skipping 53 matching lines @@
             }
         }
     }
 #if DEBUG_ADD_T_PAIR
     SkDebugf("%s addTPair this=%d %1.9g other=%d %1.9g\n",
             __FUNCTION__, fID, t, other->fID, otherT);
 #endif
     SkASSERT(other != this);
     int insertedAt = addT(other, pt, t);
     int otherInsertedAt = other->addT(this, pt2, otherT);
-    addOtherT(insertedAt, otherT, otherInsertedAt);
+    this->addOtherT(insertedAt, otherT, otherInsertedAt);
     other->addOtherT(otherInsertedAt, t, insertedAt);
-    matchWindingValue(insertedAt, t, borrowWind);
+    this->matchWindingValue(insertedAt, t, borrowWind);
     other->matchWindingValue(otherInsertedAt, otherT, borrowWind);
     SkOpSpan& span = this->fTs[insertedAt];
     if (pt != pt2) {
         span.fNear = true;
         SkOpSpan& oSpan = other->fTs[otherInsertedAt];
         oSpan.fNear = true;
     }
+    // if the newly inserted spans match a neighbor on one but not the other, make them agree
+    int lower = this->nextExactSpan(insertedAt, -1) + 1;
+    int upper = this->nextExactSpan(insertedAt, 1) - 1;
+    if (upper < 0) {
+        upper = this->count() - 1;
+    }
+    int oLower = other->nextExactSpan(otherInsertedAt, -1) + 1;
+    int oUpper = other->nextExactSpan(otherInsertedAt, 1) - 1;
+    if (oUpper < 0) {
+        oUpper = other->count() - 1;
+    }
+    if (lower == upper && oLower == oUpper) {
+        return &span;
+    }
+#if DEBUG_CONCIDENT
+    SkDebugf("%s id=%d lower=%d upper=%d other=%d oLower=%d oUpper=%d\n", __FUNCTION__,
+            debugID(), lower, upper, other->debugID(), oLower, oUpper);
+#endif
+    // find the nearby spans in one range missing in the other
+    this->alignRange(lower, upper, other, oLower, oUpper);
+    other->alignRange(oLower, oUpper, this, lower, upper);
     return &span;
 }
 
 const SkOpSpan* SkOpSegment::addTPair(double t, SkOpSegment* other, double otherT, bool borrowWind,
                            const SkPoint& pt) {
     return addTPair(t, other, otherT, borrowWind, pt, pt);
 }
 
 bool SkOpSegment::betweenPoints(double midT, const SkPoint& pt1, const SkPoint& pt2) const {
     const SkPoint midPt = ptAtT(midT);
@@ skipping 387 matching lines @@
     SkASSERT(span->fWindValue >= 0);
     span->fOppValue += oppDelta;
     SkASSERT(span->fOppValue >= 0);
     if (fXor) {
         span->fWindValue &= 1;
     }
     if (fOppXor) {
         span->fOppValue &= 1;
     }
     if (!span->fWindValue && !span->fOppValue) {
-        span->fDone = true;
-        ++fDoneSpans;
+        if (!span->fDone) {
+            span->fDone = true;
+            ++fDoneSpans;
+        }
         return true;
     }
     return false;
 }
 
 const SkOpSpan& SkOpSegment::firstSpan(const SkOpSpan& thisSpan) const {
     const SkOpSpan* firstSpan = &thisSpan; // rewind to the start
     const SkOpSpan* beginSpan = fTs.begin();
     const SkPoint& testPt = thisSpan.fPt;
     while (firstSpan > beginSpan && firstSpan[-1].fPt == testPt) {
@@ skipping 203 matching lines @@
         missing.fOther->fixOtherTIndex();
     }
     for (index = 0; index < missingCoincidence.count(); ++index) {
         MissingSpan& missing = missingCoincidence[index];
         missing.fSegment->fixOtherTIndex();
     }
     debugValidate();
 }
 
 // look to see if the curve end intersects an intermediary that intersects the other
-void SkOpSegment::checkEnds() {
+bool SkOpSegment::checkEnds() {
     debugValidate();
     SkSTArray<kMissingSpanCount, MissingSpan, true> missingSpans;
     int count = fTs.count();
     for (int index = 0; index < count; ++index) {
         const SkOpSpan& span = fTs[index];
         double otherT = span.fOtherT;
         if (otherT != 0 && otherT != 1) { // only check ends
             continue;
         }
         const SkOpSegment* other = span.fOther;
@@ skipping 54 matching lines @@
                     if (match->betweenPoints(midT, tSpan.fPt, peekSpan.fPt)) {
                         goto nextPeekIndex;
                     }
                 }
             }
             if (missingSpans.count() > 0) {
                 const MissingSpan& lastMissing = missingSpans.back();
                 if (lastMissing.fT == t
                         && lastMissing.fOther == match
                         && lastMissing.fOtherT == matchT) {
-                    SkASSERT(lastMissing.fPt == peekSpan.fPt);
+                    SkASSERT(SkDPoint::ApproximatelyEqual(lastMissing.fPt, peekSpan.fPt));
                     continue;
                 }
             }
-#if DEBUG_CHECK_ENDS
+            if (this == match) {
+                return false; // extremely large paths can trigger this
+            }
+#if DEBUG_CHECK_ALIGN
             SkDebugf("%s id=%d missing t=%1.9g other=%d otherT=%1.9g pt=(%1.9g,%1.9g)\n",
                     __FUNCTION__, fID, t, match->fID, matchT, peekSpan.fPt.fX, peekSpan.fPt.fY);
 #endif
             // this segment is missing a entry that the other contains
             // remember so we can add the missing one and recompute the indices
             {
                 MissingSpan& missing = missingSpans.push_back();
                 SkDEBUGCODE(sk_bzero(&missing, sizeof(missing)));
                 missing.fT = t;
                 SkASSERT(this != match);
                 missing.fOther = match;
                 missing.fOtherT = matchT;
                 missing.fPt = peekSpan.fPt;
             }
             break;
 nextPeekIndex:
             ;
         }
     }
     if (missingSpans.count() == 0) {
         debugValidate();
-        return;
+        return true;
     }
     debugValidate();
     int missingCount = missingSpans.count();
     for (int index = 0; index < missingCount; ++index)  {
         MissingSpan& missing = missingSpans[index];
         if (this != missing.fOther) {
             addTPair(missing.fT, missing.fOther, missing.fOtherT, false, missing.fPt);
         }
     }
     fixOtherTIndex();
     // OPTIMIZATION: this may fix indices more than once. Build an array of unique segments to
     // avoid this
     for (int index = 0; index < missingCount; ++index)  {
         missingSpans[index].fOther->fixOtherTIndex();
     }
     debugValidate();
+    return true;
 }
 
 void SkOpSegment::checkLinks(const SkOpSpan* base,
         SkTArray<MissingSpan, true>* missingSpans) const {
     const SkOpSpan* first = fTs.begin();
     const SkOpSpan* last = fTs.end() - 1;
     SkASSERT(base >= first && last >= base);
     const SkOpSegment* other = base->fOther;
     const SkOpSpan* oFirst = other->fTs.begin();
     const SkOpSpan* oLast = other->fTs.end() - 1;
     const SkOpSpan* oSpan = &other->fTs[base->fOtherIndex];
     const SkOpSpan* test = base;
     const SkOpSpan* missing = NULL;
     while (test > first && (--test)->fPt == base->fPt) {
         if (this == test->fOther) {
             continue;
         }
         CheckOneLink(test, oSpan, oFirst, oLast, &missing, missingSpans);
     }
     test = base;
     while (test < last && (++test)->fPt == base->fPt) {
-        SkASSERT(this != test->fOther);
+        SkASSERT(this != test->fOther || test->fLoop);
         CheckOneLink(test, oSpan, oFirst, oLast, &missing, missingSpans);
     }
 }
 
 // see if spans with two or more intersections all agree on common t and point values
 void SkOpSegment::checkMultiples() {
     debugValidate();
     int index;
     int end = 0;
     while (fTs[++end].fT == 0)
@@ skipping 155 matching lines @@
         SkOpSegment* missingOther = missing.fOther;
         // note that add t pair may edit span arrays, so prior pointers to spans are no longer valid
         if (!missing.fSegment->addTPair(missing.fT, missingOther, missing.fOtherT, false,
                 missing.fPt)) {
             continue;
         }
         int otherTIndex = missingOther->findT(missing.fOtherT, missing.fPt, missing.fSegment);
         const SkOpSpan& otherSpan = missingOther->span(otherTIndex);
         if (otherSpan.fSmall) {
             const SkOpSpan* nextSpan = &otherSpan;
+            if (nextSpan->fPt == missing.fPt) {
+                continue;
+            }
             do {
                 ++nextSpan;
             } while (nextSpan->fSmall);
+            if (nextSpan->fT == 1) {
+                continue;
+            }
             SkAssertResult(missing.fSegment->addTCoincident(missing.fPt, nextSpan->fPt,
                     nextSpan->fT, missingOther));
         } else if (otherSpan.fT > 0) {
             const SkOpSpan* priorSpan = &otherSpan;
             do {
                 --priorSpan;
             } while (priorSpan->fT == otherSpan.fT);
             if (priorSpan->fSmall) {
                 missing.fSegment->addTCancel(missing.fPt, priorSpan->fPt, missingOther);
             }
@@ skipping 655 matching lines @@
     for (int index = 0; index < count; ++index) {
         const SkOpSpan& span = fTs[index];
         if (span.fT == t && span.fOther == match) {
             return index;
         }
     }
     SkASSERT(0);
     return -1;
 }
 
+
+
 int SkOpSegment::findOtherT(double t, const SkOpSegment* match) const {
     int count = this->count();
     for (int index = 0; index < count; ++index) {
         const SkOpSpan& span = fTs[index];
         if (span.fOtherT == t && span.fOther == match) {
             return index;
         }
     }
     return -1;
 }
@@ skipping 66 matching lines @@
         return NULL;  // nothing to do
     }
     SkScalar top = SK_ScalarMax;
     const SkOpAngle* firstAngle = NULL;
     const SkOpAngle* angle = baseAngle;
     do {
         if (!angle->unorderable()) {
             SkOpSegment* next = angle->segment();
             SkPathOpsBounds bounds;
             next->subDivideBounds(angle->end(), angle->start(), &bounds);
-            if (approximately_greater(top, bounds.fTop)) {
+            bool nearSame = AlmostEqualUlps(top, bounds.top());
+            bool lowerSector = !firstAngle || angle->sectorEnd() < firstAngle->sectorStart();
+            bool lesserSector = top > bounds.fTop;
+            if (lesserSector && (!nearSame || lowerSector)) {
                 top = bounds.fTop;
                 firstAngle = angle;
             }
         }
         angle = angle->next();
     } while (angle != baseAngle);
-    SkASSERT(firstAngle);
+    if (!firstAngle) {
+        return NULL;  // if all are unorderable, give up
+    }
 #if DEBUG_SORT
     SkDebugf("%s\n", __FUNCTION__);
     firstAngle->debugLoop();
 #endif
     // skip edges that have already been processed
     angle = firstAngle;
     SkOpSegment* leftSegment = NULL;
     bool looped = false;
     do {
         *unsortable = angle->unorderable();
@@ skipping 76 matching lines @@
     for (int index = 0; index < count; ++index) {
         const SkOpSpan& span = this->span(index);
         if (span.fCoincident) {
             foundEnds |= (span.fOther == other) << ((t > span.fT) + (t >= span.fT));
         }
     }
     SkASSERT(foundEnds != 7);
     return foundEnds == 0x3 || foundEnds == 0x5 || foundEnds == 0x6;  // two bits set
 }
 
+bool SkOpSegment::inconsistentAngle(int maxWinding, int sumWinding, int oppMaxWinding,
+        int oppSumWinding, const SkOpAngle* angle) const {
+    SkASSERT(angle->segment() == this);
+    if (UseInnerWinding(maxWinding, sumWinding)) {
+        maxWinding = sumWinding;
+    }
+    if (oppMaxWinding != oppSumWinding && UseInnerWinding(oppMaxWinding, oppSumWinding)) {
+        oppMaxWinding = oppSumWinding;
+    }
+    return inconsistentWinding(angle, maxWinding, oppMaxWinding);
+}
+
+bool SkOpSegment::inconsistentWinding(const SkOpAngle* angle, int winding,
+        int oppWinding) const {
+    int index = angle->start();
+    int endIndex = angle->end();
+    int min = SkMin32(index, endIndex);
+    int step = SkSign32(endIndex - index);
+    if (inconsistentWinding(min, winding, oppWinding)) {
+        return true;
+    }
+    const SkOpSegment* other = this;
+    while ((other = other->nextChase(&index, &step, &min, NULL))) {
+        if (other->fTs[min].fWindSum != SK_MinS32) {
+            break;
+        }
+        if (fOperand == other->fOperand) {
+            if (other->inconsistentWinding(min, winding, oppWinding)) {
+                return true;
+            }
+        } else {
+            if (other->inconsistentWinding(min, oppWinding, winding)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+bool SkOpSegment::inconsistentWinding(int index, int winding, int oppWinding) const {
+    SkASSERT(winding || oppWinding);
+    double referenceT = this->span(index).fT;
+    int lesser = index;
+    while (--lesser >= 0 && precisely_negative(referenceT - fTs[lesser].fT)) {
+        if (inconsistentWinding(__FUNCTION__, lesser, winding, oppWinding)) {
+            return true;
+        }
+    }
+    do {
+        if (inconsistentWinding(__FUNCTION__, index, winding, oppWinding)) {
+            return true;
+        }
+   } while (++index < fTs.count() && precisely_negative(fTs[index].fT - referenceT));
+    return false;
+}
+
+bool SkOpSegment::inconsistentWinding(const char* funName, int tIndex, int winding,
+        int oppWinding) const {
+    const SkOpSpan& span = this->span(tIndex);
+    if (span.fDone && !span.fSmall) {
+        return false;
+    }
+    return (span.fWindSum != SK_MinS32 && span.fWindSum != winding)
+            || (span.fOppSum != SK_MinS32 && span.fOppSum != oppWinding);
+}
+
 void SkOpSegment::init(const SkPoint pts[], SkPath::Verb verb, bool operand, bool evenOdd) {
     fDoneSpans = 0;
     fOperand = operand;
     fXor = evenOdd;
     fPts = pts;
     fVerb = verb;
     fLoop = fMultiples = fSmall = fTiny = false;
 }
 
 void SkOpSegment::initWinding(int start, int end, SkOpAngle::IncludeType angleIncludeType) {
     int local = spanSign(start, end);
+    SkDEBUGCODE(bool success);
     if (angleIncludeType == SkOpAngle::kBinarySingle) {
         int oppLocal = oppSign(start, end);
-        (void) markAndChaseWinding(start, end, local, oppLocal);
+        SkDEBUGCODE(success =) markAndChaseWinding(start, end, local, oppLocal, NULL);
     // OPTIMIZATION: the reverse mark and chase could skip the first marking
-        (void) markAndChaseWinding(end, start, local, oppLocal);
+        SkDEBUGCODE(success |=) markAndChaseWinding(end, start, local, oppLocal, NULL);
     } else {
-        (void) markAndChaseWinding(start, end, local);
+        SkDEBUGCODE(success =) markAndChaseWinding(start, end, local, NULL);
     // OPTIMIZATION: the reverse mark and chase could skip the first marking
-        (void) markAndChaseWinding(end, start, local);
+        SkDEBUGCODE(success |=) markAndChaseWinding(end, start, local, NULL);
     }
+    SkASSERT(success);
 }
 
 /*
 when we start with a vertical intersect, we try to use the dx to determine if the edge is to
 the left or the right of vertical. This determines if we need to add the span's
 sign or not. However, this isn't enough.
 If the supplied sign (winding) is zero, then we didn't hit another vertical span, so dx is needed.
 If there was a winding, then it may or may not need adjusting. If the span the winding was borrowed
 from has the same x direction as this span, the winding should change. If the dx is opposite, then
 the same winding is shared by both.
 */
-void SkOpSegment::initWinding(int start, int end, double tHit, int winding, SkScalar hitDx,
+bool SkOpSegment::initWinding(int start, int end, double tHit, int winding, SkScalar hitDx,
                               int oppWind, SkScalar hitOppDx) {
     SkASSERT(hitDx || !winding);
     SkScalar dx = (*CurveSlopeAtT[SkPathOpsVerbToPoints(fVerb)])(fPts, tHit).fX;
     SkASSERT(dx);
     int windVal = windValue(SkMin32(start, end));
 #if DEBUG_WINDING_AT_T
     SkDebugf("%s id=%d oldWinding=%d hitDx=%c dx=%c windVal=%d", __FUNCTION__, debugID(), winding,
             hitDx ? hitDx > 0 ? '+' : '-' : '0', dx > 0 ? '+' : '-', windVal);
 #endif
     int sideWind = winding + (dx < 0 ? windVal : -windVal);
     if (abs(winding) < abs(sideWind)) {
         winding = sideWind;
     }
     SkDEBUGCODE(int oppLocal = oppSign(start, end));
     SkASSERT(hitOppDx || !oppWind || !oppLocal);
     int oppWindVal = oppValue(SkMin32(start, end));
     if (!oppWind) {
         oppWind = dx < 0 ? oppWindVal : -oppWindVal;
     } else if (hitOppDx * dx >= 0) {
         int oppSideWind = oppWind + (dx < 0 ? oppWindVal : -oppWindVal);
         if (abs(oppWind) < abs(oppSideWind)) {
             oppWind = oppSideWind;
         }
     }
 #if DEBUG_WINDING_AT_T
     SkDebugf(" winding=%d oppWind=%d\n", winding, oppWind);
 #endif
-    (void) markAndChaseWinding(start, end, winding, oppWind);
+    // if this fails to mark (because the edges are too small) inform caller to try again
+    bool success = markAndChaseWinding(start, end, winding, oppWind, NULL);
     // OPTIMIZATION: the reverse mark and chase could skip the first marking
-    (void) markAndChaseWinding(end, start, winding, oppWind);
+    success |= markAndChaseWinding(end, start, winding, oppWind, NULL);
+    return success;
 }
 
 bool SkOpSegment::inLoop(const SkOpAngle* baseAngle, int spanCount, int* indexPtr) const {
     if (!baseAngle->inLoop()) {
         return false;
     }
     int index = *indexPtr;
     SkOpAngle* from = fTs[index].fFromAngle;
     SkOpAngle* to = fTs[index].fToAngle;
     while (++index < spanCount) {
@@ skipping 43 matching lines @@
 // if neither is a line, test for coincidence
 bool SkOpSegment::joinCoincidence(SkOpSegment* other, double otherT, const SkPoint& otherPt,
         int step, bool cancel) {
     int otherTIndex = other->findT(otherT, otherPt, this);
     int next = other->nextExactSpan(otherTIndex, step);
     int otherMin = SkMin32(otherTIndex, next);
     int otherWind = other->span(otherMin).fWindValue;
     if (otherWind == 0) {
         return false;
     }
-    SkASSERT(next >= 0);
+    if (next < 0) {
+        return false;  // can happen if t values were adjusted but coincident ts were not
+    }
     int tIndex = 0;
     do {
         SkOpSpan* test = &fTs[tIndex];
         SkASSERT(test->fT == 0);
         if (test->fOther == other || test->fOtherT != 1) {
             continue;
         }
         SkPoint startPt, endPt;
         double endT;
         if (findCoincidentMatch(test, other, otherTIndex, next, step, &startPt, &endPt, &endT)) {
             SkOpSegment* match = test->fOther;
             if (cancel) {
                 match->addTCancel(startPt, endPt, other);
             } else {
-                SkAssertResult(match->addTCoincident(startPt, endPt, endT, other));
+                if (!match->addTCoincident(startPt, endPt, endT, other)) {
+                    return false;
+                }
             }
             return true;
         }
     } while (fTs[++tIndex].fT == 0);
     return false;
 }
 
 // this span is excluded by the winding rule -- chase the ends
 // as long as they are unambiguous to mark connections as done
 // and give them the same winding value
@@ skipping 23 matching lines @@
     while ((other = other->nextChase(&index, &step, &min, &last))) {
         if (other->done()) {
             SkASSERT(!last);
             break;
         }
         other->markDoneUnary(min);
     }
     return last;
 }
 
-SkOpSpan* SkOpSegment::markAndChaseWinding(const SkOpAngle* angle, int winding) {
+bool SkOpSegment::markAndChaseWinding(const SkOpAngle* angle, int winding, SkOpSpan** lastPtr) {
     int index = angle->start();
     int endIndex = angle->end();
+    return markAndChaseWinding(index, endIndex, winding, lastPtr);
+}
+
+bool SkOpSegment::markAndChaseWinding(int index, int endIndex, int winding, SkOpSpan** lastPtr) {
+    int min = SkMin32(index, endIndex);
     int step = SkSign32(endIndex - index);
-    int min = SkMin32(index, endIndex);
-    markWinding(min, winding);
+    bool success = markWinding(min, winding);
     SkOpSpan* last = NULL;
     SkOpSegment* other = this;
     while ((other = other->nextChase(&index, &step, &min, &last))) {
-        if (other->fTs[min].fWindSum != SK_MinS32) {
-//            SkASSERT(other->fTs[min].fWindSum == winding);
-            SkASSERT(!last);
-            break;
-        }
-        other->markWinding(min, winding);
-    }
-    return last;
-}
-
-SkOpSpan* SkOpSegment::markAndChaseWinding(int index, int endIndex, int winding) {
-    int min = SkMin32(index, endIndex);
-    int step = SkSign32(endIndex - index);
-    markWinding(min, winding);
-    SkOpSpan* last = NULL;
-    SkOpSegment* other = this;
-    while ((other = other->nextChase(&index, &step, &min, &last))) {
         if (other->fTs[min].fWindSum != SK_MinS32) {
             SkASSERT(other->fTs[min].fWindSum == winding || other->fTs[min].fLoop);
             SkASSERT(!last);
             break;
         }
-        other->markWinding(min, winding);
+        (void) other->markWinding(min, winding);
     }
-    return last;
+    if (lastPtr) {
+        *lastPtr = last;
+    }
+    return success;
 }
 
-SkOpSpan* SkOpSegment::markAndChaseWinding(int index, int endIndex, int winding, int oppWinding) {
+bool SkOpSegment::markAndChaseWinding(int index, int endIndex, int winding, int oppWinding,
+        SkOpSpan** lastPtr) {
     int min = SkMin32(index, endIndex);
     int step = SkSign32(endIndex - index);
-    markWinding(min, winding, oppWinding);
+    bool success = markWinding(min, winding, oppWinding);
     SkOpSpan* last = NULL;
     SkOpSegment* other = this;
     while ((other = other->nextChase(&index, &step, &min, &last))) {
         if (other->fTs[min].fWindSum != SK_MinS32) {
 #ifdef SK_DEBUG
             if (!other->fTs[min].fLoop) {
                 if (fOperand == other->fOperand) {
 // FIXME: this is probably a bug -- rects4 asserts here
 //                    SkASSERT(other->fTs[min].fWindSum == winding);
 // FIXME: this is probably a bug -- rects3 asserts here
 //                    SkASSERT(other->fTs[min].fOppSum == oppWinding);
                 } else {
 // FIXME: this is probably a bug -- issue414409b asserts here
 //                    SkASSERT(other->fTs[min].fWindSum == oppWinding);
 // FIXME: this is probably a bug -- skpwww_joomla_org_23 asserts here
 //                    SkASSERT(other->fTs[min].fOppSum == winding);
                 }
             }
             SkASSERT(!last);
 #endif
             break;
         }
         if (fOperand == other->fOperand) {
-            other->markWinding(min, winding, oppWinding);
+            (void) other->markWinding(min, winding, oppWinding);
         } else {
-            other->markWinding(min, oppWinding, winding);
+            (void) other->markWinding(min, oppWinding, winding);
         }
     }
-    return last;
+    if (lastPtr) {
+        *lastPtr = last;
+    }
+    return success;
 }
 
-SkOpSpan* SkOpSegment::markAndChaseWinding(const SkOpAngle* angle, int winding, int oppWinding) {
+bool SkOpSegment::markAndChaseWinding(const SkOpAngle* angle, int winding, int oppWinding,
+        SkOpSpan** lastPtr) {
     int start = angle->start();
     int end = angle->end();
-    return markAndChaseWinding(start, end, winding, oppWinding);
+    return markAndChaseWinding(start, end, winding, oppWinding, lastPtr);
 }
 
 SkOpSpan* SkOpSegment::markAngle(int maxWinding, int sumWinding, const SkOpAngle* angle) {
     SkASSERT(angle->segment() == this);
     if (UseInnerWinding(maxWinding, sumWinding)) {
         maxWinding = sumWinding;
     }
-    SkOpSpan* last = markAndChaseWinding(angle, maxWinding);
+    SkOpSpan* last;
+    SkAssertResult(markAndChaseWinding(angle, maxWinding, &last));
 #if DEBUG_WINDING
     if (last) {
         SkDebugf("%s last id=%d windSum=", __FUNCTION__,
                 last->fOther->fTs[last->fOtherIndex].fOther->debugID());
         SkPathOpsDebug::WindingPrintf(last->fWindSum);
         SkDebugf(" small=%d\n", last->fSmall);
     }
 #endif
     return last;
 }
 
 SkOpSpan* SkOpSegment::markAngle(int maxWinding, int sumWinding, int oppMaxWinding,
                                  int oppSumWinding, const SkOpAngle* angle) {
     SkASSERT(angle->segment() == this);
     if (UseInnerWinding(maxWinding, sumWinding)) {
         maxWinding = sumWinding;
     }
     if (oppMaxWinding != oppSumWinding && UseInnerWinding(oppMaxWinding, oppSumWinding)) {
         oppMaxWinding = oppSumWinding;
     }
-    SkOpSpan* last = markAndChaseWinding(angle, maxWinding, oppMaxWinding);
+    SkOpSpan* last;
+    // caller doesn't require that this marks anything
+    (void) markAndChaseWinding(angle, maxWinding, oppMaxWinding, &last);
 #if DEBUG_WINDING
     if (last) {
         SkDebugf("%s last id=%d windSum=", __FUNCTION__,
                 last->fOther->fTs[last->fOtherIndex].fOther->debugID());
         SkPathOpsDebug::WindingPrintf(last->fWindSum);
         SkDebugf(" small=%d\n", last->fSmall);
     }
 #endif
     return last;
 }
@@ skipping 22 matching lines @@
     int lesser = index;
     while (--lesser >= 0 && precisely_negative(referenceT - fTs[lesser].fT)) {
         markOneDoneBinary(__FUNCTION__, lesser);
     }
     do {
         markOneDoneBinary(__FUNCTION__, index);
     } while (++index < fTs.count() && precisely_negative(fTs[index].fT - referenceT));
     debugValidate();
 }
 
+void SkOpSegment::markDoneFinal(int index) {
+    double referenceT = fTs[index].fT;
+    int lesser = index;
+    while (--lesser >= 0 && precisely_negative(referenceT - fTs[lesser].fT)) {
+        markOneDoneFinal(__FUNCTION__, lesser);
+    }
+    do {
+        markOneDoneFinal(__FUNCTION__, index);
+    } while (++index < fTs.count() && precisely_negative(fTs[index].fT - referenceT));
+    debugValidate();
+}
+
 void SkOpSegment::markDoneUnary(int index) {
     double referenceT = fTs[index].fT;
     int lesser = index;
     while (--lesser >= 0 && precisely_negative(referenceT - fTs[lesser].fT)) {
         markOneDoneUnary(__FUNCTION__, lesser);
     }
     do {
         markOneDoneUnary(__FUNCTION__, index);
     } while (++index < fTs.count() && precisely_negative(fTs[index].fT - referenceT));
     debugValidate();
 }
 
 void SkOpSegment::markOneDone(const char* funName, int tIndex, int winding) {
-    SkOpSpan* span = markOneWinding(funName, tIndex, winding);
-    if (!span || span->fDone) {
+    SkOpSpan* span;
+    (void) markOneWinding(funName, tIndex, winding, &span);  // allowed to do nothing
+    if (span->fDone) {
         return;
     }
     span->fDone = true;
-    fDoneSpans++;
+    ++fDoneSpans;
+}
+
+void SkOpSegment::markOneDoneFinal(const char* funName, int tIndex) {
+    SkOpSpan* span = &fTs[tIndex];
+    if (span->fDone) {
+        return;
+    }
+    span->fDone = true;
+    ++fDoneSpans;
 }
 
 void SkOpSegment::markOneDoneBinary(const char* funName, int tIndex) {
     SkOpSpan* span = verifyOneWinding(funName, tIndex);
     if (!span) {
         return;
     }
     SkASSERT(!span->fDone);
     span->fDone = true;
-    fDoneSpans++;
+    ++fDoneSpans;
 }
 
 void SkOpSegment::markOneDoneUnary(const char* funName, int tIndex) {
     SkOpSpan* span = verifyOneWindingU(funName, tIndex);
     if (!span) {
         return;
     }
     if (span->fWindSum == SK_MinS32) {
         SkDebugf("%s uncomputed\n", __FUNCTION__);
     }
     SkASSERT(!span->fDone);
     span->fDone = true;
-    fDoneSpans++;
+    ++fDoneSpans;
 }
 
-SkOpSpan* SkOpSegment::markOneWinding(const char* funName, int tIndex, int winding) {
-    SkOpSpan& span = fTs[tIndex];
-    if (span.fDone && !span.fSmall) {
-        return NULL;
+bool SkOpSegment::markOneWinding(const char* funName, int tIndex, int winding, SkOpSpan** lastPtr) {
+    SkOpSpan* span = &fTs[tIndex];
+    if (lastPtr) {
+        *lastPtr = span;
+    }
+    if (span->fDone && !span->fSmall) {
+        return false;
     }
 #if DEBUG_MARK_DONE
-    debugShowNewWinding(funName, span, winding);
+    debugShowNewWinding(funName, *span, winding);
 #endif
-    SkASSERT(span.fWindSum == SK_MinS32 || span.fWindSum == winding);
+    SkASSERT(span->fWindSum == SK_MinS32 || span->fWindSum == winding);
 #if DEBUG_LIMIT_WIND_SUM
     SkASSERT(abs(winding) <= DEBUG_LIMIT_WIND_SUM);
 #endif
-    span.fWindSum = winding;
-    return &span;
+    span->fWindSum = winding;
+    return true;
 }
 
-SkOpSpan* SkOpSegment::markOneWinding(const char* funName, int tIndex, int winding,
-                                      int oppWinding) {
-    SkOpSpan& span = fTs[tIndex];
-    if (span.fDone && !span.fSmall) {
-        return NULL;
+bool SkOpSegment::markOneWinding(const char* funName, int tIndex, int winding,
+        int oppWinding, SkOpSpan** lastPtr) {
+    SkOpSpan* span = &fTs[tIndex];
+    if (span->fDone && !span->fSmall) {
+        return false;
     }
 #if DEBUG_MARK_DONE
-    debugShowNewWinding(funName, span, winding, oppWinding);
+    debugShowNewWinding(funName, *span, winding, oppWinding);
 #endif
-    SkASSERT(span.fWindSum == SK_MinS32 || span.fWindSum == winding);
+    SkASSERT(span->fWindSum == SK_MinS32 || span->fWindSum == winding);
 #if DEBUG_LIMIT_WIND_SUM
     SkASSERT(abs(winding) <= DEBUG_LIMIT_WIND_SUM);
 #endif
-    span.fWindSum = winding;
-    SkASSERT(span.fOppSum == SK_MinS32 || span.fOppSum == oppWinding);
+    span->fWindSum = winding;
+    SkASSERT(span->fOppSum == SK_MinS32 || span->fOppSum == oppWinding);
 #if DEBUG_LIMIT_WIND_SUM
     SkASSERT(abs(oppWinding) <= DEBUG_LIMIT_WIND_SUM);
 #endif
-    span.fOppSum = oppWinding;
+    span->fOppSum = oppWinding;
     debugValidate();
-    return &span;
+    if (lastPtr) {
+        *lastPtr = span;
+    }
+    return true;
 }
 
 // from http://stackoverflow.com/questions/1165647/how-to-determine-if-a-list-of-polygon-points-are-in-clockwise-order
 bool SkOpSegment::clockwise(int tStart, int tEnd, bool* swap) const {
     SkASSERT(fVerb != SkPath::kLine_Verb);
     SkPoint edge[4];
     subDivide(tStart, tEnd, edge);
     int points = SkPathOpsVerbToPoints(fVerb);
     double sum = (edge[0].fX - edge[points].fX) * (edge[0].fY + edge[points].fY);
     bool sumSet = false;
@@ skipping 103 matching lines @@
     debugShowNewWinding(funName, span, span.fWindSum);
 #endif
 // If the prior angle in the sort is unorderable, the winding sum may not be computable.
 // To enable the assert, the 'prior is unorderable' state could be
 // piped down to this test, but not sure it's worth it.
 // (Once the sort order is stored in the span, this test may be feasible.)
 //    SkASSERT(span.fWindSum != SK_MinS32);
     return &span;
 }
 
-void SkOpSegment::markWinding(int index, int winding) {
+bool SkOpSegment::markWinding(int index, int winding) {
 //    SkASSERT(!done());
     SkASSERT(winding);
     double referenceT = fTs[index].fT;
     int lesser = index;
+    bool success = false;
     while (--lesser >= 0 && precisely_negative(referenceT - fTs[lesser].fT)) {
-        markOneWinding(__FUNCTION__, lesser, winding);
+        success |= markOneWinding(__FUNCTION__, lesser, winding, NULL);
     }
     do {
-        markOneWinding(__FUNCTION__, index, winding);
+        success |= markOneWinding(__FUNCTION__, index, winding, NULL);
    } while (++index < fTs.count() && precisely_negative(fTs[index].fT - referenceT));
     debugValidate();
+    return success;
 }
 
-void SkOpSegment::markWinding(int index, int winding, int oppWinding) {
+bool SkOpSegment::markWinding(int index, int winding, int oppWinding) {
 //    SkASSERT(!done());
     SkASSERT(winding || oppWinding);
     double referenceT = fTs[index].fT;
     int lesser = index;
+    bool success = false;
     while (--lesser >= 0 && precisely_negative(referenceT - fTs[lesser].fT)) {
-        markOneWinding(__FUNCTION__, lesser, winding, oppWinding);
+        success |= markOneWinding(__FUNCTION__, lesser, winding, oppWinding, NULL);
     }
     do {
-        markOneWinding(__FUNCTION__, index, winding, oppWinding);
+        success |= markOneWinding(__FUNCTION__, index, winding, oppWinding, NULL);
    } while (++index < fTs.count() && precisely_negative(fTs[index].fT - referenceT));
     debugValidate();
+    return success;
 }
 
 void SkOpSegment::matchWindingValue(int tIndex, double t, bool borrowWind) {
     int nextDoorWind = SK_MaxS32;
     int nextOppWind = SK_MaxS32;
     // prefer exact matches
     if (tIndex > 0) {
         const SkOpSpan& below = fTs[tIndex - 1];
         if (below.fT == t) {
             nextDoorWind = below.fWindValue;
@@ skipping 42 matching lines @@
         if (fTs[*end].fT == 1) {
             return false;
         }
         ++(*end);
     }
     *start = *end;
     *end = nextExactSpan(*start, 1);
     return true;
 }
 
-static SkOpSegment* set_last(SkOpSpan** last, SkOpSpan* endSpan) {
+static SkOpSegment* set_last(SkOpSpan** last, const SkOpSpan* endSpan) {
     if (last && !endSpan->fSmall) {
-        *last = endSpan;
+        *last = const_cast<SkOpSpan*>(endSpan);  // FIXME: get rid of cast
     }
     return NULL;
 }
 
-SkOpSegment* SkOpSegment::nextChase(int* indexPtr, int* stepPtr, int* minPtr, SkOpSpan** last) {
+SkOpSegment* SkOpSegment::nextChase(int* indexPtr, int* stepPtr, int* minPtr,
+        SkOpSpan** last) const {
     int origIndex = *indexPtr;
     int step = *stepPtr;
     int end = nextExactSpan(origIndex, step);
     SkASSERT(end >= 0);
-    SkOpSpan& endSpan = fTs[end];
+    const SkOpSpan& endSpan = this->span(end);
     SkOpAngle* angle = step > 0 ? endSpan.fFromAngle : endSpan.fToAngle;
     int foundIndex;
     int otherEnd;
     SkOpSegment* other;
     if (angle == NULL) {
         if (endSpan.fT != 0 && endSpan.fT != 1) {
             return NULL;
         }
         other = endSpan.fOther;
         foundIndex = endSpan.fOtherIndex;
@@ skipping 505 matching lines @@
     SkASSERT(span->fWindValue > 0 || span->fOppValue != 0);
     span->fWindValue = 0;
     span->fOppValue = 0;
     if (span->fTiny || span->fSmall) {
         return;
     }
     SkASSERT(!span->fDone);
     span->fDone = true;
     ++fDoneSpans;
 }