template intersection fuzz fixes

src/pathops/SkPathOpsTSect.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #ifndef SkPathOpsTSect_DEFINED
 #define SkPathOpsTSect_DEFINED
 
 #include "SkChunkAlloc.h"
@@ skipping 81 matching lines @@
     void debugInit() {
         TCurve dummy;
         dummy.debugInit();
         init(dummy);
         initBounds(dummy);
         fCoinStart.init();
         fCoinEnd.init();
     }
 
     const SkTSect<OppCurve, TCurve>* debugOpp() const;
+
+#ifdef SK_DEBUG
+    void debugSetGlobalState(SkOpGlobalState* state) {
+        fDebugGlobalState = state;
+    }
+#endif
+
     const SkTSpan* debugSpan(int ) const;
     const SkTSpan* debugT(double t) const;
 #ifdef SK_DEBUG
     bool debugIsBefore(const SkTSpan* span) const;
 #endif
     void dump() const;
     void dumpAll() const;
     void dumpBounded(int id) const;
     void dumpBounds() const;
     void dumpCoin() const;
 
     double endT() const {
         return fEndT;
     }
 
     SkTSpan<OppCurve, TCurve>* findOppSpan(const SkTSpan<OppCurve, TCurve>* opp) const;
 
     SkTSpan<OppCurve, TCurve>* findOppT(double t) const {
         SkTSpan<OppCurve, TCurve>* result = oppT(t);
-        SkASSERT(result);
+        SkOPASSERT(result);
         return result;
     }
 
+    SkDEBUGCODE(SkOpGlobalState* globalState() const { return fDebugGlobalState; })
+
     bool hasOppT(double t) const {
         return SkToBool(oppT(t));
     }
 
     int hullsIntersect(SkTSpan<OppCurve, TCurve>* span, bool* start, bool* oppStart);
     void init(const TCurve& );
     void initBounds(const TCurve& );
 
     bool isBounded() const {
         return fBounded != nullptr;
@@ skipping 66 matching lines @@
     SkTSpan* fNext;
     SkDRect fBounds;
     double fStartT;
     double fEndT;
     double fBoundsMax;
     SkOpDebugBool fCollapsed;
     SkOpDebugBool fHasPerp;
     SkOpDebugBool fIsLinear;
     SkOpDebugBool fIsLine;
     SkOpDebugBool fDeleted;
+    SkDEBUGCODE(SkOpGlobalState* fDebugGlobalState);
     SkDEBUGCODE_(SkTSect<TCurve, OppCurve>* fDebugSect);
     PATH_OPS_DEBUG_T_SECT_CODE(int fID);
     friend class SkTSect<TCurve, OppCurve>;
     friend class SkTSect<OppCurve, TCurve>;
     friend class SkTSpan<OppCurve, TCurve>;
 };
 
 template<typename TCurve, typename OppCurve>
 class SkTSect {
 public:
@@ skipping 26 matching lines @@
         kZeroS2Set = 4,
         kOneS2Set = 8
     };
 
     SkTSpan<TCurve, OppCurve>* addFollowing(SkTSpan<TCurve, OppCurve>* prior);
     void addForPerp(SkTSpan<OppCurve, TCurve>* span, double t);
     SkTSpan<TCurve, OppCurve>* addOne();
 
     SkTSpan<TCurve, OppCurve>* addSplitAt(SkTSpan<TCurve, OppCurve>* span, double t) {
         SkTSpan<TCurve, OppCurve>* result = this->addOne();
+        SkDEBUGCODE(result->debugSetGlobalState(this->globalState()));
         result->splitAt(span, t, &fHeap);
         result->initBounds(fCurve);
         span->initBounds(fCurve);
         return result;
     }
 
     bool binarySearchCoin(SkTSect<OppCurve, TCurve>* , double tStart, double tStep, double* t,
                           double* oppT);
     SkTSpan<TCurve, OppCurve>* boundsMax() const;
     void coincidentCheck(SkTSect<OppCurve, TCurve>* sect2);
