fix fuzzers

src/pathops/SkPathOpsDebug.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkMutex.h"
 #include "SkOpCoincidence.h"
 #include "SkOpContour.h"
@@ skipping 673 matching lines @@
 
 int SkIntersections::debugLoopCount(DebugLoop index) const {
     return fDebugLoopCount[index];
 }
 
 void SkIntersections::debugResetLoopCount() {
     sk_bzero(fDebugLoopCount, sizeof(fDebugLoopCount));
 }
 #endif
 
+#include "SkPathOpsConic.h"
 #include "SkPathOpsCubic.h"
-#include "SkPathOpsQuad.h"
 
 SkDCubic SkDQuad::debugToCubic() const {
     SkDCubic cubic;
     cubic[0] = fPts[0];
     cubic[2] = fPts[1];
     cubic[3] = fPts[2];
     cubic[1].fX = (cubic[0].fX + cubic[2].fX * 2) / 3;
     cubic[1].fY = (cubic[0].fY + cubic[2].fY * 2) / 3;
     cubic[2].fX = (cubic[3].fX + cubic[2].fX * 2) / 3;
     cubic[2].fY = (cubic[3].fY + cubic[2].fY * 2) / 3;
     return cubic;
 }
 
+void SkDQuad::debugSet(const SkDPoint* pts) {
+    memcpy(fPts, pts, sizeof(fPts));
+    SkDEBUGCODE(fDebugGlobalState = nullptr);
+}
+
+void SkDCubic::debugSet(const SkDPoint* pts) {
+    memcpy(fPts, pts, sizeof(fPts));
+    SkDEBUGCODE(fDebugGlobalState = nullptr);
+}
+
+void SkDConic::debugSet(const SkDPoint* pts, SkScalar weight) {
+    fPts.debugSet(pts);
+    fWeight = weight;
+}
+
 void SkDRect::debugInit() {
     fLeft = fTop = fRight = fBottom = SK_ScalarNaN;
 }
 
 #include "SkOpAngle.h"
 #include "SkOpSegment.h"
 
 #if DEBUG_COIN
 // commented-out lines keep this in sync with addT()
  const SkOpPtT* SkOpSegment::debugAddT(double t, SkPathOpsDebug::GlitchLog* log) const {
@@ skipping 869 matching lines @@
         }
     } while ((span = span->next()));
 //    this->restoreHead();
     return;
 }
 
 /* Commented-out lines keep this in sync with addExpanded */
 // for each coincident pair, match the spans
 // if the spans don't match, add the mssing pt to the segment and loop it in the opposite span
 void SkOpCoincidence::debugAddExpanded(SkPathOpsDebug::GlitchLog* log) const {
+//    DEBUG_SET_PHASE();
     const SkCoincidentSpans* coin = this->fHead;
     if (!coin) {
         return;
     }
     do {
         const SkOpPtT* startPtT = coin->coinPtTStart();
         const SkOpPtT* oStartPtT = coin->oppPtTStart();
         double priorT = startPtT->fT;
         double oPriorT = oStartPtT->fT;
         FAIL_IF(startPtT->contains(oStartPtT), coin);
@@ skipping 24 matching lines @@
                     oNextT = oTest->t();
                 } else {
                     // iterate through until a pt-t list found that contains the other
                     const SkOpSpanBase* walk = test;
                     const SkOpPtT* walkOpp;
                     do {
                         FAIL_IF(!walk->upCastable(), coin);
                         walk = walk->upCast()->next();
                     } while (!(walkOpp = walk->ptT()->contains(oSeg))
                             && walk != coin->coinPtTEnd()->span());
+                    FAIL_IF(!walkOpp, coin);
                     nextT = walk->t();
                     oNextT = walkOpp->fT;
                 }
                 // use t ranges to guess which one is missing
-                double startRange = coin->coinPtTEnd()->fT - startPtT->fT;
+                double startRange = nextT - priorT;
                 FAIL_IF(!startRange, coin);
-                double startPart = (test->t() - startPtT->fT) / startRange;
-                double oStartRange = coin->oppPtTEnd()->fT - oStartPtT->fT;
+                double startPart = (test->t() - priorT) / startRange;
+                double oStartRange = oNextT - oPriorT;
                 FAIL_IF(!oStartRange, coin);
                 double oStartPart = (oTest->t() - oStartPtT->fT) / oStartRange;
                 FAIL_IF(startPart == oStartPart, coin);
                 bool addToOpp = !containedOpp && !containedThis ? startPart < oStartPart
                         : !!containedThis;
                 bool startOver = false;
                 addToOpp ? log->record(SkPathOpsDebug::kAddExpandedCoin_Glitch,
                         oPriorT + oStartRange * startPart, test)
                         : log->record(SkPathOpsDebug::kAddExpandedCoin_Glitch,
                         priorT + startRange * oStartPart, oTest);
@@ skipping 362 matching lines @@
             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->debugInsertCoincidence(log, oStart->upCast());
         end->debugInsertCoinEnd(log, oEnd);
         const SkOpSegment* segment = start->segment();
         const SkOpSegment* oSegment = oStart->segment();
         const SkOpSpanBase* next = start;
         const SkOpSpanBase* oNext = oStart;
-        bool ordered = coin->ordered();
+        bool ordered;
+        FAIL_IF(!coin->ordered(&ordered), coin);
         while ((next = next->upCast()->next()) != end) {
             FAIL_IF(!next->upCastable(), coin);
             if (next->upCast()->debugInsertCoincidence(log, oSegment, flipped, ordered), false) {
                 return;
             }
         }
         while ((oNext = oNext->upCast()->next()) != oEnd) {
             FAIL_IF(!oNext->upCastable(), coin);
             if (oNext->upCast()->debugInsertCoincidence(log, segment, flipped, ordered), false) {
                 return;
@@ skipping 838 matching lines @@
 #endif
     SkPath::FillType fillType = path.getFillType();
     SkASSERT(fillType >= SkPath::kWinding_FillType && fillType <= SkPath::kInverseEvenOdd_FillType);
     if (includeDeclaration) {
         SkDebugf("    SkPath %s;\n", name);
     }
     SkDebugf("    %s.setFillType(SkPath::%s);\n", name, gFillTypeStr[fillType]);
     iter.setPath(path);
     showPathContours(iter, name);
 }