pathops coincidence and security rewrite

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 232 matching lines @@
     enum {
         kZeroS1Set = 1,
         kOneS1Set = 2,
         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();
         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);
@@ skipping 72 matching lines @@
 void SkTCoincident<TCurve, OppCurve>::setPerp(const TCurve& c1, double t,
         const SkDPoint& cPt, const OppCurve& c2) {
     SkDVector dxdy = c1.dxdyAtT(t);
     SkDLine perp = {{ cPt, {cPt.fX + dxdy.fY, cPt.fY - dxdy.fX} }};
     SkIntersections i;
     int used = i.intersectRay(c2, perp);
     // only keep closest
     if (used == 0 || used == 3) {
         this->init();
         return;
-    } 
+    }
     fPerpT = i[0][0];
     fPerpPt = i.pt(0);
     SkASSERT(used <= 2);
     if (used == 2) {
         double distSq = (fPerpPt - cPt).lengthSquared();
         double dist2Sq = (i.pt(1) - cPt).lengthSquared();
         if (dist2Sq < distSq) {
             fPerpT = i[0][1];
             fPerpPt = i.pt(1);
         }
@@ skipping 494 matching lines @@
     } else {
         result = new (fHeap.allocThrow(sizeof(SkTSpan<TCurve, OppCurve>)))(
                 SkTSpan<TCurve, OppCurve>);
 #if DEBUG_T_SECT
         ++fDebugAllocatedCount;
 #endif
     }
     result->reset();
     result->fHasPerp = false;
     result->fDeleted = false;
-    ++fActiveCount; 
+    ++fActiveCount;
     PATH_OPS_DEBUG_T_SECT_CODE(result->fID = fDebugCount++ * 2 + fID);
     SkDEBUGCODE(result->fDebugSect = this);
 #ifdef SK_DEBUG
     result->fPart.debugInit();
     result->fCoinStart.debugInit();
     result->fCoinEnd.debugInit();
     result->fPrev = result->fNext = nullptr;
     result->fBounds.debugInit();
     result->fStartT = result->fEndT = result->fBoundsMax = SK_ScalarNaN;
     result->fCollapsed = result->fIsLinear = result->fIsLine = 0xFF;
@@ skipping 90 matching lines @@
         this->validate();
         sect2->validate();
         this->computePerpendiculars(sect2, first, last);
         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;
+        }
     } 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 219 matching lines @@
     sect2->validateBounded();
     last = first->fNext;
     this->removeCoincident(first, false);
     sect2->removeCoincident(oppFirst, true);
     if (deleteEmptySpans) {
         this->deleteEmptySpans();
         sect2->deleteEmptySpans();
     }
     this->validate();
     sect2->validate();
