fix bugs found by computing flat clips in 800K skps

src/pathops/SkPathOpsDebug.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkPathOpsDebug.h"
 #include "SkPath.h"
 
@@ skipping 86 matching lines @@
 }
 #endif
 
 #endif //  defined SK_DEBUG || !FORCE_RELEASE
 
 #include "SkOpAngle.h"
 #include "SkOpSegment.h"
 
 #if DEBUG_SORT
 void SkOpAngle::debugLoop() const {
-    const SkOpAngle* first = this;
-    const SkOpAngle* next = this;
-    do {
-        next->debugOne(true);
-        SkDebugf("\n");
-        next = next->fNext;
-    } while (next && next != first);
-}
-
-void SkOpAngle::debugOne(bool functionHeader) const {
-//    fSegment->debugValidate();
-    const SkOpSpan& mSpan = fSegment->span(SkMin32(fStart, fEnd));
-    if (functionHeader) {
-        SkDebugf("%s ", __FUNCTION__);
-    }
-    SkDebugf("[%d", fSegment->debugID());
-#if DEBUG_ANGLE
-    SkDebugf("/%d", fID);
-#endif
-    SkDebugf("] next=");
-    if (fNext) {
-        SkDebugf("%d", fNext->fSegment->debugID());
-#if DEBUG_ANGLE
-        SkDebugf("/%d", fNext->fID);
-#endif
-    } else {
-        SkDebugf("?");
-    }
-    SkDebugf(" sect=%d/%d ", fSectorStart, fSectorEnd);
-    SkDebugf(" s=%1.9g [%d] e=%1.9g [%d]", fSegment->span(fStart).fT, fStart,
-            fSegment->span(fEnd).fT, fEnd);
-    SkDebugf(" sgn=%d windVal=%d", sign(), mSpan.fWindValue);
-
-#if DEBUG_WINDING
-    SkDebugf(" windSum=");
-    SkPathOpsDebug::WindingPrintf(mSpan.fWindSum);
-#endif
-    if (mSpan.fOppValue != 0 || mSpan.fOppSum != SK_MinS32) {
-        SkDebugf(" oppVal=%d", mSpan.fOppValue);
-#if DEBUG_WINDING
-        SkDebugf(" oppSum=");
-        SkPathOpsDebug::WindingPrintf(mSpan.fOppSum);
-#endif
-    }
-    if (mSpan.fDone) {
-        SkDebugf(" done");
-    }
-    if (unorderable()) {
-        SkDebugf(" unorderable");
-    }
-    if (small()) {
-        SkDebugf(" small");
-    }
-    if (mSpan.fTiny) {
-        SkDebugf(" tiny");
-    }
-    if (fSegment->operand()) {
-        SkDebugf(" operand");
-    }
-    if (fStop) {
-        SkDebugf(" stop");
-    }
+    dumpLoop();
 }
 #endif
 
 #if DEBUG_ANGLE
 void SkOpAngle::debugSameAs(const SkOpAngle* compare) const {
     SK_ALWAYSBREAK(fSegment == compare->fSegment);
     const SkOpSpan& startSpan = fSegment->span(fStart);
     const SkOpSpan& oStartSpan = fSegment->span(compare->fStart);
-    SK_ALWAYSBREAK(startSpan.fToAngleIndex == oStartSpan.fToAngleIndex);
-    SK_ALWAYSBREAK(startSpan.fFromAngleIndex == oStartSpan.fFromAngleIndex);
+    SK_ALWAYSBREAK(startSpan.fToAngle == oStartSpan.fToAngle);
+    SK_ALWAYSBREAK(startSpan.fFromAngle == oStartSpan.fFromAngle);
     const SkOpSpan& endSpan = fSegment->span(fEnd);
     const SkOpSpan& oEndSpan = fSegment->span(compare->fEnd);
-    SK_ALWAYSBREAK(endSpan.fToAngleIndex == oEndSpan.fToAngleIndex);
-    SK_ALWAYSBREAK(endSpan.fFromAngleIndex == oEndSpan.fFromAngleIndex);
+    SK_ALWAYSBREAK(endSpan.fToAngle == oEndSpan.fToAngle);
+    SK_ALWAYSBREAK(endSpan.fFromAngle == oEndSpan.fFromAngle);
 }
 #endif
 
 #if DEBUG_VALIDATE
 void SkOpAngle::debugValidateNext() const {
     const SkOpAngle* first = this;
     const SkOpAngle* next = first;
     SkTDArray<const SkOpAngle*>(angles);
     do {
-        SK_ALWAYSBREAK(next->fSegment->debugContains(next));
+//        SK_ALWAYSBREAK(next->fSegment->debugContains(next));
         angles.push(next);
         next = next->next();
         if (next == first) {
             break;
         }
         SK_ALWAYSBREAK(!angles.contains(next));
         if (!next) {
             return;
         }
     } while (true);
@@ skipping 167 matching lines @@
 #if DEBUG_ANGLE
 void SkOpSegment::debugCheckPointsEqualish(int tStart, int tEnd) const {
     const SkPoint& basePt = fTs[tStart].fPt;
     while (++tStart < tEnd) {
        const SkPoint& cmpPt = fTs[tStart].fPt;
        SK_ALWAYSBREAK(SkDPoint::ApproximatelyEqual(basePt, cmpPt));
     }
 }
 #endif
 
-#if DEBUG_VALIDATE
-bool SkOpSegment::debugContains(const SkOpAngle* angle) const {
-    for (int index = 0; index < fAngles.count(); ++index) {
-        if (&fAngles[index] == angle) {
-            return true;
-        }
-    }
-    for (int index = 0; index < fSingletonAngles.count(); ++index) {
-        if (&fSingletonAngles[index] == angle) {
-            return true;
-        }
-    }
-    return false;
-}
-#endif
-
 #if DEBUG_SWAP_TOP
 int SkOpSegment::debugInflections(int tStart, int tEnd) const {
     if (fVerb != SkPath::kCubic_Verb) {
         return false;
     }
     SkDCubic dst = SkDCubic::SubDivide(fPts, fTs[tStart].fT, fTs[tEnd].fT);
     double inflections[2];
     return dst.findInflections(inflections);
 }
 #endif
 
+const SkOpAngle* SkOpSegment::debugLastAngle() const {
+    const SkOpAngle* result = NULL;
+    for (int index = 0; index < count(); ++index) {
+        const SkOpSpan& span = this->span(index);
+        if (span.fToAngle) {
+            SkASSERT(!result);
+            result = span.fToAngle;
+        }
+    }
+    SkASSERT(result);
+    return result;
+}
+
 void SkOpSegment::debugReset() {
     fTs.reset();
     fAngles.reset();
 }
 
 #if DEBUG_CONCIDENT
 void SkOpSegment::debugShowTs(const char* prefix) const {
     SkDebugf("%s %s id=%d", __FUNCTION__, prefix, fID);
     int lastWind = -1;
     int lastOpp = -1;
@@ skipping 115 matching lines @@
         SkDebugf("?");
     } else {
         SkDebugf("%d", span.fOppSum);
     }
     SkDebugf(" windSum=");
     if (span.fWindSum == SK_MinS32) {
         SkDebugf("?");
     } else {
         SkDebugf("%d", span.fWindSum);
     }
-    SkDebugf(" windValue=%d\n", span.fWindValue);
+    SkDebugf(" windValue=%d oppValue=%d\n", span.fWindValue, span.fOppValue);
 }
 #endif
 
 #if DEBUG_SHOW_WINDING
 int SkOpSegment::debugShowWindingValues(int slotCount, int ofInterest) const {
     if (!(1 << fID & ofInterest)) {
         return 0;
     }
     int sum = 0;
     SkTArray<char, true> slots(slotCount * 2);
@@ skipping 30 matching lines @@
         t = span.fT;
         int otherIndex = span.fOtherIndex;
         const SkOpSegment* other = span.fOther;
         SK_ALWAYSBREAK(other != this || fVerb == SkPath::kCubic_Verb);
         const SkOpSpan& otherSpan = other->fTs[otherIndex];
         SK_ALWAYSBREAK(otherSpan.fPt == span.fPt);
         SK_ALWAYSBREAK(otherSpan.fOtherT == t);
         SK_ALWAYSBREAK(&fTs[i] == &otherSpan.fOther->fTs[otherSpan.fOtherIndex]);
         done += span.fDone;
         if (last) {
+            SK_ALWAYSBREAK(last->fT != span.fT || last->fOther != span.fOther);
             bool tsEqual = last->fT == span.fT;
             bool tsPreciselyEqual = precisely_equal(last->fT, span.fT);
             SK_ALWAYSBREAK(!tsEqual || tsPreciselyEqual);
             bool pointsEqual = last->fPt == span.fPt;
             bool pointsNearlyEqual = AlmostEqualUlps(last->fPt, span.fPt);
 #if 0  // bufferOverflow test triggers this
             SK_ALWAYSBREAK(!tsPreciselyEqual || pointsNearlyEqual);
 #endif
 //            SK_ALWAYSBREAK(!last->fTiny || !tsPreciselyEqual || span.fTiny || tinyTFound);
             SK_ALWAYSBREAK(last->fTiny || tsPreciselyEqual || !pointsEqual || hasLoop);
             SK_ALWAYSBREAK(!last->fTiny || pointsEqual);
             SK_ALWAYSBREAK(!last->fTiny || last->fDone);
             SK_ALWAYSBREAK(!last->fSmall || pointsNearlyEqual);
             SK_ALWAYSBREAK(!last->fSmall || last->fDone);
 //            SK_ALWAYSBREAK(!last->fSmall || last->fTiny);
 //            SK_ALWAYSBREAK(last->fTiny || !pointsEqual || last->fDone == span.fDone);
             if (last->fTiny) {
                 tinyTFound |= !tsPreciselyEqual;
             } else {
                 tinyTFound = false;
             }
         }
         last = &span;
         hasLoop |= last->fLoop;
     }
     SK_ALWAYSBREAK(done == fDoneSpans);
-    if (fAngles.count() ) {
-        fAngles.begin()->debugValidateLoop();
-    }
+//    if (fAngles.count() ) {
+//        fAngles.begin()->debugValidateLoop();
+//    }
 #endif
 }