@@ skipping 109 matching lines @@
             sizeof(SkTSpanBounded<OppCurve, TCurve>)))(SkTSpanBounded<OppCurve, TCurve>);
     bounded->fBounded = span;
     bounded->fNext = fBounded;
     fBounded = bounded;
 }
 
 template<typename TCurve, typename OppCurve>
 SkTSpan<TCurve, OppCurve>* SkTSect<TCurve, OppCurve>::addFollowing(
         SkTSpan<TCurve, OppCurve>* prior) {
     SkTSpan<TCurve, OppCurve>* result = this->addOne();
+    SkDEBUGCODE(result->debugSetGlobalState(this->globalState()));
     result->fStartT = prior ? prior->fEndT : 0;
     SkTSpan<TCurve, OppCurve>* next = prior ? prior->fNext : fHead;
     result->fEndT = next ? next->fStartT : 1;
     result->fPrev = prior;
     result->fNext = next;
     if (prior) {
         prior->fNext = result;
     } else {
         fHead = result;
     }
     if (next) {
         next->fPrev = result;
     }
     result->resetBounds(fCurve);
+    result->validate();
     return result;
 }
 
 template<typename TCurve, typename OppCurve>
 void SkTSect<TCurve, OppCurve>::addForPerp(SkTSpan<OppCurve, TCurve>* span, double t) {
     if (!span->hasOppT(t)) {
         SkTSpan<TCurve, OppCurve>* priorSpan;
         SkTSpan<TCurve, OppCurve>* opp = this->spanAtT(t, &priorSpan);
         if (!opp) {
             opp = this->addFollowing(priorSpan);
@@ skipping 313 matching lines @@
                 prev->fNext = boundedNext;
                 return false;
             } else {
                 fBounded = boundedNext;
                 return fBounded == nullptr;
             }
         }
         prev = bounded;
         bounded = boundedNext;
     }
