fix fuzz bugs

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 200 matching lines @@
     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:
-    SkTSect(const TCurve& c  PATH_OPS_DEBUG_T_SECT_PARAMS(int id));
+    SkTSect(const TCurve& c  SkDEBUGPARAMS(SkOpGlobalState* ) PATH_OPS_DEBUG_T_SECT_PARAMS(int id));
     static void BinarySearch(SkTSect* sect1, SkTSect<OppCurve, TCurve>* sect2,
             SkIntersections* intersections);
 
+    SkDEBUGCODE(SkOpGlobalState* globalState() { return fDebugGlobalState; })
     // for testing only
     bool debugHasBounded(const SkTSpan<OppCurve, TCurve>* ) const;
 
     const SkTSect<OppCurve, TCurve>* debugOpp() const {
         return SkDEBUGRELEASE(fOppSect, nullptr);
     }
 
     const SkTSpan<TCurve, OppCurve>* debugSpan(int id) const;
     const SkTSpan<TCurve, OppCurve>* debugT(double t) const;
     void dump() const;
@@ skipping 77 matching lines @@
                        SkTSpan<OppCurve, TCurve>* oppFirst);
     void validate() const;
     void validateBounded() const;
 
     const TCurve& fCurve;
     SkChunkAlloc fHeap;
     SkTSpan<TCurve, OppCurve>* fHead;
     SkTSpan<TCurve, OppCurve>* fCoincident;
     SkTSpan<TCurve, OppCurve>* fDeleted;
     int fActiveCount;
+    SkDEBUGCODE(SkOpGlobalState* fDebugGlobalState);
     SkDEBUGCODE_(SkTSect<OppCurve, TCurve>* fOppSect);
     PATH_OPS_DEBUG_T_SECT_CODE(int fID);
     PATH_OPS_DEBUG_T_SECT_CODE(int fDebugCount);
 #if DEBUG_T_SECT
     int fDebugAllocatedCount;
 #endif
     friend class SkTSpan<TCurve, OppCurve>;
     friend class SkTSpan<OppCurve, TCurve>;
     friend class SkTSect<OppCurve, TCurve>;
 };
@@ skipping 489 matching lines @@
     SkASSERT(0);
 }
 
 template<typename TCurve, typename OppCurve>
 void SkTSpan<TCurve, OppCurve>::validatePerpPt(double t, const SkDPoint& pt) const {
     SkASSERT(fDebugSect->fOppSect->fCurve.ptAtT(t) == pt);
 }
 
 
 template<typename TCurve, typename OppCurve>
-SkTSect<TCurve, OppCurve>::SkTSect(const TCurve& c PATH_OPS_DEBUG_T_SECT_PARAMS(int id))
+SkTSect<TCurve, OppCurve>::SkTSect(const TCurve& c 
+        SkDEBUGPARAMS(SkOpGlobalState* debugGlobalState)
+        PATH_OPS_DEBUG_T_SECT_PARAMS(int id))
     : fCurve(c)
     , 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();
     fHead->init(c);
 }
 
 template<typename TCurve, typename OppCurve>
 SkTSpan<TCurve, OppCurve>* SkTSect<TCurve, OppCurve>::addOne() {
@@ skipping 325 matching lines @@
     // FIXME: incomplete : if we're not at the end, find end of coin
     SkTSpan<OppCurve, TCurve>* oppLast;
     SkASSERT(last->fCoinEnd.isCoincident());
     oppLast = last->findOppT(last->fCoinEnd.perpT());
     SkDEBUGCODE(coinEnd = last->fEndT);
     SkDEBUGCODE(oppEndT = oppMatched ? oppLast->fEndT : oppLast->fStartT);
     if (!oppMatched) {
         SkTSwap(oppFirst, oppLast);
         SkTSwap(oppStartT, oppEndT);
     }
-    SkASSERT(oppStartT < oppEndT);
+    SkOPASSERT(oppStartT < oppEndT);
     SkASSERT(coinStart == first->fStartT);
     SkASSERT(coinEnd == last->fEndT);
     SkASSERT(oppStartT == oppFirst->fStartT);
     SkASSERT(oppEndT == oppLast->fEndT);
     // 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);
@@ skipping 51 matching lines @@
             *lastPtr = lastCandidate;
             return first;
         } else {
             lastCandidate = nullptr;
             SkASSERT(!first);
         }
         if (work == *lastPtr) {
             return first;
         }
         work = work->fNext;
-        SkASSERT(work);
+        if (!work) {
+            return nullptr;
+        }
     } while (true);
     if (lastCandidate) {
         *lastPtr = lastCandidate;
     }
     return first;
 }
 
 template<typename TCurve, typename OppCurve>
 int SkTSect<TCurve, OppCurve>::intersects(SkTSpan<TCurve, OppCurve>* span,
         SkTSect<OppCurve, TCurve>* opp,
@@ skipping 231 matching lines @@
     i->insert(workT, oppTTest, workPt);
     return 1;
 }
 
 
 template<typename TCurve, typename OppCurve>
 void SkTSect<TCurve, OppCurve>::markSpanGone(SkTSpan<TCurve, OppCurve>* span) {
     --fActiveCount;
     span->fNext = fDeleted;
     fDeleted = span;
-    SkASSERT(!span->fDeleted);
+    SkOPASSERT(!span->fDeleted);
     span->fDeleted = true;
 }
 
 template<typename TCurve, typename OppCurve>
 bool SkTSect<TCurve, OppCurve>::matchedDirection(double t, const SkTSect<OppCurve, TCurve>* sect2,
         double t2) const {
     SkDVector dxdy = this->fCurve.dxdyAtT(t);
     SkDVector dxdy2 = sect2->fCurve.dxdyAtT(t2);
     return dxdy.dot(dxdy2) >= 0;
 }
@@ skipping 270 matching lines @@
 }
 
 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);
+    } 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
@@ skipping 439 matching lines @@
             --last;
         } else {
             intersections->setCoincident(index++);
         }
         intersections->setCoincident(index);
     }
     SkASSERT(intersections->used() <= TCurve::kMaxIntersections);
 }
 
 #endif