conic fuzz fix

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 864 matching lines @@
 
 template<typename TCurve, typename OppCurve>
 bool SkTSect<TCurve, OppCurve>::binarySearchCoin(SkTSect<OppCurve, TCurve>* sect2, double tStart,
         double tStep, double* resultT, double* oppT) {
     SkTSpan<TCurve, OppCurve> work;
     double result = work.fStartT = work.fEndT = tStart;
     SkDEBUGCODE(work.fDebugSect = this);
     SkDPoint last = fCurve.ptAtT(tStart);
     SkDPoint oppPt;
     bool flip = false;
+    bool contained = false;
     SkDEBUGCODE(bool down = tStep < 0);
     const OppCurve& opp = sect2->fCurve;
     do {
         tStep *= 0.5;
         work.fStartT += tStep;
         if (flip) {
             tStep = -tStep;
             flip = false;
         }
         work.initBounds(fCurve);
         if (work.fCollapsed) {
             return false;
         }
         if (last.approximatelyEqual(work.fPart[0])) {
             break;
         }
         last = work.fPart[0];
         work.fCoinStart.setPerp(fCurve, work.fStartT, last, opp);
         if (work.fCoinStart.isCoincident()) {
 #if DEBUG_T_SECT
             work.validatePerpPt(work.fCoinStart.perpT(), work.fCoinStart.perpPt());
 #endif
             double oppTTest = work.fCoinStart.perpT();
             if (sect2->fHead->contains(oppTTest)) {
                 *oppT = oppTTest;
                 oppPt = work.fCoinStart.perpPt();
+                contained = true;
                 SkASSERT(down ? result > work.fStartT : result < work.fStartT);
                 result = work.fStartT;
                 continue;
             }
         }
         tStep = -tStep;
         flip = true;
     } while (true);
+    if (!contained) {
+        return false;
+    }
     if (last.approximatelyEqual(fCurve[0])) {
         result = 0;
     } else if (last.approximatelyEqual(fCurve[TCurve::kPointLast])) {
         result = 1;
     }
     if (oppPt.approximatelyEqual(opp[0])) {
         *oppT = 0;
     } else if (oppPt.approximatelyEqual(opp[OppCurve::kPointLast])) {
         *oppT = 1;
     }
@@ skipping 987 matching lines @@
         fC2Span = span2;
         fC1StartT = span1->startT();
         fC1EndT = span1->endT();
         fC2StartT = span2->startT();
         fC2EndT = span2->endT();
         fC1Index = c1Index;
         fC2Index = c2Index;
         fClosest = dist;
     }
 
-    bool matesWith(const SkClosestRecord& mate) const {
+    bool matesWith(const SkClosestRecord& mate  SkDEBUGPARAMS(SkIntersections* i)) const {
         SkASSERT(fC1Span == mate.fC1Span || fC1Span->endT() <= mate.fC1Span->startT()
                 || mate.fC1Span->endT() <= fC1Span->startT());
-        SkASSERT(fC2Span == mate.fC2Span || fC2Span->endT() <= mate.fC2Span->startT()
+        SkOPOBJASSERT(i, fC2Span == mate.fC2Span || fC2Span->endT() <= mate.fC2Span->startT()
                 || mate.fC2Span->endT() <= fC2Span->startT());
         return fC1Span == mate.fC1Span || fC1Span->endT() == mate.fC1Span->startT()
                 || fC1Span->startT() == mate.fC1Span->endT()
                 || fC2Span == mate.fC2Span
                 || fC2Span->endT() == mate.fC2Span->startT()
                 || fC2Span->startT() == mate.fC2Span->endT();
     }
 
     void merge(const SkClosestRecord& mate) {
         fC1Span = mate.fC1Span;
@@ skipping 28 matching lines @@
     int fC2Index;
 };
 
 template<typename TCurve, typename OppCurve>
 struct SkClosestSect {
     SkClosestSect()
         : fUsed(0) {
         fClosest.push_back().reset();
     }
 
-    bool find(const SkTSpan<TCurve, OppCurve>* span1, const SkTSpan<OppCurve, TCurve>* span2) {
+    bool find(const SkTSpan<TCurve, OppCurve>* span1, const SkTSpan<OppCurve, TCurve>* span2
+            SkDEBUGPARAMS(SkIntersections* i)) {
         SkClosestRecord<TCurve, OppCurve>* record = &fClosest[fUsed];
         record->findEnd(span1, span2, 0, 0);
         record->findEnd(span1, span2, 0, OppCurve::kPointLast);
         record->findEnd(span1, span2, TCurve::kPointLast, 0);
         record->findEnd(span1, span2, TCurve::kPointLast, OppCurve::kPointLast);
         if (record->fClosest == FLT_MAX) {
             return false;
         }
         for (int index = 0; index < fUsed; ++index) {
             SkClosestRecord<TCurve, OppCurve>* test = &fClosest[index];
-            if (test->matesWith(*record)) {
+            if (test->matesWith(*record  SkDEBUGPARAMS(i))) {
                 if (test->fClosest > record->fClosest) {
                     test->merge(*record);
                 }
                 test->update(*record);
                 record->reset();
                 return false;
             }
         }
         ++fUsed;
         fClosest.push_back().reset();
@@ skipping 205 matching lines @@
     do {
         while (result1 && result1->fCoinStart.isCoincident() && result1->fCoinEnd.isCoincident()) {
             result1 = result1->fNext;
         }
         if (!result1) {
             break;
         }
         SkTSpan<OppCurve, TCurve>* result2 = sect2->fHead;
         bool found = false;
         while (result2) {
-            found |= closest.find(result1, result2);
+            found |= closest.find(result1, result2  SkDEBUGPARAMS(intersections));
             result2 = result2->fNext;
         }
     } while ((result1 = result1->fNext));
     closest.finish(intersections);
     // if there is more than one intersection and it isn't already coincident, check
     int last = intersections->used() - 1;
     for (int index = 0; index < last; ) {
         if (intersections->isCoincident(index) && intersections->isCoincident(index + 1)) {
             ++index;
             continue;
@@ skipping 15 matching lines @@
             --last;
         } else {
             intersections->setCoincident(index++);
         }
         intersections->setCoincident(index);
     }
     SkASSERT(intersections->used() <= TCurve::kMaxIntersections);
 }
 
 #endif