-    SkASSERT(0);
+    SkOPASSERT(0);
     return false;
 }
 
 template<typename TCurve, typename OppCurve>
 bool SkTSpan<TCurve, OppCurve>::splitAt(SkTSpan* work, double t, SkChunkAlloc* heap) {
     fStartT = t;
     fEndT = work->fEndT;
     if (fStartT == fEndT) {
         fCollapsed = true;
         return false;
     }
     work->fEndT = t;
     if (work->fStartT == work->fEndT) {
         work->fCollapsed = true;
         return false;
     }
     fPrev = work;
     fNext = work->fNext;
     fIsLinear = work->fIsLinear;
     fIsLine = work->fIsLine;
 
     work->fNext = this;
     if (fNext) {
         fNext->fPrev = this;
     }
+    this->validate();
     SkTSpanBounded<OppCurve, TCurve>* bounded = work->fBounded;
     fBounded = nullptr;
     while (bounded) {
         this->addBounded(bounded->fBounded, heap);
         bounded = bounded->fNext;
     }
     bounded = fBounded;
     while (bounded) {
         bounded->fBounded->addBounded(this, heap);
         bounded = bounded->fNext;
     }
     return true;
 }
 
 template<typename TCurve, typename OppCurve>
 void SkTSpan<TCurve, OppCurve>::validate() const {
-#if DEBUG_T_SECT
+#if DEBUG_VALIDATE
+    SkASSERT(this != fPrev);
+    SkASSERT(this != fNext);
     SkASSERT(fNext == nullptr || fNext != fPrev);
     SkASSERT(fNext == nullptr || this == fNext->fPrev);
     SkASSERT(fPrev == nullptr || this == fPrev->fNext);
+    this->validateBounded();
+#endif
+#if DEBUG_T_SECT
     SkASSERT(fBounds.width() || fBounds.height() || fCollapsed);
     SkASSERT(fBoundsMax == SkTMax(fBounds.width(), fBounds.height()));
     SkASSERT(0 <= fStartT);
     SkASSERT(fEndT <= 1);
     SkASSERT(fStartT <= fEndT);
     SkASSERT(fBounded);
-    this->validateBounded();
     if (fHasPerp) {
         if (fCoinStart.isCoincident()) {
             validatePerpT(fCoinStart.perpT());
             validatePerpPt(fCoinStart.perpT(), fCoinStart.perpPt());
         }
         if (fCoinEnd.isCoincident()) {
             validatePerpT(fCoinEnd.perpT());
             validatePerpPt(fCoinEnd.perpT(), fCoinEnd.perpPt());
         }
     }
 #endif
 }
 
 template<typename TCurve, typename OppCurve>
 void SkTSpan<TCurve, OppCurve>::validateBounded() const {
 #if DEBUG_VALIDATE
     const SkTSpanBounded<OppCurve, TCurve>* testBounded = fBounded;
     while (testBounded) {
         SkDEBUGCODE_(const SkTSpan<OppCurve, TCurve>* overlap = testBounded->fBounded);
         SkASSERT(!overlap->fDeleted);
+#if DEBUG_T_SECT
         SkASSERT(((this->debugID() ^ overlap->debugID()) & 1) == 1);
         SkASSERT(overlap->findOppSpan(this));
+#endif
         testBounded = testBounded->fNext;
     }
 #endif
 }
 
 template<typename TCurve, typename OppCurve>
 void SkTSpan<TCurve, OppCurve>::validatePerpT(double oppT) const {
     const SkTSpanBounded<OppCurve, TCurve>* testBounded = fBounded;
     while (testBounded) {
         const SkTSpan<OppCurve, TCurve>* overlap = testBounded->fBounded;
@@ skipping 19 matching lines @@
     , fHeap(sizeof(SkTSpan<TCurve, OppCurve>) * 4)
     , fCoincident(nullptr)
     , fDeleted(nullptr)
     , fActiveCount(0)
     SkDEBUGPARAMS(fDebugGlobalState(debugGlobalState))
     PATH_OPS_DEBUG_T_SECT_PARAMS(fID(id))
     PATH_OPS_DEBUG_T_SECT_PARAMS(fDebugCount(0))
     PATH_OPS_DEBUG_T_SECT_PARAMS(fDebugAllocatedCount(0))
 {
     fHead = addOne();
+    SkDEBUGCODE(fHead->debugSetGlobalState(debugGlobalState));
     fHead->init(c);
 }
 
 template<typename TCurve, typename OppCurve>
 SkTSpan<TCurve, OppCurve>* SkTSect<TCurve, OppCurve>::addOne() {
     SkTSpan<TCurve, OppCurve>* result;
     if (fDeleted) {
         result = fDeleted;
         fDeleted = result->fNext;
     } else {
@@ skipping 118 matching lines @@
         this->validate();
         sect2->validate();
         // check to see if a range of points are on the curve
         SkTSpan<TCurve, OppCurve>* coinStart = first;
         do {
             coinStart = this->extractCoincident(sect2, coinStart, last);
         } while (coinStart && !last->fDeleted);
         if (!fHead || !sect2->fHead) {
             break;
         }
+        if (!next || next->fDeleted) {
+            break;
+        }
     } while ((first = next));
 }
 
 template<typename TCurve, typename OppCurve>
 void SkTSect<TCurve, OppCurve>::coincidentForce(SkTSect<OppCurve, TCurve>* sect2,
         double start1s, double start1e) {
     SkTSpan<TCurve, OppCurve>* first = fHead;
     SkTSpan<TCurve, OppCurve>* last = this->tail();
     SkTSpan<OppCurve, TCurve>* oppFirst = sect2->fHead;
     SkTSpan<OppCurve, TCurve>* oppLast = sect2->tail();
@@ skipping 143 matching lines @@
     if (!first) {
         return nullptr;
     }
     // march outwards to find limit of coincidence from here to previous and next spans
     double startT = first->fStartT;
     double oppStartT SK_INIT_TO_AVOID_WARNING;
     double oppEndT SK_INIT_TO_AVOID_WARNING;
     SkTSpan<TCurve, OppCurve>* prev = first->fPrev;
     SkASSERT(first->fCoinStart.isCoincident());
     SkTSpan<OppCurve, TCurve>* oppFirst = first->findOppT(first->fCoinStart.perpT());
-    SkASSERT(last->fCoinEnd.isCoincident());
+    SkOPASSERT(last->fCoinEnd.isCoincident());
     bool oppMatched = first->fCoinStart.perpT() < first->fCoinEnd.perpT();
     double coinStart;
     SkDEBUGCODE(double coinEnd);
     SkTSpan<OppCurve, TCurve>* cutFirst;
     if (prev && prev->fEndT == startT
             && this->binarySearchCoin(sect2, startT, prev->fStartT - startT, &coinStart,
                                       &oppStartT)
             && prev->fStartT < coinStart && coinStart < startT
             && (cutFirst = prev->oppT(oppStartT))) {
         oppFirst = cutFirst;
@@ skipping 10 matching lines @@
                 oppFirst->markCoincident();
                 oppHalf->fCoinStart.markCoincident();
             }
         }
     } else {
         SkDEBUGCODE(coinStart = first->fStartT);
         SkDEBUGCODE(oppStartT = oppMatched ? oppFirst->fStartT : oppFirst->fEndT);
     }
     // FIXME: incomplete : if we're not at the end, find end of coin
     SkTSpan<OppCurve, TCurve>* oppLast;
-    SkASSERT(last->fCoinEnd.isCoincident());
+    SkOPASSERT(last->fCoinEnd.isCoincident());
     oppLast = last->findOppT(last->fCoinEnd.perpT());
     SkDEBUGCODE(coinEnd = last->fEndT);
-    SkDEBUGCODE(oppEndT = oppMatched ? oppLast->fEndT : oppLast->fStartT);
+#ifdef SK_DEBUG
+    if (!this->globalState() || !this->globalState()->debugSkipAssert()) {
+        oppEndT = oppMatched ? oppLast->fEndT : oppLast->fStartT;
+    }
+#endif
     if (!oppMatched) {
         SkTSwap(oppFirst, oppLast);
         SkTSwap(oppStartT, oppEndT);
     }
     SkOPASSERT(oppStartT < oppEndT);
     SkASSERT(coinStart == first->fStartT);
     SkASSERT(coinEnd == last->fEndT);
-    SkASSERT(oppStartT == oppFirst->fStartT);
-    SkASSERT(oppEndT == oppLast->fEndT);
+    SkOPASSERT(oppStartT == oppFirst->fStartT);
+    SkOPASSERT(oppEndT == oppLast->fEndT);
+    if (!oppFirst) {
+        return nullptr;
+    }
     // reduce coincident runs to single entries
     this->validate();
     sect2->validate();
     bool deleteEmptySpans = this->updateBounded(first, last, oppFirst);
     deleteEmptySpans |= sect2->updateBounded(oppFirst, oppLast, first);
     this->removeSpanRange(first, last);
     sect2->removeSpanRange(oppFirst, oppLast);
     first->fEndT = last->fEndT;
     first->resetBounds(this->fCurve);
     first->fCoinStart.setPerp(fCurve, first->fStartT, first->fPart[0], sect2->fCurve);
@@ skipping 41 matching lines @@
             }
             lastCandidate = work;
             if (!first) {
                 first = work;
             }
         } else if (first && work->fCollapsed) {
             *lastPtr = lastCandidate;
             return first;
         } else {
             lastCandidate = nullptr;
-            SkASSERT(!first);
+            SkOPASSERT(!first);
         }
         if (work == *lastPtr) {
             return first;
         }
         work = work->fNext;
         if (!work) {
             return nullptr;
         }
     } while (true);
     if (lastCandidate) {
@@ skipping 311 matching lines @@
         // check middle t value to see if it is coincident as well
         double midT = (smaller->fEndT + larger->fStartT) / 2;
         SkDPoint midPt = fCurve.ptAtT(midT);
         SkTCoincident<TCurve, OppCurve> coin;
         coin.setPerp(fCurve, midT, midPt, sect2->fCurve);
         if (coin.isCoincident()) {
             smaller->fEndT = larger->fEndT;
             smaller->fCoinEnd = larger->fCoinEnd;
             if (largerPrior) {
                 largerPrior->fNext = larger->fNext;
+                largerPrior->validate();
             } else {
                 fCoincident = larger->fNext;
             }
         }
     } while (true);
 }
 
 template<typename TCurve, typename OppCurve>
 SkTSpan<TCurve, OppCurve>* SkTSect<TCurve, OppCurve>::prev(
         SkTSpan<TCurve, OppCurve>* span) const {
@@ skipping 96 matching lines @@
     SkTSpan<TCurve, OppCurve>* final = last->fNext;
     SkTSpan<TCurve, OppCurve>* next = span->fNext;
     while ((span = next) && span != final) {
         next = span->fNext;
         this->markSpanGone(span);
     }
     if (final) {
         final->fPrev = first;
     }
     first->fNext = final;
+    first->validate();
 }
 
 template<typename TCurve, typename OppCurve>
 void SkTSect<TCurve, OppCurve>::removeSpans(SkTSpan<TCurve, OppCurve>* span,
         SkTSect<OppCurve, TCurve>* opp) {
     SkTSpanBounded<OppCurve, TCurve>* bounded = span->fBounded;
     while (bounded) {
         SkTSpan<OppCurve, TCurve>* spanBounded = bounded->fBounded;
         SkTSpanBounded<OppCurve, TCurve>* next = bounded->fNext;
         if (span->removeBounded(spanBounded)) {  // shuffles last into position 0
@@ skipping 66 matching lines @@
 }
 
 template<typename TCurve, typename OppCurve>
 void SkTSect<TCurve, OppCurve>::unlinkSpan(SkTSpan<TCurve, OppCurve>* span) {
     SkTSpan<TCurve, OppCurve>* prev = span->fPrev;
     SkTSpan<TCurve, OppCurve>* next = span->fNext;
     if (prev) {
         prev->fNext = next;
         if (next) {
             next->fPrev = prev;
+            next->validate();
         }
     } else {
         fHead = next;
         if (next) {
             next->fPrev = nullptr;
         }
     }
 }
 
 template<typename TCurve, typename OppCurve>
 bool SkTSect<TCurve, OppCurve>::updateBounded(SkTSpan<TCurve, OppCurve>* first,
         SkTSpan<TCurve, OppCurve>* last, SkTSpan<OppCurve, TCurve>* oppFirst) {
     SkTSpan<TCurve, OppCurve>* test = first;
     const SkTSpan<TCurve, OppCurve>* final = last->next();
     bool deleteSpan = false;
     do {
         deleteSpan |= test->removeAllBounded();
     } while ((test = test->fNext) != final && test);
     first->fBounded = nullptr;
     first->addBounded(oppFirst, &fHeap);
     // cannot call validate until remove span range is called
     return deleteSpan;
 }
 
 
 template<typename TCurve, typename OppCurve>
 void SkTSect<TCurve, OppCurve>::validate() const {
-#if DEBUG_T_SECT
+#if DEBUG_VALIDATE
     int count = 0;
+    double last = 0;
     if (fHead) {
         const SkTSpan<TCurve, OppCurve>* span = fHead;
         SkASSERT(!span->fPrev);
-        SkDEBUGCODE(double last = 0);
+        const SkTSpan<TCurve, OppCurve>* next;
         do {
             span->validate();
             SkASSERT(span->fStartT >= last);
-            SkDEBUGCODE(last = span->fEndT);
+            last = span->fEndT;
             ++count;
-        } while ((span = span->fNext) != nullptr);
+            next = span->fNext;
+            SkASSERT(next != span);
+        } while ((span = next) != nullptr);
     }
     SkASSERT(count == fActiveCount);
+#endif
+#if DEBUG_T_SECT
     SkASSERT(fActiveCount <= fDebugAllocatedCount);
     int deletedCount = 0;
     const SkTSpan<TCurve, OppCurve>* deleted = fDeleted;
     while (deleted) {
         ++deletedCount;
         deleted = deleted->fNext;
     }
     const SkTSpan<TCurve, OppCurve>* coincident = fCoincident;
     while (coincident) {
         ++deletedCount;
         coincident = coincident->fNext;
     }
     SkASSERT(fActiveCount + deletedCount == fDebugAllocatedCount);
 #endif
 }
 
 template<typename TCurve, typename OppCurve>
 void SkTSect<TCurve, OppCurve>::validateBounded() const {
-#if DEBUG_T_SECT
+#if DEBUG_VALIDATE
     if (!fHead) {
         return;
     }
     const SkTSpan<TCurve, OppCurve>* span = fHead;
     do {
         span->validateBounded();
     } while ((span = span->fNext) != nullptr);
 #endif
 }
 
@@ skipping 211 matching lines @@
         }
         SkTSpan<OppCurve, TCurve>* largest2 = sect2->boundsMax();
         // split it
         if (!largest2 || (largest1 && (largest1->fBoundsMax > largest2->fBoundsMax
                 || (!largest1->fCollapsed && largest2->fCollapsed)))) {
             if (largest1->fCollapsed) {
                 break;
             }
             // trim parts that don't intersect the opposite
             SkTSpan<TCurve, OppCurve>* half1 = sect1->addOne();
+            SkDEBUGCODE(half1->debugSetGlobalState(sect1->globalState()));
             if (!half1->split(largest1, &sect1->fHeap)) {
                 break;
             }
             sect1->trim(largest1, sect2);
             sect1->trim(half1, sect2);
         } else {
             if (largest2->fCollapsed) {
                 break;
             }
             // trim parts that don't intersect the opposite
             SkTSpan<OppCurve, TCurve>* half2 = sect2->addOne();
+            SkDEBUGCODE(half2->debugSetGlobalState(sect2->globalState()));
             if (!half2->split(largest2, &sect2->fHeap)) {
                 break;
             }
             sect2->trim(largest2, sect1);
             sect2->trim(half2, sect1);
         }
         sect1->validate();
         sect2->validate();
 #if DEBUG_T_SECT_LOOP_COUNT
         intersections->debugBumpLoopCount(SkIntersections::kIterations_DebugLoop);
@@ skipping 155 matching lines @@
             --last;
         } else {
             intersections->setCoincident(index++);
         }
         intersections->setCoincident(index);
     }
     SkASSERT(intersections->used() <= TCurve::kMaxIntersections);
 }
 
 #endif