fail early if coincidence can't be resolved

src/pathops/SkOpContour.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 "SkIntersections.h"
 #include "SkOpContour.h"
 #include "SkPathWriter.h"
 #include "SkTSort.h"
@@ skipping 249 matching lines @@
 bool SkOpContour::calcAngles() {
     int segmentCount = fSegments.count();
     for (int test = 0; test < segmentCount; ++test) {
         if (!fSegments[test].calcAngles()) {
             return false;
         }
     }
     return true;
 }
 
-void SkOpContour::calcCoincidentWinding() {
+bool SkOpContour::calcCoincidentWinding() {
     int count = fCoincidences.count();
 #if DEBUG_CONCIDENT
     if (count > 0) {
         SkDebugf("%s count=%d\n", __FUNCTION__, count);
     }
 #endif
     for (int index = 0; index < count; ++index) {
         SkCoincidence& coincidence = fCoincidences[index];
-         calcCommonCoincidentWinding(coincidence);
+        if (!calcCommonCoincidentWinding(coincidence)) {
+            return false;
+        }
     }
+    return true;
 }
 
 void SkOpContour::calcPartialCoincidentWinding() {
     int count = fPartialCoincidences.count();
 #if DEBUG_CONCIDENT
     if (count > 0) {
         SkDebugf("%s count=%d\n", __FUNCTION__, count);
     }
 #endif
     for (int index = 0; index < count; ++index) {
@@ skipping 173 matching lines @@
                 SkTSwap(missingPt1, missingPt2);
             }
             addTo1->addTCancel(missingPt1, missingPt2, addOther1);
         } else {
             if (addTo2->reversePoints(missingPt1, missingPt2)) {
                 SkTSwap(missingPt1, missingPt2);
             }
             addTo2->addTCancel(missingPt1, missingPt2, addOther2);
         }
     } else if (missingT1 >= 0) {
-        addTo1->addTCoincident(missingPt1, missingPt2, addTo1 == addTo2 ? missingT2 : otherT2,
-                addOther1);
+        SkAssertResult(addTo1->addTCoincident(missingPt1, missingPt2,
+                addTo1 == addTo2 ? missingT2 : otherT2, addOther1));
     } else {
-        addTo2->addTCoincident(missingPt2, missingPt1, addTo2 == addTo1 ? missingT1 : otherT1,
-                addOther2);
+        SkAssertResult(addTo2->addTCoincident(missingPt2, missingPt1,
+                addTo2 == addTo1 ? missingT1 : otherT1, addOther2));
     }
 }
 
 void SkOpContour::joinCoincidence(const SkTArray<SkCoincidence, true>& coincidences, bool partial) {
     int count = coincidences.count();
 #if DEBUG_CONCIDENT
     if (count > 0) {
         SkDebugf("%s count=%d\n", __FUNCTION__, count);
     }
 #endif
@@ skipping 47 matching lines @@
         double oMatchEnd = cancel ? oStartT : oEndT;
         if (partial ? endT != 1 || oMatchEnd != 1 : (endT == 1) != (oMatchEnd == 1)) {
             bool added = false;
             if (cancel && endT != 1 && !added) {
                 (void) other.joinCoincidence(&thisOne, endT, *endPt, -step, cancel);
             }
         }
     }
 }
 
-void SkOpContour::calcCommonCoincidentWinding(const SkCoincidence& coincidence) {
+bool SkOpContour::calcCommonCoincidentWinding(const SkCoincidence& coincidence) {
     if (coincidence.fNearly[0] && coincidence.fNearly[1]) {
-        return;
+        return true;
     }
     int thisIndex = coincidence.fSegments[0];
     SkOpSegment& thisOne = fSegments[thisIndex];
     if (thisOne.done()) {
-        return;
+        return true;
     }
     SkOpContour* otherContour = coincidence.fOther;
     int otherIndex = coincidence.fSegments[1];
     SkOpSegment& other = otherContour->fSegments[otherIndex];
     if (other.done()) {
-        return;
+        return true;
     }
     double startT = coincidence.fTs[0][0];
     double endT = coincidence.fTs[0][1];
     const SkPoint* startPt = &coincidence.fPts[0][0];
     const SkPoint* endPt = &coincidence.fPts[0][1];
     bool cancelers;
     if ((cancelers = startT > endT)) {
         SkTSwap<double>(startT, endT);
         SkTSwap<const SkPoint*>(startPt, endPt);
     }
     bump_out_close_span(&startT, &endT);
     SkASSERT(!approximately_negative(endT - startT));
     double oStartT = coincidence.fTs[1][0];
     double oEndT = coincidence.fTs[1][1];
     if (oStartT > oEndT) {
         SkTSwap<double>(oStartT, oEndT);
         cancelers ^= true;
     }
     bump_out_close_span(&oStartT, &oEndT);
     SkASSERT(!approximately_negative(oEndT - oStartT));
+    bool success = true;
     if (cancelers) {
         thisOne.addTCancel(*startPt, *endPt, &other);
     } else {
-        thisOne.addTCoincident(*startPt, *endPt, endT, &other);
+        success = thisOne.addTCoincident(*startPt, *endPt, endT, &other);
     }
 #if DEBUG_CONCIDENT
     thisOne.debugShowTs("p");
     other.debugShowTs("o");
 #endif
+    return success;
 }
 
 void SkOpContour::resolveNearCoincidence() {
     int count = fCoincidences.count();
     for (int index = 0; index < count; ++index) {
         SkCoincidence& coincidence = fCoincidences[index];
         if (!coincidence.fNearly[0] || !coincidence.fNearly[1]) {
             continue;
         }
         int thisIndex = coincidence.fSegments[0];
@@ skipping 149 matching lines @@
         SkDebugf("%s empty contour\n", __FUNCTION__);
         SkASSERT(0);
         // FIXME: delete empty contour?
         return;
     }
     fBounds = fSegments.front().bounds();
     for (int index = 1; index < count; ++index) {
         fBounds.add(fSegments[index].bounds());
     }
 }