fix fuzzers

tests/PathOpsCubicLineIntersectionIdeas.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "PathOpsTestCommon.h"
 #include "SkIntersections.h"
 #include "SkPathOpsCubic.h"
 #include "SkPathOpsLine.h"
 #include "SkPathOpsQuad.h"
 #include "SkRandom.h"
 #include "SkReduceOrder.h"
 #include "Test.h"
 
 static bool gPathOpsCubicLineIntersectionIdeasVerbose = false;
 
 static struct CubicLineFailures {
-    SkDCubic c;
+    CubicPts c;
     double t;
     SkDPoint p;
 } cubicLineFailures[] = {
     {{{{-164.3726806640625, 36.826904296875}, {-189.045166015625, -953.2220458984375},
         {926.505859375, -897.36175537109375}, {-139.33489990234375, 204.40771484375}}},
         0.37329583, {107.54935269006289, -632.13736293162208}},
     {{{{784.056884765625, -554.8350830078125}, {67.5489501953125, 509.0224609375},
         {-447.713134765625, 751.375}, {415.7784423828125, 172.22265625}}},
         0.660005242, {-32.973148967736151, 478.01341797403569}},
     {{{{-580.6834716796875, -127.044921875}, {-872.8983154296875, -945.54302978515625},
@@ skipping 108 matching lines @@
         return;
     }
     SkRandom ran;
     double worstStep[256] = {0};
     int errors = 0;
     int iters = 0;
     double smallestR2 = 0;
     double largestR2 = 0;
     for (int index = 0; index < 1000000000; ++index) {
         SkDPoint origin = {ran.nextRangeF(-1000, 1000), ran.nextRangeF(-1000, 1000)};
-        SkDCubic cubic = {{origin,
+        CubicPts cuPts = {{origin,
                 {ran.nextRangeF(-1000, 1000), ran.nextRangeF(-1000, 1000)},
                 {ran.nextRangeF(-1000, 1000), ran.nextRangeF(-1000, 1000)},
                 {ran.nextRangeF(-1000, 1000), ran.nextRangeF(-1000, 1000)}
         }};
         // construct a line at a known intersection
         double t = ran.nextRangeF(0, 1);
+        SkDCubic cubic;
+        cubic.debugSet(cuPts.fPts);
         SkDPoint pt = cubic.ptAtT(t);
         // skip answers with no intersections (although note the bug!) or two, or more
         // see if the line / cubic has a fun range of roots
         double A, B, C, D;
         SkDCubic::Coefficients(&cubic[0].fY, &A, &B, &C, &D);
         D -= pt.fY;
         double allRoots[3] = {0}, validRoots[3] = {0};
         int realRoots = SkDCubic::RootsReal(A, B, C, D, allRoots);
         int valid = SkDQuad::AddValidTs(allRoots, realRoots, validRoots);
         if (valid != 1) {
@@ skipping 76 matching lines @@
     int worstLimit = SK_ARRAY_COUNT(worstStep);
     while (worstStep[--worstLimit] == 0) ;
     for (int idx2 = 0; idx2 <= worstLimit; ++idx2) {
         SkDebugf("%1.9g ", worstStep[idx2]);
     }
     SkDebugf("\n");
     SkDebugf("smallestR2=%1.9g largestR2=%1.9g\n", smallestR2, largestR2);
 }
 
 static double testOneFailure(const CubicLineFailures& failure) {
-    const SkDCubic& cubic = failure.c;
+    const CubicPts& c = failure.c;
+    SkDCubic cubic;
+    cubic.debugSet(c.fPts);
     const SkDPoint& pt = failure.p;
     double A, B, C, D;
     SkDCubic::Coefficients(&cubic[0].fY, &A, &B, &C, &D);
     D -= pt.fY;
     double allRoots[3] = {0}, validRoots[3] = {0};
     int realRoots = SkDCubic::RootsReal(A, B, C, D, allRoots);
     int valid = SkDQuad::AddValidTs(allRoots, realRoots, validRoots);
     SkASSERT_RELEASE(valid == 1);
     SkASSERT_RELEASE(realRoots != 1);
     double t = validRoots[0];
@@ skipping 12 matching lines @@
         SkASSERT_RELEASE(newT >= 0);
     }
 }
 
 DEF_TEST(PathOpsCubicLineOneFailure, reporter) {
     return;  // disable for now
     const CubicLineFailures& failure = cubicLineFailures[1];
     double newT = testOneFailure(failure);
     SkASSERT_RELEASE(newT >= 0);
 }