fail on extremely large coincident curves

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 1193 matching lines @@
     int oWindValue = oTest.fWindValue;
     int oOppValue = oTest.fOppValue;
     if (binary) {
         SkTSwap<int>(oWindValue, oOppValue);
     }
     do {
         (void) bumpSpan(&fTs[index], oWindValue, oOppValue);
     } while (++index < endIndex);
 }
 
-void SkOpSegment::bumpCoincidentThis(const SkOpSpan& oTest, bool binary, int* indexPtr,
+bool SkOpSegment::bumpCoincidentThis(const SkOpSpan& oTest, bool binary, int* indexPtr,
         SkTArray<SkPoint, true>* outsideTs) {
     int index = *indexPtr;
     int oWindValue = oTest.fWindValue;
     int oOppValue = oTest.fOppValue;
     if (binary) {
         SkTSwap<int>(oWindValue, oOppValue);
     }
     SkOpSpan* const test = &fTs[index];
     SkOpSpan* end = test;
     const SkPoint& oStartPt = oTest.fPt;
     do {
+        if (end->fDone && !end->fTiny && !end->fSmall) {  // extremely large paths trigger this
+            return false;
+        }
         if (bumpSpan(end, oWindValue, oOppValue)) {
             TrackOutside(outsideTs, oStartPt);
         }
         end = &fTs[++index];
     } while ((end->fPt == test->fPt || precisely_equal(end->fT, test->fT)) && end->fT < 1);
     *indexPtr = index;
+    return true;
 }
 
 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
@@ skipping 80 matching lines @@
             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) {
-                bumpCoincidentThis(*oTest, binary, &index, &outsidePts);
+                if (!bumpCoincidentThis(*oTest, binary, &index, &outsidePts)) {
+                    return false;
+                }
                 other->bumpCoincidentOther(*test, &oIndex, &oOutsidePts);
             } else {
-                other->bumpCoincidentThis(*test, binary, &oIndex, &oOutsidePts);
+                if (!other->bumpCoincidentThis(*test, binary, &oIndex, &oOutsidePts)) {
+                    return false;
+                }
                 bumpCoincidentOther(*oTest, &index, &outsidePts);
             }
         }
         test = &fTs[index];
         testPt = &test->fPt;
         testT = test->fT;
         oTest = &other->fTs[oIndex];
         oTestPt = &oTest->fPt;
         if (endPt == *testPt || precisely_equal(endT, testT)) {
             break;
@@ skipping 43 matching lines @@
                     break;
                 }
                 oPeek = &other->fTs[oPeekIndex];
             } while (endPt == oPeek->fPt);
         }
         if (success) {
             do {
                 if (!binary || test->fWindValue + oTest->fOppValue >= 0) {
                     other->bumpCoincidentOther(*test, &oIndex, &oOutsidePts);
                 } else {
-                    other->bumpCoincidentThis(*test, binary, &oIndex, &oOutsidePts);
+                    if (!other->bumpCoincidentThis(*test, binary, &oIndex, &oOutsidePts)) {
+                        return false;
+                    }
                 }
                 oTest = &other->fTs[oIndex];
                 oTestPt = &oTest->fPt;
             } while (endPt != *oTestPt);
         }
     }
     int outCount = outsidePts.count();
     if (!done() && outCount) {
         addCoinOutsides(outsidePts[0], endPt, other);
     }
@@ skipping 3035 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;
 }