fuzzer fixes

Fix path bugs exposed by the path fuzzer.

Changes to existing gm and samplecode files defer their calls to construct
SkPath objects until the first draw instead of at test initialization.

Add an experimental call to SkPath to validate the internal SkPathRef.

Fix SkPath::addPoly to set the last moveto after adding a close verb.

Fix stroke to handle failures when computing the unit normal.

Add a unit test for the unit normal failure.

R=reed@google.com

Review URL: https://codereview.chromium.org/953383002

19 files changed, 765 insertions, 58 deletions

diff --git a/gm/bitmapshader.cpp b/gm/bitmapshader.cpp
index 8085f5c42c..ac8bf663c9 100644
--- a/gm/bitmapshader.cpp
+++ b/gm/bitmapshader.cpp
@@ -41,15 +41,14 @@ static void adopt_shader(SkPaint* paint, SkShader* shader) {
 }
 
 class BitmapShaderGM : public GM {
-public:
 
-    BitmapShaderGM() {
+protected:
+    void onOnceBeforeDraw() SK_OVERRIDE {
         this->setBGColor(SK_ColorGRAY);
         draw_bm(&fBitmap);
         draw_mask(&fMask);
     }
 
-protected:
     virtual SkString onShortName() {
         return SkString("bitmapshaders");
     }
diff --git a/gm/circularclips.cpp b/gm/circularclips.cpp
index ec766fbca4..614ebb6097 100644
--- a/gm/circularclips.cpp
+++ b/gm/circularclips.cpp
@@ -13,8 +13,8 @@ class CircularClipsGM : public skiagm::GM {
     SkScalar fX1, fX2, fY, fR;
     SkPath   fCircle1, fCircle2;
 
-public:
-    CircularClipsGM() {
+protected:
+    void onOnceBeforeDraw() SK_OVERRIDE {
         fX1 = 80;
         fX2 = 120;
         fY = 50;
@@ -24,7 +24,6 @@ public:
         fCircle2.addCircle(fX2, fY, fR, SkPath::kCW_Direction);
     }
 
-protected:
 
     bool runAsBench() const SK_OVERRIDE { return true; }
 
diff --git a/gm/complexclip2.cpp b/gm/complexclip2.cpp
index a55d0733e0..361b1c0b97 100644
--- a/gm/complexclip2.cpp
+++ b/gm/complexclip2.cpp
@@ -24,6 +24,21 @@ public:
     ComplexClip2GM(Clip clip, bool antiAlias)
     : fClip(clip)
     , fAntiAlias(antiAlias) {
+        SkScalar xA = 0.65f;
+        SkScalar xF = 50.65f;
+
+        SkScalar yA = 0.65f;
+        SkScalar yF = 50.65f;
+
+        fWidth = xF - xA;
+        fHeight = yF - yA;
+
+        fTotalWidth = kCols * fWidth + SK_Scalar1 * (kCols + 1) * kPadX;
+        fTotalHeight = kRows * fHeight + SK_Scalar1 * (kRows + 1) * kPadY;
+    }
+
+protected:
+    void onOnceBeforeDraw() SK_OVERRIDE {
         this->setBGColor(SkColorSetRGB(0xDD,0xA0,0xDD));
 
         // offset the rects a bit so we get antialiasing even in the rect case
@@ -41,9 +56,6 @@ public:
         SkScalar yE = 40.65f;
         SkScalar yF = 50.65f;
 
-        fWidth = xF - xA;
-        fHeight = yF - yA;
-
         fRects[0].set(xB, yB, xE, yE);
         fRRects[0].setRectXY(fRects[0], 7, 7);
         fPaths[0].addRoundRect(fRects[0], 5, 5);
@@ -69,9 +81,6 @@ public:
         fPaths[4].addRoundRect(fRects[4], 5, 5);
         fRectColors[4] = SK_ColorCYAN;
 
-        fTotalWidth = kCols * fWidth + SK_Scalar1 * (kCols + 1) * kPadX;
-        fTotalHeight = kRows * fHeight + SK_Scalar1 * (kRows + 1) * kPadY;
-
         SkRegion::Op ops[] = {
             SkRegion::kDifference_Op,
             SkRegion::kIntersect_Op,
@@ -91,8 +100,6 @@ public:
         }
     }
 
-protected:
-
     static const int kRows = 5;
     static const int kCols = 5;
     static const int kPadX = 20;
diff --git a/gm/picture.cpp b/gm/picture.cpp
index b07a5969a9..5432fc93ef 100644
--- a/gm/picture.cpp
+++ b/gm/picture.cpp
@@ -39,9 +39,15 @@ static SkPicture* make_picture() {
 //
 class PictureGM : public skiagm::GM {
 public:
-    PictureGM() : fPicture(make_picture()) {}
+    PictureGM()
+        : fPicture(NULL)
+    {}
 
 protected:
+    void onOnceBeforeDraw() SK_OVERRIDE {
+         fPicture.reset(make_picture());
+    }
+
     SkString onShortName() SK_OVERRIDE {
         return SkString("pictures");
     }
diff --git a/gm/pictureshader.cpp b/gm/pictureshader.cpp
index 630ecd8f0c..3f184ec2d6 100644
--- a/gm/pictureshader.cpp
+++ b/gm/pictureshader.cpp
@@ -27,21 +27,23 @@ public:
     PictureShaderGM(SkScalar tileSize, SkScalar sceneSize)
         : fTileSize(tileSize)
         , fSceneSize(sceneSize) {
+    }
 
-        // Build the picture.
+ protected:
+    void onOnceBeforeDraw() SK_OVERRIDE {
+       // Build the picture.
         SkPictureRecorder recorder;
-        SkCanvas* pictureCanvas = recorder.beginRecording(tileSize, tileSize, NULL, 0);
+        SkCanvas* pictureCanvas = recorder.beginRecording(fTileSize, fTileSize, NULL, 0);
         this->drawTile(pictureCanvas);
         fPicture.reset(recorder.endRecording());
 
         // Build a reference bitmap.
-        fBitmap.allocN32Pixels(SkScalarCeilToInt(tileSize), SkScalarCeilToInt(tileSize));
+        fBitmap.allocN32Pixels(SkScalarCeilToInt(fTileSize), SkScalarCeilToInt(fTileSize));
         fBitmap.eraseColor(SK_ColorTRANSPARENT);
         SkCanvas bitmapCanvas(fBitmap);
         this->drawTile(&bitmapCanvas);
     }
 
-protected:
 
     SkString onShortName() SK_OVERRIDE {
         return SkString("pictureshader");
diff --git a/gm/shadows.cpp b/gm/shadows.cpp
index 3ecbdd833f..66ad32e089 100644
--- a/gm/shadows.cpp
+++ b/gm/shadows.cpp
@@ -28,14 +28,14 @@ public:
     SkPath fCirclePath;
     SkRect fRect;
 
-    ShadowsGM() {
+protected:
+    void onOnceBeforeDraw() SK_OVERRIDE {
         this->setBGColor(0xFFDDDDDD);
         fCirclePath.addCircle(SkIntToScalar(20), SkIntToScalar(20), SkIntToScalar(10) );
         fRect.set(SkIntToScalar(10), SkIntToScalar(10),
                   SkIntToScalar(30), SkIntToScalar(30));
     }
 
-protected:
     virtual SkString onShortName() {
         return SkString("shadows");
     }
diff --git a/gm/simpleaaclip.cpp b/gm/simpleaaclip.cpp
index 950a1c025e..8a18f48e62 100644
--- a/gm/simpleaaclip.cpp
+++ b/gm/simpleaaclip.cpp
@@ -49,7 +49,10 @@ public:
 
     SimpleClipGM(SkGeomTypes geomType)
     : fGeomType(geomType) {
+    }
 
+protected:
+    void onOnceBeforeDraw() SK_OVERRIDE {
         // offset the rects a bit so we get anti-aliasing in the rect case
         fBase.set(100.65f,
                   100.65f,
@@ -64,7 +67,6 @@ public:
         INHERITED::setBGColor(0xFFDDDDDD);
     }
 
-protected:
     void buildRgn(SkAAClip* clip, SkRegion::Op op) {
         clip->setPath(fBasePath, NULL, true);
 
diff --git a/gm/strokes.cpp b/gm/strokes.cpp
index af01b9169e..cadd0d6d9e 100644
--- a/gm/strokes.cpp
+++ b/gm/strokes.cpp
@@ -80,8 +80,8 @@ private:
 
 class Strokes2GM : public skiagm::GM {
     SkPath fPath;
-public:
-    Strokes2GM() {
+protected:
+    void onOnceBeforeDraw() SK_OVERRIDE {
         SkRandom rand;
         fPath.moveTo(0, 0);
         for (int i = 0; i < 13; i++) {
@@ -91,7 +91,6 @@ public:
         }
     }
 
-protected:
 
     SkString onShortName() SK_OVERRIDE {
         return SkString("strokes_poly");
diff --git a/gyp/SampleApp.gyp b/gyp/SampleApp.gyp
index cbe9e88598..9caeecabc6 100644
--- a/gyp/SampleApp.gyp
+++ b/gyp/SampleApp.gyp
@@ -86,6 +86,7 @@
         '../samplecode/SamplePatch.cpp',
         '../samplecode/SamplePath.cpp',
         '../samplecode/SamplePathClip.cpp',
+        '../samplecode/SamplePathFuzz.cpp',
         '../samplecode/SamplePathUtils.cpp',
         '../samplecode/SamplePathEffects.cpp',
         '../samplecode/SamplePicture.cpp',
diff --git a/include/core/SkPath.h b/include/core/SkPath.h
index 2d1a8e3910..7444cc97ca 100644
--- a/include/core/SkPath.h
+++ b/include/core/SkPath.h
@@ -958,6 +958,7 @@ public:
 #endif
 
     SkDEBUGCODE(void validate() const;)
+    SkDEBUGCODE(void experimentalValidateRef() const { fPathRef->validate(); } )
 
 private:
     enum SerializationOffsets {
diff --git a/samplecode/SampleApp.cpp b/samplecode/SampleApp.cpp
index 17e8623d4f..2b3183023a 100644
--- a/samplecode/SampleApp.cpp
+++ b/samplecode/SampleApp.cpp
@@ -2135,6 +2135,10 @@ void SampleView::draw(SkCanvas* canvas) {
 }
 
 void SampleView::onDraw(SkCanvas* canvas) {
+    if (!fHaveCalledOnceBeforeDraw) {
+        fHaveCalledOnceBeforeDraw = true;
+        this->onOnceBeforeDraw();
+    }
     this->onDrawBackground(canvas);
 
     for (int i = 0; i < fRepeatCount; i++) {
diff --git a/samplecode/SampleCode.h b/samplecode/SampleCode.h
index e65919a765..4152f54c67 100644
--- a/samplecode/SampleCode.h
+++ b/samplecode/SampleCode.h
@@ -107,6 +107,7 @@ public:
         : fPipeState(SkOSMenu::kOffState)
         , fBGColor(SK_ColorWHITE)
         , fRepeatCount(1)
+        , fHaveCalledOnceBeforeDraw(false)
     {}
 
     void setBGColor(SkColor color) { fBGColor = color; }
@@ -131,6 +132,7 @@ protected:
     virtual void onDrawBackground(SkCanvas*);
     virtual void onDrawContent(SkCanvas*) = 0;
     virtual bool onAnimate(const SkAnimTimer&) { return false; }
+    virtual void onOnceBeforeDraw() {}
 
     // overrides
     virtual bool onEvent(const SkEvent& evt);
@@ -143,7 +145,7 @@ protected:
 
 private:
     int fRepeatCount;
-
+    bool fHaveCalledOnceBeforeDraw;
     typedef SkView INHERITED;
 };
 
diff --git a/samplecode/SamplePathEffects.cpp b/samplecode/SamplePathEffects.cpp
index a5f91c296e..f1574fbda8 100644
--- a/samplecode/SamplePathEffects.cpp
+++ b/samplecode/SamplePathEffects.cpp
@@ -96,6 +96,10 @@ class PathEffectView : public SampleView {
 
 public:
     PathEffectView() : fPhase(0) {
+        }
+
+protected:
+    void onOnceBeforeDraw() SK_OVERRIDE {
         SkRandom    rand;
         int         steps = 20;
         SkScalar    dist = SkIntToScalar(400);
@@ -126,7 +130,6 @@ public:
         this->setBGColor(0xFFDDDDDD);
     }
 
-protected:
     bool onQuery(SkEvent* evt) SK_OVERRIDE {
         if (SampleCode::TitleQ(*evt)) {
             SampleCode::TitleR(evt, "PathEffects");
diff --git a/samplecode/SamplePathFuzz.cpp b/samplecode/SamplePathFuzz.cpp
new file mode 100644
index 0000000000..d6b11c5971
--- /dev/null
+++ b/samplecode/SamplePathFuzz.cpp
@@ -0,0 +1,651 @@
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "SampleCode.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkPaint.h"
+#include "SkPath.h"
+#include "SkMatrix.h"
+#include "SkColor.h"
+#include "SkTDArray.h"
+#include "SkRandom.h"
+
+enum RandomAddPath {
+    kMoveToPath,
+    kRMoveToPath,
+    kLineToPath,
+    kRLineToPath,
+    kQuadToPath,
+    kRQuadToPath,
+    kConicToPath,
+    kRConicToPath,
+    kCubicToPath,
+    kRCubicToPath,
+    kArcToPath,
+    kArcTo2Path,
+    kClosePath,
+    kAddArc,
+    kAddRoundRect1,
+    kAddRoundRect2,
+    kAddRRect,
+    kAddPoly,
+    kAddPath1,
+    kAddPath2,
+    kAddPath3,
+    kReverseAddPath,
+};
+
+const int kRandomAddPath_Last = kReverseAddPath;
+
+const char* gRandomAddPathNames[] = {
+    "kMoveToPath",
+    "kRMoveToPath",
+    "kLineToPath",
+    "kRLineToPath",
+    "kQuadToPath",
+    "kRQuadToPath",
+    "kConicToPath",
+    "kRConicToPath",
+    "kCubicToPath",
+    "kRCubicToPath",
+    "kArcToPath",
+    "kArcTo2Path",
+    "kClosePath",
+    "kAddArc",
+    "kAddRoundRect1",
+    "kAddRoundRect2",
+    "kAddRRect",
+    "kAddPoly",
+    "kAddPath1",
+    "kAddPath2",
+    "kAddPath3",
+    "kReverseAddPath",
+};
+
+enum RandomSetRRect {
+    kSetEmpty,
+    kSetRect,
+    kSetOval,
+    kSetRectXY,
+    kSetNinePatch,
+    kSetRectRadii,
+};
+
+const char* gRandomSetRRectNames[] = {
+    "kSetEmpty",
+    "kSetRect",
+    "kSetOval",
+    "kSetRectXY",
+    "kSetNinePatch",
+    "kSetRectRadii",
+};
+
+int kRandomSetRRect_Last = kSetRectRadii;
+
+enum RandomSetMatrix {
+    kSetIdentity,
+    kSetTranslate,
+    kSetTranslateX,
+    kSetTranslateY,
+    kSetScale,
+    kSetScaleTranslate,
+    kSetScaleX,
+    kSetScaleY,
+    kSetSkew,
+    kSetSkewTranslate,
+    kSetSkewX,
+    kSetSkewY,
+    kSetRotate,
+    kSetRotateTranslate,
+    kSetPerspectiveX,
+    kSetPerspectiveY,
+    kSetAll,
+};
+
+int kRandomSetMatrix_Last = kSetAll;
+
+const char* gRandomSetMatrixNames[] = {
+    "kSetIdentity",
+    "kSetTranslate",
+    "kSetTranslateX",
+    "kSetTranslateY",
+    "kSetScale",
+    "kSetScaleTranslate",
+    "kSetScaleX",
+    "kSetScaleY",
+    "kSetSkew",
+    "kSetSkewTranslate",
+    "kSetSkewX",
+    "kSetSkewY",
+    "kSetRotate",
+    "kSetRotateTranslate",
+    "kSetPerspectiveX",
+    "kSetPerspectiveY",
+    "kSetAll",
+};
+
+class FuzzPath {
+public:
+    FuzzPath() 
+        : fFloatMin(0)
+        , fFloatMax(800)
+        , fAddCount(0)
+        , fPrintName(false)
+        , fValidate(false)
+    {
+        fTab = "                                                                                  ";
+    }
+    void randomize() {
+        fPathDepth = 0;
+        fPathDepthLimit = fRand.nextRangeU(1, 2);
+        fPathContourCount = fRand.nextRangeU(1, 4);
+        fPathSegmentLimit = fRand.nextRangeU(1, 8);
+        fClip = makePath();
+        SkASSERT(!fPathDepth);
+        fMatrix = makeMatrix();
+        fPaint = makePaint();
+        fPathDepthLimit = fRand.nextRangeU(1, 3);
+        fPathContourCount = fRand.nextRangeU(1, 6);
+        fPathSegmentLimit = fRand.nextRangeU(1, 16);
+        fPath = makePath();
+        SkASSERT(!fPathDepth);
+    }
+
+    const SkPath& getClip() const {
+        return fClip;
+    }
+
+    const SkMatrix& getMatrix() const {
+        return fMatrix;
+    }
+
+    const SkPaint& getPaint() const {
+        return fPaint;
+    }
+
+    const SkPath& getPath() const {
+        return fPath;
+    }
+
+private:
+
+SkPath::AddPathMode makeAddPathMode() {
+    return (SkPath::AddPathMode) fRand.nextRangeU(SkPath::kAppend_AddPathMode,
+        SkPath::kExtend_AddPathMode);
+}
+
+RandomAddPath makeAddPathType() {
+    return (RandomAddPath) fRand.nextRangeU(0, kRandomAddPath_Last);
+}
+
+SkScalar makeAngle() {
+    SkScalar angle;
+    angle = fRand.nextF();
+    return angle;
+}
+
+bool makeBool() {
+    return fRand.nextBool();
+}
+
+SkPath::Direction makeDirection() {
+    return (SkPath::Direction) fRand.nextRangeU(SkPath::kCW_Direction, SkPath::kCCW_Direction);
+}
+
+SkMatrix makeMatrix() {
+    SkMatrix matrix;
+    matrix.reset();
+    RandomSetMatrix setMatrix = (RandomSetMatrix) fRand.nextRangeU(0, kRandomSetMatrix_Last);
+    if (fPrintName) {
+        SkDebugf("%.*s%s\n", fPathDepth * 3, fTab, gRandomSetMatrixNames[setMatrix]);
+    }
+    switch (setMatrix) {
+        case kSetIdentity:
+            break;
+        case kSetTranslateX:
+            matrix.setTranslateX(makeScalar());
+            break;
+        case kSetTranslateY:
+            matrix.setTranslateY(makeScalar());
+            break;
+        case kSetTranslate:
+            matrix.setTranslate(makeScalar(), makeScalar());
+            break;
+        case kSetScaleX:
+            matrix.setScaleX(makeScalar());
+            break;
+        case kSetScaleY:
+            matrix.setScaleY(makeScalar());
+            break;
+        case kSetScale:
+            matrix.setScale(makeScalar(), makeScalar());
+            break;
+        case kSetScaleTranslate:
+            matrix.setScale(makeScalar(), makeScalar(), makeScalar(), makeScalar());
+            break;
+        case kSetSkewX:
+            matrix.setSkewX(makeScalar());
+            break;
+        case kSetSkewY:
+            matrix.setSkewY(makeScalar());
+            break;
+        case kSetSkew:
+            matrix.setSkew(makeScalar(), makeScalar());
+            break;
+        case kSetSkewTranslate:
+            matrix.setSkew(makeScalar(), makeScalar(), makeScalar(), makeScalar());
+            break;
+        case kSetRotate:
+            matrix.setRotate(makeScalar());
+            break;
+        case kSetRotateTranslate:
+            matrix.setRotate(makeScalar(), makeScalar(), makeScalar());
+            break;
+        case kSetPerspectiveX:
+            matrix.setPerspX(makeScalar());
+            break;
+        case kSetPerspectiveY:
+            matrix.setPerspY(makeScalar());
+            break;
+        case kSetAll:
+            matrix.setAll(makeScalar(), makeScalar(), makeScalar(),
+                          makeScalar(), makeScalar(), makeScalar(),
+                          makeScalar(), makeScalar(), makeScalar());
+            break;
+    }
+    return matrix;
+}
+
+SkPaint makePaint() {
+    SkPaint paint;
+    bool antiAlias = fRand.nextBool();
+    paint.setAntiAlias(antiAlias);
+    SkPaint::Style style = (SkPaint::Style) fRand.nextRangeU(SkPaint::kFill_Style,
+        SkPaint::kStrokeAndFill_Style);
+    paint.setStyle(style);
+    SkColor color = (SkColor) fRand.nextU();
+    paint.setColor(color);
+    SkScalar width = fRand.nextF();
+    paint.setStrokeWidth(width);
+    SkScalar miter = fRand.nextF();
+    paint.setStrokeMiter(miter);
+    SkPaint::Cap cap = (SkPaint::Cap) fRand.nextRangeU(SkPaint::kButt_Cap, SkPaint::kSquare_Cap);
+    paint.setStrokeCap(cap);
+    SkPaint::Join join = (SkPaint::Join) fRand.nextRangeU(SkPaint::kMiter_Join,
+        SkPaint::kBevel_Join);
+    paint.setStrokeJoin(join);
+    return paint;
+}
+
+SkPoint makePoint() {
+    SkPoint result;
+    makeScalarArray(2, &result.fX);
+    return result;
+}
+
+void makePointArray(size_t arrayCount, SkPoint* points) {
+    for (size_t index = 0; index < arrayCount; ++index) {
+        points[index] = makePoint();
+    }
+}
+
+void makePointArray(SkTDArray<SkPoint>* points) {
+    size_t arrayCount = fRand.nextRangeU(1, 10);
+    for (size_t index = 0; index < arrayCount; ++index) {
+        *points->append() = makePoint();
+    }
+}
+
+SkRect makeRect() {
+    SkRect result;
+    makeScalarArray(4, &result.fLeft);
+    return result;
+}
+
+SkRRect makeRRect() {
+    SkRRect rrect;
+    RandomSetRRect rrectType = makeSetRRectType();
+    if (fPrintName) {
+        SkDebugf("%.*s%s\n", fPathDepth * 3, fTab, gRandomSetRRectNames[rrectType]);
+    }
+    switch (rrectType) {
+        case kSetEmpty:
+            rrect.setEmpty();
+            break;
+        case kSetRect: {
+            SkRect rect = makeRect();
+            rrect.setRect(rect);
+            } break;
+        case kSetOval: {
+            SkRect oval = makeRect();
+            rrect.setOval(oval);
+            } break;
+        case kSetRectXY: {
+            SkRect rect = makeRect();
+            SkScalar xRad = makeScalar();
+            SkScalar yRad = makeScalar();
+            rrect.setRectXY(rect, xRad, yRad);
+            } break;
+        case kSetNinePatch: {
+            SkRect rect = makeRect();
+            SkScalar leftRad = makeScalar();
+            SkScalar topRad = makeScalar();
+            SkScalar rightRad = makeScalar();
+            SkScalar bottomRad = makeScalar();
+            rrect.setNinePatch(rect, leftRad, topRad, rightRad, bottomRad);
+            SkDebugf("");  // keep locals in scope
+            } break;
+        case kSetRectRadii: {
+            SkRect rect = makeRect();
+            SkVector radii[4];
+            makeVectorArray(SK_ARRAY_COUNT(radii), radii);
+            rrect.setRectRadii(rect, radii);
+            } break;
+    }
+    return rrect;
+}
+
+SkPath makePath() {
+    SkPath path;
+    for (uint32_t cIndex = 0; cIndex < fPathContourCount; ++cIndex) {
+        uint32_t segments = makeSegmentCount();
+        for (uint32_t sIndex = 0; sIndex < segments; ++sIndex) {
+            RandomAddPath addPathType = makeAddPathType();
+            ++fAddCount;
+            if (fPrintName) {
+                SkDebugf("%.*s%s\n", fPathDepth * 3, fTab,
+                        gRandomAddPathNames[addPathType]);
+            }
+            switch (addPathType) {
+                case kAddArc: {
+                    SkRect oval = makeRect();
+                    SkScalar startAngle = makeAngle();
+                    SkScalar sweepAngle = makeAngle();
+                    path.addArc(oval, startAngle, sweepAngle);
+                    validate(path);
+                    } break;
+                case kAddRoundRect1: {
+                    SkRect rect = makeRect();
+                    SkScalar rx = makeScalar(), ry = makeScalar();
+                    SkPath::Direction dir = makeDirection();
+                    path.addRoundRect(rect, rx, ry, dir);
+                    validate(path);
+                    } break;
+                case kAddRoundRect2: {
+                    SkRect rect = makeRect();
+                    SkScalar radii[8];
+                    makeScalarArray(SK_ARRAY_COUNT(radii), radii);
+                    SkPath::Direction dir = makeDirection();
+                    path.addRoundRect(rect, radii, dir);
+                    validate(path);
+                    } break;
+                case kAddRRect: {
+                    SkRRect rrect = makeRRect();
+                    SkPath::Direction dir = makeDirection();
+                    path.addRRect(rrect, dir);
+                    validate(path);
+                    } break;
+                case kAddPoly: {
+                    SkTDArray<SkPoint> points;
+                    makePointArray(&points);
+                    bool close = makeBool();
+                    path.addPoly(&points[0], points.count(), close);
+                    validate(path);
+                    } break;
+                case kAddPath1:
+                    if (fPathDepth < fPathDepthLimit) {
+                        ++fPathDepth;
+                        SkPath src = makePath();
+                        validate(src);
+                        SkScalar dx = makeScalar();
+                        SkScalar dy = makeScalar();
+                        SkPath::AddPathMode mode = makeAddPathMode();
+                        path.addPath(src, dx, dy, mode);
+                        --fPathDepth;
+                        validate(path);
+                    } 
+                    break;
+                case kAddPath2:
+                    if (fPathDepth < fPathDepthLimit) {
+                        ++fPathDepth;
+                        SkPath src = makePath();
+                        validate(src);
+                        SkPath::AddPathMode mode = makeAddPathMode();
+                        path.addPath(src, mode);
+                        --fPathDepth;
+                        validate(path);
+                    }
+                    break;
+                case kAddPath3:
+                    if (fPathDepth < fPathDepthLimit) {
+                        ++fPathDepth;
+                        SkPath src = makePath();
+                        validate(src);
+                        SkMatrix matrix = makeMatrix();
+                        SkPath::AddPathMode mode = makeAddPathMode();
+                        path.addPath(src, matrix, mode);
+                        --fPathDepth;
+                        validate(path);
+                    }
+                    break;
+                case kReverseAddPath:
+                    if (fPathDepth < fPathDepthLimit) {
+                        ++fPathDepth;
+                        SkPath src = makePath();
+                        validate(src);
+                        path.reverseAddPath(src);
+                        --fPathDepth;
+                        validate(path);
+                    }
+                    break;
+                case kMoveToPath: {
+                    SkScalar x = makeScalar();
+                    SkScalar y = makeScalar();
+                    path.moveTo(x, y);
+                    validate(path);
+                    } break;
+                case kRMoveToPath: {
+                    SkScalar x = makeScalar();
+                    SkScalar y = makeScalar();
+                    path.rMoveTo(x, y);
+                    validate(path);
+                    } break;
+                case kLineToPath: {
+                    SkScalar x = makeScalar();
+                    SkScalar y = makeScalar();
+                    path.lineTo(x, y);
+                    validate(path);
+                    } break;
+                case kRLineToPath: {
+                    SkScalar x = makeScalar();
+                    SkScalar y = makeScalar();
+                    path.rLineTo(x, y);
+                    validate(path);
+                    } break;
+                case kQuadToPath: {
+                    SkPoint pt[2];
+                    makePointArray(SK_ARRAY_COUNT(pt), pt);
+                    path.quadTo(pt[0], pt[1]);
+                    validate(path);
+                    } break;
+                case kRQuadToPath: {
+                    SkPoint pt[2];
+                    makePointArray(SK_ARRAY_COUNT(pt), pt);
+                    path.rQuadTo(pt[0].fX, pt[0].fY, pt[1].fX, pt[1].fY);
+                    validate(path);
+                    } break;
+                case kConicToPath: {
+                    SkPoint pt[2];
+                    makePointArray(SK_ARRAY_COUNT(pt), pt);
+                    SkScalar weight = makeScalar();
+                    path.conicTo(pt[0], pt[1], weight);
+                    validate(path);
+                    } break;
+                case kRConicToPath: {
+                    SkPoint pt[2];
+                    makePointArray(SK_ARRAY_COUNT(pt), pt);
+                    SkScalar weight = makeScalar();
+                    path.rConicTo(pt[0].fX, pt[0].fY, pt[1].fX, pt[1].fY, weight);
+                    validate(path);
+                    } break;
+                case kCubicToPath: {
+                    SkPoint pt[3];
+                    makePointArray(SK_ARRAY_COUNT(pt), pt);
+                    path.cubicTo(pt[0], pt[1], pt[2]);
+                    validate(path);
+                    } break;
+                case kRCubicToPath: {
+                    SkPoint pt[3];
+                    makePointArray(SK_ARRAY_COUNT(pt), pt);
+                    path.rCubicTo(pt[0].fX, pt[0].fY, pt[1].fX, pt[1].fY, pt[2].fX, pt[2].fY);
+                    validate(path);
+                    } break;
+                case kArcToPath: {
+                    SkPoint pt[2];
+                    makePointArray(SK_ARRAY_COUNT(pt), pt);
+                    SkScalar radius = makeScalar();
+                    path.arcTo(pt[0], pt[1], radius);
+                    validate(path);
+                    } break;
+                case kArcTo2Path: {
+                    SkRect oval = makeRect();
+                    SkScalar startAngle = makeAngle();
+                    SkScalar sweepAngle = makeAngle();
+                    bool forceMoveTo = makeBool();
+                    path.arcTo(oval, startAngle, sweepAngle, forceMoveTo);
+                    validate(path);
+                    } break;
+                case kClosePath:
+                    path.close();
+                    validate(path);
+                    break;
+            }
+        }
+    }
+    return path;
+}
+
+uint32_t makeSegmentCount() {
+    return fRand.nextRangeU(1, fPathSegmentLimit);
+}
+
+RandomSetRRect makeSetRRectType() {
+    return (RandomSetRRect) fRand.nextRangeU(0, kRandomSetRRect_Last);
+}
+
+SkScalar makeScalar() {
+    SkScalar scalar;
+    scalar = fRand.nextRangeF(fFloatMin, fFloatMax);
+    return scalar;
+}
+
+void makeScalarArray(size_t arrayCount, SkScalar* array) {
+    for (size_t index = 0; index < arrayCount; ++index) {
+        array[index] = makeScalar();
+    }
+}
+
+void makeVectorArray(size_t arrayCount, SkVector* array) {
+    for (size_t index = 0; index < arrayCount; ++index) {
+        array[index] = makeVector();
+    }
+}
+
+SkVector makeVector() {
+    SkVector result;
+    makeScalarArray(2, &result.fX);
+    return result;
+}
+
+void validate(const SkPath& path) {
+    if (fValidate) {
+        SkDEBUGCODE(path.experimentalValidateRef());
+    }
+}
+
+SkRandom fRand;
+SkMatrix fMatrix;
+SkPath fClip;
+SkPaint fPaint;
+SkPath fPath;
+SkScalar fFloatMin;
+SkScalar fFloatMax;
+uint32_t fPathContourCount;
+int fPathDepth;
+int fPathDepthLimit;
+uint32_t fPathSegmentLimit;
+int fAddCount;
+bool fPrintName;
+bool fValidate;
+const char* fTab;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+static bool contains_only_moveTo(const SkPath& path) {
+    int verbCount = path.countVerbs();
+    if (verbCount == 0) {
+        return true;
+    }
+    SkTDArray<uint8_t> verbs;
+    verbs.setCount(verbCount);
+    SkDEBUGCODE(int getVerbResult = ) path.getVerbs(verbs.begin(), verbCount);
+    SkASSERT(getVerbResult == verbCount);
+    for (int index = 0; index < verbCount; ++index) {
+        if (verbs[index] != SkPath::kMove_Verb) {
+            return false;
+        }
+    }
+    return true;
+}
+
+class PathFuzzView : public SampleView {
+public:
+    PathFuzzView() {
+        fDots = 0;
+    }
+protected:
+    // overrides from SkEventSink
+    virtual bool onQuery(SkEvent* evt) {
+        if (SampleCode::TitleQ(*evt)) {
+            SampleCode::TitleR(evt, "PathFuzzer");
+            return true;
+        }
+        return this->INHERITED::onQuery(evt);
+    }
+
+    virtual void onDrawContent(SkCanvas* canvas) {
+        fuzzPath.randomize();
+        const SkPath& path = fuzzPath.getPath();
+        const SkPaint& paint = fuzzPath.getPaint();
+        const SkPath& clip = fuzzPath.getClip();
+        const SkMatrix& matrix = fuzzPath.getMatrix();
+        if (!contains_only_moveTo(clip)) {
+            canvas->clipPath(clip);
+        }
+        canvas->setMatrix(matrix);
+        canvas->drawPath(path, paint);
+        this->inval(NULL);
+        if (++fDots == 8000) {
+            SkDebugf("\n");
+            fDots = 0;
+        }
+        if ((fDots % 100) == 99) {
+            SkDebugf(".");
+        }
+    }
+
+private:
+    FuzzPath fuzzPath;
+    int fDots;
+    typedef SkView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new PathFuzzView; }
+static SkViewRegister reg(MyFactory);
diff --git a/samplecode/SampleStrokePath.cpp b/samplecode/SampleStrokePath.cpp
index 4f6e3cc743..00e5821937 100644
--- a/samplecode/SampleStrokePath.cpp
+++ b/samplecode/SampleStrokePath.cpp
@@ -98,8 +98,8 @@ static const struct {
 class StrokePathView : public SampleView {
     SkScalar    fWidth;
     SkPath      fPath;
-public:
-    StrokePathView() {
+protected:
+    void onOnceBeforeDraw() SK_OVERRIDE {
 //        test_blur();
         fWidth = SkIntToScalar(120);
 
@@ -122,7 +122,6 @@ public:
         this->setBGColor(0xFFDDDDDD);
     }
 
-protected:
     // overrides from SkEventSink
     bool onQuery(SkEvent* evt) SK_OVERRIDE {
         if (SampleCode::TitleQ(*evt)) {
diff --git a/samplecode/SampleTextOnPath.cpp b/samplecode/SampleTextOnPath.cpp
index ac889c3dae..95ae548016 100644
--- a/samplecode/SampleTextOnPath.cpp
+++ b/samplecode/SampleTextOnPath.cpp
@@ -93,7 +93,8 @@ public:
     SkPath      fPath;
     SkScalar    fHOffset;
 
-    TextOnPathView() {
+protected:
+    void onOnceBeforeDraw() SK_OVERRIDE {
         SkRect r;
         r.set(SkIntToScalar(100), SkIntToScalar(100),
               SkIntToScalar(300), SkIntToScalar(300));
@@ -103,7 +104,6 @@ public:
         fHOffset = SkIntToScalar(50);
     }
 
-protected:
     // overrides from SkEventSink
     bool onQuery(SkEvent* evt) SK_OVERRIDE {
         if (SampleCode::TitleQ(*evt)) {
diff --git a/src/core/SkPath.cpp b/src/core/SkPath.cpp
index 0b796fc537..2babe70185 100644
--- a/src/core/SkPath.cpp
+++ b/src/core/SkPath.cpp
@@ -863,6 +863,7 @@ void SkPath::addPoly(const SkPoint pts[], int count, bool close) {
 
     if (close) {
         ed.growForVerb(kClose_Verb);
+        fLastMoveToIndex ^= ~fLastMoveToIndex >> (8 * sizeof(fLastMoveToIndex) - 1);
     }
 
     DIRTY_AFTER_EDIT;
diff --git a/src/core/SkStroke.cpp b/src/core/SkStroke.cpp
index 29da19f4c5..062406aa2c 100644
--- a/src/core/SkStroke.cpp
+++ b/src/core/SkStroke.cpp
@@ -271,7 +271,7 @@ private:
 #endif
 
     void    finishContour(bool close, bool isLine);
-    void    preJoinTo(const SkPoint&, SkVector* normal, SkVector* unitNormal,
+    bool    preJoinTo(const SkPoint&, SkVector* normal, SkVector* unitNormal,
                       bool isLine);
     void    postJoinTo(const SkPoint&, const SkVector& normal,
                        const SkVector& unitNormal);
@@ -291,15 +291,16 @@ private:
 
 ///////////////////////////////////////////////////////////////////////////////
 
-void SkPathStroker::preJoinTo(const SkPoint& currPt, SkVector* normal,
+bool SkPathStroker::preJoinTo(const SkPoint& currPt, SkVector* normal,
                               SkVector* unitNormal, bool currIsLine) {
     SkASSERT(fSegmentCount >= 0);
 
     SkScalar    prevX = fPrevPt.fX;
     SkScalar    prevY = fPrevPt.fY;
 
-    SkAssertResult(set_normal_unitnormal(fPrevPt, currPt, fRadius, normal,
-                                         unitNormal));
+    if (!set_normal_unitnormal(fPrevPt, currPt, fRadius, normal, unitNormal)) {
+        return false;
+    }
 
     if (fSegmentCount == 0) {
         fFirstNormal = *normal;
@@ -313,6 +314,7 @@ void SkPathStroker::preJoinTo(const SkPoint& currPt, SkVector* normal,
                 fRadius, fInvMiterLimit, fPrevIsLine, currIsLine);
     }
     fPrevIsLine = currIsLine;
+    return true;
 }
 
 void SkPathStroker::postJoinTo(const SkPoint& currPt, const SkVector& normal,
@@ -418,7 +420,9 @@ void SkPathStroker::lineTo(const SkPoint& currPt) {
     }
     SkVector    normal, unitNormal;
 
-    this->preJoinTo(currPt, &normal, &unitNormal, true);
+    if (!this->preJoinTo(currPt, &normal, &unitNormal, true)) {
+        return;
+    }
     this->line_to(currPt, normal);
     this->postJoinTo(currPt, normal, unitNormal);
 }
@@ -796,16 +800,15 @@ void SkPathStroker::conicTo(const SkPoint& pt1, const SkPoint& pt2, SkScalar wei
     }
     SkASSERT(kQuad_ReductionType == reductionType);
     SkVector normalAB, unitAB, normalBC, unitBC;
-    this->preJoinTo(pt1, &normalAB, &unitAB, false);
-    SkQuadConstruct quadPts;
-    this->init(kOuter_StrokeType, &quadPts, 0, 1);
-    if (!this->conicStroke(conic, &quadPts)) {
+    if (!this->preJoinTo(pt1, &normalAB, &unitAB, false)) {
+        this->lineTo(pt2);
         return;
     }
+    SkQuadConstruct quadPts;
+    this->init(kOuter_StrokeType, &quadPts, 0, 1);
+    (void) this->conicStroke(conic, &quadPts);
     this->init(kInner_StrokeType, &quadPts, 0, 1);
-    if (!this->conicStroke(conic, &quadPts)) {
-        return;
-    }
+    (void) this->conicStroke(conic, &quadPts);
     this->setConicEndNormal(conic, normalAB, unitAB, &normalBC, &unitBC);
     this->postJoinTo(pt2, normalBC, unitBC);
 }
@@ -833,16 +836,15 @@ void SkPathStroker::quadTo(const SkPoint& pt1, const SkPoint& pt2) {
     }
     SkASSERT(kQuad_ReductionType == reductionType);
     SkVector normalAB, unitAB, normalBC, unitBC;
-    this->preJoinTo(pt1, &normalAB, &unitAB, false);
-    SkQuadConstruct quadPts;
-    this->init(kOuter_StrokeType, &quadPts, 0, 1);
-    if (!this->quadStroke(quad, &quadPts)) {
+    if (!this->preJoinTo(pt1, &normalAB, &unitAB, false)) {
+        this->lineTo(pt2);
         return;
     }
+    SkQuadConstruct quadPts;
+    this->init(kOuter_StrokeType, &quadPts, 0, 1);
+    (void) this->quadStroke(quad, &quadPts);
     this->init(kInner_StrokeType, &quadPts, 0, 1);
-    if (!this->quadStroke(quad, &quadPts)) {
-        return;
-    }
+    (void) this->quadStroke(quad, &quadPts);
     this->setQuadEndNormal(quad, normalAB, unitAB, &normalBC, &unitBC);
 #else
     bool    degenerateAB = SkPath::IsLineDegenerate(fPrevPt, pt1);
@@ -1404,7 +1406,10 @@ void SkPathStroker::cubicTo(const SkPoint& pt1, const SkPoint& pt2,
     }
     SkASSERT(kQuad_ReductionType == reductionType);
     SkVector normalAB, unitAB, normalCD, unitCD;
-    this->preJoinTo(*tangentPt, &normalAB, &unitAB, false);
+    if (!this->preJoinTo(*tangentPt, &normalAB, &unitAB, false)) {
+        this->lineTo(pt3);
+        return;
+    }
     SkScalar tValues[2];
     int count = SkFindCubicInflections(cubic, tValues);
     SkScalar lastT = 0;
@@ -1412,13 +1417,9 @@ void SkPathStroker::cubicTo(const SkPoint& pt1, const SkPoint& pt2,
         SkScalar nextT = index < count ? tValues[index] : 1;
         SkQuadConstruct quadPts;
         this->init(kOuter_StrokeType, &quadPts, lastT, nextT);
-        if (!this->cubicStroke(cubic, &quadPts)) {
-            break;
-        }
+        (void) this->cubicStroke(cubic, &quadPts);
         this->init(kInner_StrokeType, &quadPts, lastT, nextT);
-        if (!this->cubicStroke(cubic, &quadPts)) {
-            break;
-        }
+        (void) this->cubicStroke(cubic, &quadPts);
         lastT = nextT;
     }
     // emit the join even if one stroke succeeded but the last one failed
diff --git a/tests/StrokeTest.cpp b/tests/StrokeTest.cpp
index 15220c4a3b..80ca317302 100644
--- a/tests/StrokeTest.cpp
+++ b/tests/StrokeTest.cpp
@@ -18,6 +18,35 @@ static bool equal(const SkRect& a, const SkRect& b) {
             SkScalarNearlyEqual(a.bottom(), b.bottom());
 }
 
+static void test_strokecubic(skiatest::Reporter* reporter) {
+    uint32_t hexCubicVals[] = {
+        0x424c1086, 0x44bcf0cb,  // fX=51.0161362 fY=1511.52478
+        0x424c107c, 0x44bcf0cb,  // fX=51.0160980 fY=1511.52478
+        0x424c10c2, 0x44bcf0cb,  // fX=51.0163651 fY=1511.52478
+        0x424c1119, 0x44bcf0ca,  // fX=51.0166969 fY=1511.52466
+    };
+    SkPoint cubicVals[] = {
+        {51.0161362f, 1511.52478f },
+        {51.0160980f, 1511.52478f },
+        {51.0163651f, 1511.52478f },
+        {51.0166969f, 1511.52466f },
+    };
+    SkPaint paint;
+
+    paint.setStyle(SkPaint::kStroke_Style);
+    paint.setStrokeWidth(0.394537568f);
+    SkPath path, fillPath;
+    path.moveTo(cubicVals[0]);
+    path.cubicTo(cubicVals[1], cubicVals[2], cubicVals[3]);
+    paint.getFillPath(path, &fillPath);
+    path.reset();
+    path.moveTo(SkBits2Float(hexCubicVals[0]), SkBits2Float(hexCubicVals[1]));
+    path.cubicTo(SkBits2Float(hexCubicVals[2]), SkBits2Float(hexCubicVals[3]),
+            SkBits2Float(hexCubicVals[4]), SkBits2Float(hexCubicVals[5]),
+            SkBits2Float(hexCubicVals[6]), SkBits2Float(hexCubicVals[7]));
+    paint.getFillPath(path, &fillPath);
+}
+
 static void test_strokerect(skiatest::Reporter* reporter) {
     const SkScalar width = SkIntToScalar(10);
     SkPaint paint;
@@ -56,5 +85,6 @@ static void test_strokerect(skiatest::Reporter* reporter) {
 }
 
 DEF_TEST(Stroke, reporter) {
+    test_strokecubic(reporter);
     test_strokerect(reporter);
 }