-    return last && !last->fDeleted ? last : nullptr;
+    return last && !last->fDeleted && fHead && sect2->fHead ? last : nullptr;
 }
 
 template<typename TCurve, typename OppCurve>
 SkTSpan<TCurve, OppCurve>* SkTSect<TCurve, OppCurve>::findCoincidentRun(
         SkTSpan<TCurve, OppCurve>* first, SkTSpan<TCurve, OppCurve>** lastPtr) {
     SkTSpan<TCurve, OppCurve>* work = first;
     SkTSpan<TCurve, OppCurve>* lastCandidate = nullptr;
     first = nullptr;
     // find the first fully coincident span
     do {
@@ skipping 282 matching lines @@
         double t2) const {
     SkDVector dxdy = this->fCurve.dxdyAtT(t);
     SkDVector dxdy2 = sect2->fCurve.dxdyAtT(t2);
     return dxdy.dot(dxdy2) >= 0;
 }
 
 template<typename TCurve, typename OppCurve>
 void SkTSect<TCurve, OppCurve>::matchedDirCheck(double t, const SkTSect<OppCurve, TCurve>* sect2,
         double t2, bool* calcMatched, bool* oppMatched) const {
     if (*calcMatched) {
-        SkASSERT(*oppMatched == this->matchedDirection(t, sect2, t2)); 
+        SkASSERT(*oppMatched == this->matchedDirection(t, sect2, t2));
     } else {
         *oppMatched = this->matchedDirection(t, sect2, t2);
         *calcMatched = true;
     }
 }
 
 template<typename TCurve, typename OppCurve>
 void SkTSect<TCurve, OppCurve>::mergeCoincidence(SkTSect<OppCurve, TCurve>* sect2) {
     double smallLimit = 0;
     do {
@@ skipping 52 matching lines @@
 template<typename TCurve, typename OppCurve>
 SkTSpan<TCurve, OppCurve>* SkTSect<TCurve, OppCurve>::prev(
         SkTSpan<TCurve, OppCurve>* span) const {
     SkTSpan<TCurve, OppCurve>* result = nullptr;
     SkTSpan<TCurve, OppCurve>* test = fHead;
     while (span != test) {
         result = test;
         test = test->fNext;
         SkASSERT(test);
     }
-    return result; 
+    return result;
 }
 
 template<typename TCurve, typename OppCurve>
 void SkTSect<TCurve, OppCurve>::recoverCollapsed() {
     SkTSpan<TCurve, OppCurve>* deleted = fDeleted;
     while (deleted) {
         SkTSpan<TCurve, OppCurve>* delNext = deleted->fNext;
         if (deleted->fCollapsed) {
             SkTSpan<TCurve, OppCurve>** spanPtr = &fHead;
             while (*spanPtr && (*spanPtr)->fEndT <= deleted->fStartT) {
@@ skipping 334 matching lines @@
                 || fC2Span->startT() == mate.fC2Span->endT();
     }
 
     void merge(const SkClosestRecord& mate) {
         fC1Span = mate.fC1Span;
         fC2Span = mate.fC2Span;
         fClosest = mate.fClosest;
         fC1Index = mate.fC1Index;
         fC2Index = mate.fC2Index;
     }
-    
+
     void reset() {
         fClosest = FLT_MAX;
         SkDEBUGCODE(fC1Span = nullptr);
         SkDEBUGCODE(fC2Span = nullptr);
         SkDEBUGCODE(fC1Index = fC2Index = -1);
     }
 
     void update(const SkClosestRecord& mate) {
         fC1StartT = SkTMin(fC1StartT, mate.fC1StartT);
         fC1EndT = SkTMax(fC1EndT, mate.fC1EndT);
@@ skipping 139 matching lines @@
             sect1->validate();
             sect2->validate();
 #if DEBUG_T_SECT_LOOP_COUNT
             intersections->debugBumpLoopCount(SkIntersections::kCoinCheck_DebugLoop);
 #endif
             if (!--coinLoopCount && sect1->fHead && sect2->fHead) {
                 /* All known working cases resolve in two tries. Sadly, cubicConicTests[0]
                    gets stuck in a loop. It adds an extension to allow a coincident end
                    perpendicular to track its intersection in the opposite curve. However,
                    the bounding box of the extension does not intersect the original curve,
-                   so the extension is discarded, only to be added again the next time around. */ 
+                   so the extension is discarded, only to be added again the next time around. */
                 sect1->coincidentForce(sect2, start1s, start1e);
                 sect1->validate();
                 sect2->validate();
             }
         }
         if (sect1->fActiveCount >= COINCIDENT_SPAN_COUNT
                 && sect2->fActiveCount >= COINCIDENT_SPAN_COUNT) {
             sect1->computePerpendiculars(sect2, sect1->fHead, sect1->tail());
             sect2->computePerpendiculars(sect1, sect2->fHead, sect2->tail());
             sect1->removeByPerpendicular(sect2);
@@ skipping 125 matching lines @@
             --last;
         } else {
             intersections->setCoincident(index++);
         }
         intersections->setCoincident(index);
     }
     SkASSERT(intersections->used() <= TCurve::kMaxIntersections);
 }
 
 #endif