fix fuzzer bug

src/pathops/SkOpCoincidence.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "SkOpCoincidence.h"
 #include "SkOpSegment.h"
 #include "SkPathOpsTSect.h"
 
@@ skipping 250 matching lines @@
     DebugCheckAdd(fTop, coinPtTStart, coinPtTEnd, oppPtTStart, oppPtTEnd);
     SkCoincidentSpans* coinRec = SkOpTAllocator<SkCoincidentSpans>::Allocate(
             this->globalState()->allocator());
     coinRec->init();
     coinRec->set(this->fHead, coinPtTStart, coinPtTEnd, oppPtTStart, oppPtTEnd
             SkDEBUGPARAMS(fGlobalState->nextCoinID()));
     fHead = coinRec;
 }
 
 // description below
-void SkOpCoincidence::addEndMovedSpans(const SkOpSpan* base, const SkOpSpanBase* testSpan) {
+bool SkOpCoincidence::addEndMovedSpans(const SkOpSpan* base, const SkOpSpanBase* testSpan) {
     const SkOpPtT* testPtT = testSpan->ptT();
     const SkOpPtT* stopPtT = testPtT;
     const SkOpSegment* baseSeg = base->segment();
     while ((testPtT = testPtT->next()) != stopPtT) {
         const SkOpSegment* testSeg = testPtT->segment();
         if (testPtT->deleted()) {
             continue;
         }
         if (testSeg == baseSeg) {
             continue;
@@ skipping 35 matching lines @@
                 SkTSwap(coinSeg, oppSeg);
                 coinTs = oppStart->fT;
                 coinTe = testPtT->fT;
                 oppTs = base->t();
                 oppTe = testSpan->t();
             }
             if (coinTs > coinTe) {
                 SkTSwap(coinTs, coinTe);
                 SkTSwap(oppTs, oppTe);
             }
-            (void) this->addOrOverlap(coinSeg, oppSeg, coinTs, coinTe, oppTs, oppTe);
+            if (!this->addOrOverlap(coinSeg, oppSeg, coinTs, coinTe, oppTs, oppTe)) {
+                return false;
+            }
         }
     }
+    return true;
 }
 
 // description below
 bool SkOpCoincidence::addEndMovedSpans(const SkOpPtT* ptT) {
     const SkOpSpan* base = ptT->span()->upCast();
     const SkOpSpan* prev = base->prev();
     if (!prev) {
         return false;
     }
     if (!prev->isCanceled()) {
-        this->addEndMovedSpans(base, base->prev());
+        if (!this->addEndMovedSpans(base, base->prev())) {
+            return false;
+        }
     }
     if (!base->isCanceled()) {
-        this->addEndMovedSpans(base, base->next());
+        if (!this->addEndMovedSpans(base, base->next())) {
+            return false;
+        }
     }
     return true;
 }
 
 /*  If A is coincident with B and B includes an endpoint, and A's matching point
     is not the endpoint (i.e., there's an implied line connecting B-end and A)
     then assume that the same implied line may intersect another curve close to B.
     Since we only care about coincidence that was undetected, look at the
     ptT list on B-segment adjacent to the B-end/A ptT loop (not in the loop, but
     next door) and see if the A matching point is close enough to form another
@@ skipping 270 matching lines @@
         }
         if (!fHead || !this->release(fHead, test)) {
             SkAssertResult(this->release(fTop, test));
         }
     }
     const SkOpPtT* cs = coinSeg->existing(coinTs, oppSeg);
     const SkOpPtT* ce = coinSeg->existing(coinTe, oppSeg);
     if (overlap && cs && ce && overlap->contains(cs, ce)) {
         return false;
     }
-    SkASSERT(cs != ce || !cs);
+    if (cs == ce && cs) {
+        return false;
+    }
     const SkOpPtT* os = oppSeg->existing(oppTs, coinSeg);
     const SkOpPtT* oe = oppSeg->existing(oppTe, coinSeg);
     if (overlap && os && oe && overlap->contains(os, oe)) {
         return false;
     }
     SkASSERT(!cs || !cs->deleted());
     SkASSERT(!os || !os->deleted());
     SkASSERT(!ce || !ce->deleted());
     SkASSERT(!oe || !oe->deleted());
     const SkOpPtT* csExisting = !cs ? coinSeg->existing(coinTs, nullptr) : nullptr;
@@ skipping 794 matching lines @@
             this->release(fHead, coin);
         }
     } while ((coin = coin->next()));
 }
 
 bool SkOpCoincidence::testForCoincidence(const SkCoincidentSpans* outer, const SkOpPtT* testS,
         const SkOpPtT* testE) const {
     return testS->segment()->testForCoincidence(testS, testE, testS->span(),
             testE->span(), outer->coinPtTStart()->segment());
 }