fix fuzzers

src/pathops/SkOpSegment.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "SkOpCoincidence.h"
 #include "SkOpContour.h"
 #include "SkOpSegment.h"
 #include "SkPathWriter.h"
@@ skipping 151 matching lines @@
 bool SkOpSegment::addCurveTo(const SkOpSpanBase* start, const SkOpSpanBase* end,
         SkPathWriter* path) const {
     FAIL_IF(start->starter(end)->alreadyAdded());
     SkDCurveSweep curvePart;
     start->segment()->subDivide(start, end, &curvePart.fCurve);
     curvePart.setCurveHullSweep(fVerb);
     SkPath::Verb verb = curvePart.isCurve() ? fVerb : SkPath::kLine_Verb;
     path->deferredMove(start->ptT());
     switch (verb) {
         case SkPath::kLine_Verb:
-            path->deferredLine(end->ptT());
+            FAIL_IF(!path->deferredLine(end->ptT()));
             break;
         case SkPath::kQuad_Verb:
-            path->quadTo(curvePart.fCurve.fQuad.fPts[1].asSkPoint(), end->ptT());
+            path->quadTo(curvePart.fCurve.fQuad[1].asSkPoint(), end->ptT());
             break;
         case SkPath::kConic_Verb:
-            path->conicTo(curvePart.fCurve.fConic.fPts[1].asSkPoint(), end->ptT(),
+            path->conicTo(curvePart.fCurve.fConic[1].asSkPoint(), end->ptT(),
                     curvePart.fCurve.fConic.fWeight);
             break;
         case SkPath::kCubic_Verb:
-            path->cubicTo(curvePart.fCurve.fCubic.fPts[1].asSkPoint(),
-                    curvePart.fCurve.fCubic.fPts[2].asSkPoint(), end->ptT());
+            path->cubicTo(curvePart.fCurve.fCubic[1].asSkPoint(),
+                    curvePart.fCurve.fCubic[2].asSkPoint(), end->ptT());
             break;
         default:
             SkASSERT(0);
     }
     return true;
 }
 
 const SkOpPtT* SkOpSegment::existing(double t, const SkOpSegment* opp) const {
     const SkOpSpanBase* test = &fHead;
     const SkOpPtT* testPtT;
@@ skipping 24 matching lines @@
 foundMatch:
     return opp && !test->contains(opp) ? nullptr : testPtT;
 }
 
 // break the span so that the coincident part does not change the angle of the remainder
 bool SkOpSegment::addExpanded(double newT, const SkOpSpanBase* test, bool* startOver) {
     if (this->contains(newT)) {
         return true;
     }
     this->globalState()->resetAllocatedOpSpan();
+    FAIL_IF(!between(0, newT, 1));
     SkOpPtT* newPtT = this->addT(newT);
     *startOver |= this->globalState()->allocatedOpSpan();
     if (!newPtT) {
         return false;
     }
     newPtT->fPt = this->ptAtT(newT);
     SkOpPtT* oppPrev = test->ptT()->oppPrev(newPtT);
     if (oppPrev) {
         // const cast away to change linked list; pt/t values stays unchanged
         SkOpSpanBase* writableTest = const_cast<SkOpSpanBase*>(test);
@@ skipping 1449 matching lines @@
     int absOut = SkTAbs(outerWinding);
     int absIn = SkTAbs(innerWinding);
     bool result = absOut == absIn ? outerWinding < 0 : absOut < absIn;
     return result;
 }
 
 int SkOpSegment::windSum(const SkOpAngle* angle) const {
     const SkOpSpan* minSpan = angle->start()->starter(angle->end());
     return minSpan->windSum();
 }