From 63c684a8a609d39da11b4a656223cebf52ca85dc Mon Sep 17 00:00:00 2001 From: caryclark Date: Wed, 25 Feb 2015 09:04:04 -0800 Subject: [PATCH] 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 --- gm/bitmapshader.cpp | 5 +- gm/circularclips.cpp | 5 +- gm/complexclip2.cpp | 23 +- gm/picture.cpp | 8 +- gm/pictureshader.cpp | 10 +- gm/shadows.cpp | 4 +- gm/simpleaaclip.cpp | 4 +- gm/strokes.cpp | 5 +- gyp/SampleApp.gyp | 1 + include/core/SkPath.h | 1 + samplecode/SampleApp.cpp | 4 + samplecode/SampleCode.h | 4 +- samplecode/SamplePathEffects.cpp | 5 +- samplecode/SamplePathFuzz.cpp | 651 +++++++++++++++++++++++++++++++++++++++ samplecode/SampleStrokePath.cpp | 5 +- samplecode/SampleTextOnPath.cpp | 4 +- src/core/SkPath.cpp | 1 + src/core/SkStroke.cpp | 53 ++-- tests/StrokeTest.cpp | 30 ++ 19 files changed, 765 insertions(+), 58 deletions(-) create mode 100644 samplecode/SamplePathFuzz.cpp diff --git a/gm/bitmapshader.cpp b/gm/bitmapshader.cpp index 8085f5c..ac8bf66 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 ec766fb..614ebb6 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 a55d073..361b1c0 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 b07a596..5432fc9 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 630ecd8..3f184ec 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 3ecbdd8..66ad32e 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 950a1c0..8a18f48 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 af01b91..cadd0d6 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 cbe9e88..9caeeca 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 2d1a8e3..7444cc9 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 17e8623..2b31830 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 e65919a..4152f54 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 a5f91c2..f1574fb 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 0000000..d6b11c5 --- /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* 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 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 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 4f6e3cc..00e5821 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 ac889c3..95ae548 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 0b796fc..2babe70 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 29da19f..062406a 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 15220c4..80ca317 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); } -- 2.7.4