fix pathops fuzzers

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 533 matching lines @@
 double SkOpCoincidence::TRange(const SkOpPtT* overS, double t,
        const SkOpSegment* coinSeg  SkDEBUGPARAMS(const SkOpPtT* overE)) {
     const SkOpSpanBase* work = overS->span();
     const SkOpPtT* foundStart = nullptr;
     const SkOpPtT* foundEnd = nullptr;
     const SkOpPtT* coinStart = nullptr;
     const SkOpPtT* coinEnd = nullptr;
     do {
         const SkOpPtT* contained = work->contains(coinSeg);
         if (!contained) {
+            if (work->t() >= t) {
+                return 1;
+            }
             continue;
         }
         if (work->t() <= t) {
             coinStart = contained;
             foundStart = work->ptT();
         }
         if (work->t() >= t) {
             coinEnd = contained;
             foundEnd = work->ptT();
             break;
@@ skipping 224 matching lines @@
     fHead = nullptr;
     do {
     // addifmissing can modify the list that this is walking
     // save head so that walker can iterate over old data unperturbed
     // addifmissing adds to head freely then add saved head in the end
         const SkOpPtT* ocs = outer->coinPtTStart();
         SkASSERT(!ocs->deleted());
         const SkOpSegment* outerCoin = ocs->segment();
         SkASSERT(!outerCoin->done());  // if it's done, should have already been removed from list
         const SkOpPtT* oos = outer->oppPtTStart();
-        SkASSERT(!oos->deleted());
+        if (oos->deleted()) {
+            return false;
+        }
         const SkOpSegment* outerOpp = oos->segment();
         SkASSERT(!outerOpp->done());
         SkOpSegment* outerCoinWritable = const_cast<SkOpSegment*>(outerCoin);
         SkOpSegment* outerOppWritable = const_cast<SkOpSegment*>(outerOpp);
         SkCoincidentSpans* inner = outer;
         while ((inner = inner->next())) {
             this->debugValidate();
             double overS, overE;
             const SkOpPtT* ics = inner->coinPtTStart();
             SkASSERT(!ics->deleted());
             const SkOpSegment* innerCoin = ics->segment();
             SkASSERT(!innerCoin->done());
             const SkOpPtT* ios = inner->oppPtTStart();
             SkASSERT(!ios->deleted());
             const SkOpSegment* innerOpp = ios->segment();
             SkASSERT(!innerOpp->done());
             SkOpSegment* innerCoinWritable = const_cast<SkOpSegment*>(innerCoin);
             SkOpSegment* innerOppWritable = const_cast<SkOpSegment*>(innerOpp);
             if (outerCoin == innerCoin) {
                 const SkOpPtT* oce = outer->coinPtTEnd();
-                SkASSERT(!oce->deleted());
+                if (oce->deleted()) {
+                    return false;
+                }
                 const SkOpPtT* ice = inner->coinPtTEnd();
                 SkASSERT(!ice->deleted());
                 if (outerOpp != innerOpp && this->overlap(ocs, oce, ics, ice, &overS, &overE)) {
                     added |= this->addIfMissing(ocs->starter(oce), ics->starter(ice),
                             overS, overE, outerOppWritable, innerOppWritable
                             SkDEBUGPARAMS(ocs->debugEnder(oce))
                             SkDEBUGPARAMS(ics->debugEnder(ice)));
                 }
             } else if (outerCoin == innerOpp) {
                 const SkOpPtT* oce = outer->coinPtTEnd();
@@ skipping 15 matching lines @@
                 if (this->overlap(oos, ooe, ics, ice, &overS, &overE)) {
                     added |= this->addIfMissing(oos->starter(ooe), ics->starter(ice),
                             overS, overE, outerCoinWritable, innerOppWritable
                             SkDEBUGPARAMS(oos->debugEnder(ooe))
                             SkDEBUGPARAMS(ics->debugEnder(ice)));
                 }
             } else if (outerOpp == innerOpp) {
                 const SkOpPtT* ooe = outer->oppPtTEnd();
                 SkASSERT(!ooe->deleted());
                 const SkOpPtT* ioe = inner->oppPtTEnd();
-                SkASSERT(!ioe->deleted());
+                if (ioe->deleted()) {
+                    return false;
+                }
                 SkASSERT(outerCoin != innerCoin);
                 if (this->overlap(oos, ooe, ios, ioe, &overS, &overE)) {
                     added |= this->addIfMissing(oos->starter(ooe), ios->starter(ioe),
                             overS, overE, outerCoinWritable, innerCoinWritable
                             SkDEBUGPARAMS(oos->debugEnder(ooe))
                             SkDEBUGPARAMS(ios->debugEnder(ioe)));
                 }
             }
             this->debugValidate();
         }
@@ skipping 521 matching lines @@
         if (coin->oppPtTStart()->collapsed(coin->oppPtTEnd())) {
             *priorPtr = coin->next();
             continue;
         }
         priorPtr = coin->nextPtr();
     } while ((coin = coin->next()));
     return true;
 }
 
 void SkOpCoincidence::fixUp(SkOpPtT* deleted, const SkOpPtT* kept) {
-    SkASSERT(deleted != kept);
+    SkOPASSERT(deleted != kept);
     if (fHead) {
         this->fixUp(fHead, deleted, kept);
     }
     if (fTop) {
         this->fixUp(fTop, deleted, kept);
     }
 }
 
 void SkOpCoincidence::fixUp(SkCoincidentSpans* coin, SkOpPtT* deleted, const SkOpPtT* kept) {
     SkCoincidentSpans* head = coin;
@@ skipping 38 matching lines @@
     }
     do {
         if (!coin->coinPtTStartWritable()->span()->upCastable()) {
             return false;
         }
         SkOpSpan* start = coin->coinPtTStartWritable()->span()->upCast();
         SkASSERT(!start->deleted());
         SkOpSpanBase* end = coin->coinPtTEndWritable()->span();
         SkASSERT(!end->deleted());
         SkOpSpanBase* oStart = coin->oppPtTStartWritable()->span();
-        SkASSERT(!oStart->deleted());
+        if (oStart->deleted()) {
+            return false;
+        }
         SkOpSpanBase* oEnd = coin->oppPtTEndWritable()->span();
         SkASSERT(!oEnd->deleted());
         bool flipped = coin->flipped();
         if (flipped) {
             SkTSwap(oStart, oEnd);
         }
         /* coin and opp spans may not match up. Mark the ends, and then let the interior
            get marked as many times as the spans allow */
         start->insertCoincidence(oStart->upCast());
         end->insertCoinEnd(oEnd);
@@ skipping 89 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());
 }