fix fuzzers

tests/StrokerTest.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 "PathOpsCubicIntersectionTestData.h"
 #include "PathOpsQuadIntersectionTestData.h"
 #include "SkCommonFlags.h"
+#include "SkPathOpsCubic.h"
 #include "SkPaint.h"
 #include "SkPath.h"
 #include "SkRandom.h"
 #include "SkStrokerPriv.h"
 #include "SkTime.h"
 #include "Test.h"
 
 DEFINE_bool(timeout, true, "run until alloted time expires");
 
 #define MS_TEST_DURATION 10
@@ skipping 21 matching lines @@
     pathTest(path);
 }
 
 static void quadTest(const SkPoint c[3]) {
     SkPath path;
     path.moveTo(c[0].fX, c[0].fY);
     path.quadTo(c[1].fX, c[1].fY, c[2].fX, c[2].fY);
     pathTest(path);
 }
 
-static void cubicSetTest(const SkDCubic* dCubic, size_t count) {
+static void cubicSetTest(const CubicPts* dCubic, size_t count) {
     skiatest::Timer timer;
     for (size_t index = 0; index < count; ++index) {
-        const SkDCubic& d = dCubic[index];
+        const CubicPts& dPts = dCubic[index];
+        SkDCubic d;
+        d.debugSet(dPts.fPts);
         SkPoint c[4] = { {(float) d[0].fX, (float) d[0].fY}, {(float) d[1].fX, (float) d[1].fY},
                          {(float) d[2].fX, (float) d[2].fY}, {(float) d[3].fX, (float) d[3].fY} };
         cubicTest(c);
         if (FLAGS_timeout && timer.elapsedMs() > MS_TEST_DURATION) {
             return;
         }
     }
 }
 
-static void cubicPairSetTest(const SkDCubic dCubic[][2], size_t count) {
+static void cubicPairSetTest(const CubicPts dCubic[][2], size_t count) {
     skiatest::Timer timer;
     for (size_t index = 0; index < count; ++index) {
         for (int pair = 0; pair < 2; ++pair) {
-            const SkDCubic& d = dCubic[index][pair];
+            const CubicPts& dPts = dCubic[index][pair];
+            SkDCubic d;
+            d.debugSet(dPts.fPts);
             SkPoint c[4] = { {(float) d[0].fX, (float) d[0].fY}, {(float) d[1].fX, (float) d[1].fY},
                              {(float) d[2].fX, (float) d[2].fY}, {(float) d[3].fX, (float) d[3].fY} };
             cubicTest(c);
             if (FLAGS_timeout && timer.elapsedMs() > MS_TEST_DURATION) {
                 return;
             }
         }
     }
 }
 
-static void quadSetTest(const SkDQuad* dQuad, size_t count) {
+static void quadSetTest(const QuadPts* dQuad, size_t count) {
     skiatest::Timer timer;
     for (size_t index = 0; index < count; ++index) {
-        const SkDQuad& d = dQuad[index];
+        const QuadPts& dPts = dQuad[index];
+        SkDQuad d;
+        d.debugSet(dPts.fPts);
         SkPoint c[3] = { {(float) d[0].fX, (float) d[0].fY}, {(float) d[1].fX, (float) d[1].fY},
                          {(float) d[2].fX, (float) d[2].fY}  };
         quadTest(c);
         if (FLAGS_timeout && timer.elapsedMs() > MS_TEST_DURATION) {
             return;
         }
     }
 }
 
-static void quadPairSetTest(const SkDQuad dQuad[][2], size_t count) {
+static void quadPairSetTest(const QuadPts dQuad[][2], size_t count) {
     skiatest::Timer timer;
     for (size_t index = 0; index < count; ++index) {
         for (int pair = 0; pair < 2; ++pair) {
-            const SkDQuad& d = dQuad[index][pair];
+            const QuadPts& dPts = dQuad[index][pair];
+            SkDQuad d;
+            d.debugSet(dPts.fPts);
             SkPoint c[3] = { {(float) d[0].fX, (float) d[0].fY}, {(float) d[1].fX, (float) d[1].fY},
                              {(float) d[2].fX, (float) d[2].fY}  };
             quadTest(c);
             if (FLAGS_timeout && timer.elapsedMs() > MS_TEST_DURATION) {
                 return;
             }
         }
     }
 }
 
@@ skipping 342 matching lines @@
         path.dump();
         SkDebugf("fill:\n");
         fill.dump();
     }
 #if defined(SK_DEBUG) && QUAD_STROKE_APPROXIMATION
     if (FLAGS_veryVerbose) {
         SkDebugf("max tan=%d cubic=%d\n", gMaxRecursion[0], gMaxRecursion[1]);
     }
 #endif
 }