diff options
48 files changed, 256 insertions, 259 deletions
diff --git a/bench/DashBench.cpp b/bench/DashBench.cpp index 43db54c092..e3d8364013 100644 --- a/bench/DashBench.cpp +++ b/bench/DashBench.cpp @@ -72,7 +72,9 @@ protected: SkPath path; this->makePath(&path); - paint.setPathEffect(SkDashPathEffect::Make(fIntervals.begin(), fIntervals.count(), 0)); + SkAutoTUnref<SkPathEffect> effect(SkDashPathEffect::Create(fIntervals.begin(), + fIntervals.count(), 0)); + paint.setPathEffect(effect); if (fDoClip) { SkRect r = path.getBounds(); @@ -177,7 +179,7 @@ static void make_cubic(SkPath* path) { class MakeDashBench : public Benchmark { SkString fName; SkPath fPath; - sk_sp<SkPathEffect> fPE; + SkAutoTUnref<SkPathEffect> fPE; public: MakeDashBench(void (*proc)(SkPath*), const char name[]) { @@ -185,7 +187,7 @@ public: proc(&fPath); SkScalar vals[] = { SkIntToScalar(4), SkIntToScalar(4) }; - fPE = SkDashPathEffect::Make(vals, 2, 0); + fPE.reset(SkDashPathEffect::Create(vals, 2, 0)); } protected: @@ -214,7 +216,7 @@ class DashLineBench : public Benchmark { SkString fName; SkScalar fStrokeWidth; bool fIsRound; - sk_sp<SkPathEffect> fPE; + SkAutoTUnref<SkPathEffect> fPE; public: DashLineBench(SkScalar width, bool isRound) { @@ -223,7 +225,7 @@ public: fIsRound = isRound; SkScalar vals[] = { SK_Scalar1, SK_Scalar1 }; - fPE = SkDashPathEffect::Make(vals, 2, 0); + fPE.reset(SkDashPathEffect::Create(vals, 2, 0)); } protected: @@ -252,7 +254,7 @@ class DrawPointsDashingBench : public Benchmark { int fStrokeWidth; bool fDoAA; - sk_sp<SkPathEffect> fPathEffect; + SkAutoTUnref<SkPathEffect> fPathEffect; public: DrawPointsDashingBench(int dashLength, int strokeWidth, bool doAA) @@ -262,7 +264,7 @@ public: fDoAA = doAA; SkScalar vals[] = { SkIntToScalar(dashLength), SkIntToScalar(dashLength) }; - fPathEffect = SkDashPathEffect::Make(vals, 2, SK_Scalar1); + fPathEffect.reset(SkDashPathEffect::Create(vals, 2, SK_Scalar1)); } protected: @@ -299,7 +301,7 @@ class GiantDashBench : public Benchmark { SkString fName; SkScalar fStrokeWidth; SkPoint fPts[2]; - sk_sp<SkPathEffect> fPathEffect; + SkAutoTUnref<SkPathEffect> fPathEffect; public: enum LineType { @@ -322,7 +324,8 @@ public: // deliberately pick intervals that won't be caught by asPoints(), so // we can test the filterPath code-path. const SkScalar intervals[] = { 20, 10, 10, 10 }; - fPathEffect = SkDashPathEffect::Make(intervals, SK_ARRAY_COUNT(intervals), 0); + fPathEffect.reset(SkDashPathEffect::Create(intervals, + SK_ARRAY_COUNT(intervals), 0)); SkScalar cx = 640 / 2; // center X SkScalar cy = 480 / 2; // center Y @@ -378,7 +381,7 @@ class DashGridBench : public Benchmark { int fStrokeWidth; bool fDoAA; - sk_sp<SkPathEffect> fPathEffect; + SkAutoTUnref<SkPathEffect> fPathEffect; public: DashGridBench(int dashLength, int strokeWidth, bool doAA) { @@ -387,7 +390,7 @@ public: fDoAA = doAA; SkScalar vals[] = { SkIntToScalar(dashLength), SkIntToScalar(dashLength) }; - fPathEffect = SkDashPathEffect::Make(vals, 2, SK_Scalar1); + fPathEffect.reset(SkDashPathEffect::Create(vals, 2, SK_Scalar1)); } protected: diff --git a/gm/arcto.cpp b/gm/arcto.cpp index fcbc3d5926..584fca3c4f 100644 --- a/gm/arcto.cpp +++ b/gm/arcto.cpp @@ -223,6 +223,6 @@ DEF_SIMPLE_GM(bug583299, canvas, 300, 300) { SkScalar length = meas.getLength(); SkScalar intervals[] = {0, length }; int intervalCount = (int) SK_ARRAY_COUNT(intervals); - p.setPathEffect(SkDashPathEffect::Make(intervals, intervalCount, 0)); + p.setPathEffect(SkDashPathEffect::Create(intervals, intervalCount, 0))->unref(); canvas->drawPath(path, p); } diff --git a/gm/bug530095.cpp b/gm/bug530095.cpp index fa88c01b8f..76f6bc8f2e 100644 --- a/gm/bug530095.cpp +++ b/gm/bug530095.cpp @@ -20,13 +20,13 @@ DEF_SIMPLE_GM(bug530095, canvas, 900, 1200) { paint.setStrokeWidth(26); SkScalar intervals[] = {700, 700 }; int intervalCount = (int) SK_ARRAY_COUNT(intervals); - paint.setPathEffect(SkDashPathEffect::Make(intervals, intervalCount, -40)); + paint.setPathEffect(SkDashPathEffect::Create(intervals, intervalCount, -40))->unref(); canvas->drawPath(path1, paint); paint.setStrokeWidth(0.26f); SkScalar smIntervals[] = {7, 7 }; int smIntervalCount = (int) SK_ARRAY_COUNT(smIntervals); - paint.setPathEffect(SkDashPathEffect::Make(smIntervals, smIntervalCount, -0.40f)); + paint.setPathEffect(SkDashPathEffect::Create(smIntervals, smIntervalCount, -0.40f))->unref(); canvas->save(); canvas->scale(100, 100); canvas->translate(4, 0); @@ -34,14 +34,14 @@ DEF_SIMPLE_GM(bug530095, canvas, 900, 1200) { canvas->restore(); paint.setStrokeWidth(26); - paint.setPathEffect(SkDashPathEffect::Make(intervals, intervalCount, 0)); + paint.setPathEffect(SkDashPathEffect::Create(intervals, intervalCount, 0))->unref(); canvas->save(); canvas->translate(0, 400); canvas->drawPath(path1, paint); canvas->restore(); paint.setStrokeWidth(0.26f); - paint.setPathEffect(SkDashPathEffect::Make(smIntervals, smIntervalCount, 0)); + paint.setPathEffect(SkDashPathEffect::Create(smIntervals, smIntervalCount, 0))->unref(); canvas->scale(100, 100); canvas->translate(4, 4); canvas->drawPath(path2, paint); @@ -54,7 +54,8 @@ DEF_SIMPLE_GM(bug591993, canvas, 40, 140) { p.setStyle(SkPaint::kStroke_Style); p.setStrokeCap(SkPaint::kRound_Cap); p.setStrokeWidth(10); - const SkScalar intervals[] = { 100, 100 }; - p.setPathEffect(SkDashPathEffect::Make(intervals, SK_ARRAY_COUNT(intervals), 100)); + SkScalar intervals[] = { 100, 100 }; + SkPathEffect* dash = SkDashPathEffect::Create(intervals, SK_ARRAY_COUNT(intervals), 100); + p.setPathEffect(dash)->unref(); canvas->drawLine(20, 20, 120, 20, p); } diff --git a/gm/dashcircle.cpp b/gm/dashcircle.cpp index a02c7d0f7b..cddd913723 100644 --- a/gm/dashcircle.cpp +++ b/gm/dashcircle.cpp @@ -68,7 +68,7 @@ DEF_SIMPLE_GM(dashcircle, canvas, 900, 1200) { for (int index = 0; index < dashExample.length; ++index) { intervals[index] = dashExample.pattern[index] * dashLength; } - p.setPathEffect(SkDashPathEffect::Make(intervals, intervalCount, 0)); + p.setPathEffect(SkDashPathEffect::Create(intervals, intervalCount, 0))->unref(); canvas->drawPath(circle, p); canvas->translate(0, radius * 2 + 50); } diff --git a/gm/dashcubics.cpp b/gm/dashcubics.cpp index 7736f2b47c..1773303f0c 100644 --- a/gm/dashcubics.cpp +++ b/gm/dashcubics.cpp @@ -14,24 +14,26 @@ /* * Inspired by http://code.google.com/p/chromium/issues/detail?id=112145 */ -static void flower(SkCanvas* canvas, const SkPath& path, SkScalar intervals[2], - SkPaint::Join join) { - SkPaint paint; - paint.setAntiAlias(true); - paint.setStyle(SkPaint::kStroke_Style); - paint.setStrokeJoin(join); - paint.setStrokeWidth(42); - canvas->drawPath(path, paint); +static void flower(SkCanvas* canvas, const SkPath& path, + SkScalar intervals[2], SkPaint::Join join) { + SkPathEffect* pe = SkDashPathEffect::Create(intervals, 2, 0); - paint.setColor(SK_ColorRED); - paint.setStrokeWidth(21); - paint.setPathEffect(SkDashPathEffect::Make(intervals, 2, 0)); - canvas->drawPath(path, paint); + SkPaint paint; + paint.setAntiAlias(true); + paint.setStyle(SkPaint::kStroke_Style); + paint.setStrokeJoin(join); + paint.setStrokeWidth(42); + canvas->drawPath(path, paint); - paint.setColor(SK_ColorGREEN); - paint.setPathEffect(nullptr); - paint.setStrokeWidth(0); - canvas->drawPath(path, paint); + paint.setColor(SK_ColorRED); + paint.setStrokeWidth(21); + paint.setPathEffect(pe)->unref(); + canvas->drawPath(path, paint); + + paint.setColor(SK_ColorGREEN); + paint.setPathEffect(nullptr); + paint.setStrokeWidth(0); + canvas->drawPath(path, paint); } DEF_SIMPLE_GM(dashcubics, canvas, 860, 700) { diff --git a/gm/dashing.cpp b/gm/dashing.cpp index 6cb1dea66c..c728d15a1a 100644 --- a/gm/dashing.cpp +++ b/gm/dashing.cpp @@ -21,7 +21,8 @@ static void drawline(SkCanvas* canvas, int on, int off, const SkPaint& paint, SkIntToScalar(off), }; - p.setPathEffect(SkDashPathEffect::Make(intervals, 2, phase)); + SkAutoTUnref<SkPathEffect> effect(SkDashPathEffect::Create(intervals, 2, phase)); + p.setPathEffect(effect); canvas->drawLine(startX, startY, finalX, finalY, p); } @@ -174,7 +175,7 @@ protected: vals[i] = SkIntToScalar(*intervals++); } SkScalar phase = vals[0] / 2; - paint.setPathEffect(SkDashPathEffect::Make(vals, count, phase)); + paint.setPathEffect(SkDashPathEffect::Create(vals, count, phase))->unref(); for (size_t x = 0; x < SK_ARRAY_COUNT(gProc); ++x) { SkPath path; @@ -222,7 +223,7 @@ protected: SkScalar intervals[2] = { dashLength, dashLength }; - p.setPathEffect(SkDashPathEffect::Make(intervals, 2, phase)); + p.setPathEffect(SkDashPathEffect::Create(intervals, 2, phase))->unref(); SkPoint pts[2]; @@ -498,7 +499,7 @@ DEF_SIMPLE_GM(longpathdash, canvas, 512, 512) { p.setStyle(SkPaint::kStroke_Style); p.setStrokeWidth(1); const SkScalar intervals[] = { 1, 1 }; - p.setPathEffect(SkDashPathEffect::Make(intervals, SK_ARRAY_COUNT(intervals), 0)); + p.setPathEffect(SkDashPathEffect::Create(intervals, SK_ARRAY_COUNT(intervals), 0))->unref(); canvas->drawPath(lines, p); } @@ -509,7 +510,7 @@ DEF_SIMPLE_GM(longlinedash, canvas, 512, 512) { p.setStrokeWidth(80); const SkScalar intervals[] = { 2, 2 }; - p.setPathEffect(SkDashPathEffect::Make(intervals, SK_ARRAY_COUNT(intervals), 0)); + p.setPathEffect(SkDashPathEffect::Create(intervals, SK_ARRAY_COUNT(intervals), 0))->unref(); canvas->drawRect(SkRect::MakeXYWH(-10000, 100, 20000, 20), p); } @@ -539,7 +540,7 @@ DEF_SIMPLE_GM(dashtextcaps, canvas, 512, 512) { p.setARGB(0xff, 0xbb, 0x00, 0x00); sk_tool_utils::set_portable_typeface(&p); const SkScalar intervals[] = { 12, 12 }; - p.setPathEffect(SkDashPathEffect::Make(intervals, SK_ARRAY_COUNT(intervals), 0)); + p.setPathEffect(SkDashPathEffect::Create(intervals, SK_ARRAY_COUNT(intervals), 0))->unref(); canvas->drawText("Sausages", 8, 10, 90, p); canvas->drawLine(8, 120, 456, 120, p); } diff --git a/gm/pathcontourstart.cpp b/gm/pathcontourstart.cpp index dbda7c3cae..de3644c9f1 100644 --- a/gm/pathcontourstart.cpp +++ b/gm/pathcontourstart.cpp @@ -26,11 +26,14 @@ public: intervals.push_back(len); } + SkAutoTUnref<SkPathEffect> effect( + SkDashPathEffect::Create(intervals.begin(), intervals.count(), 0)); + fDashPaint.setAntiAlias(true); fDashPaint.setStyle(SkPaint::kStroke_Style); fDashPaint.setStrokeWidth(6); fDashPaint.setColor(0xff008000); - fDashPaint.setPathEffect(SkDashPathEffect::Make(intervals.begin(), intervals.count(), 0)); + fDashPaint.setPathEffect(effect); fPointsPaint.setColor(0xff800000); fPointsPaint.setStrokeWidth(3); diff --git a/gm/patheffects.cpp b/gm/patheffects.cpp index 9821b3a35d..517d02e547 100644 --- a/gm/patheffects.cpp +++ b/gm/patheffects.cpp @@ -17,14 +17,15 @@ namespace skiagm { static void compose_pe(SkPaint* paint) { SkPathEffect* pe = paint->getPathEffect(); - sk_sp<SkPathEffect> corner = SkCornerPathEffect::Make(25); - sk_sp<SkPathEffect> compose; + SkPathEffect* corner = SkCornerPathEffect::Create(25); + SkPathEffect* compose; if (pe) { - compose = SkComposePathEffect::Make(sk_ref_sp(pe), corner); + compose = SkComposePathEffect::Create(pe, corner); + corner->unref(); } else { compose = corner; } - paint->setPathEffect(compose); + paint->setPathEffect(compose)->unref(); } static void hair_pe(SkPaint* paint) { @@ -44,7 +45,8 @@ static void stroke_pe(SkPaint* paint) { static void dash_pe(SkPaint* paint) { SkScalar inter[] = { 20, 10, 10, 10 }; paint->setStrokeWidth(12); - paint->setPathEffect(SkDashPathEffect::Make(inter, SK_ARRAY_COUNT(inter), 0)); + paint->setPathEffect(SkDashPathEffect::Create(inter, SK_ARRAY_COUNT(inter), + 0))->unref(); compose_pe(paint); } @@ -67,8 +69,8 @@ static void one_d_pe(SkPaint* paint) { path.offset(SkIntToScalar(-6), 0); scale(&path, 1.5f); - paint->setPathEffect(SkPath1DPathEffect::Make(path, SkIntToScalar(21), 0, - SkPath1DPathEffect::kRotate_Style)); + paint->setPathEffect(SkPath1DPathEffect::Create(path, SkIntToScalar(21), 0, + SkPath1DPathEffect::kRotate_Style))->unref(); compose_pe(paint); } @@ -81,21 +83,21 @@ static void fill_pe(SkPaint* paint) { } static void discrete_pe(SkPaint* paint) { - paint->setPathEffect(SkDiscretePathEffect::Make(10, 4)); + paint->setPathEffect(SkDiscretePathEffect::Create(10, 4))->unref(); } -static sk_sp<SkPathEffect> MakeTileEffect() { +static SkPathEffect* MakeTileEffect() { SkMatrix m; m.setScale(SkIntToScalar(12), SkIntToScalar(12)); SkPath path; path.addCircle(0, 0, SkIntToScalar(5)); - return SkPath2DPathEffect::Make(m, path); + return SkPath2DPathEffect::Create(m, path); } static void tile_pe(SkPaint* paint) { - paint->setPathEffect(MakeTileEffect()); + paint->setPathEffect(MakeTileEffect())->unref(); } static const PE_Proc gPE2[] = { fill_pe, discrete_pe, tile_pe }; diff --git a/gm/strokes.cpp b/gm/strokes.cpp index f64a87640c..261db9c69d 100644 --- a/gm/strokes.cpp +++ b/gm/strokes.cpp @@ -128,7 +128,7 @@ protected: canvas->drawPath(fMoveZfPath, strokePaint); dashPaint = strokePaint; const SkScalar intervals[] = { 0, 10 }; - dashPaint.setPathEffect(SkDashPathEffect::Make(intervals, 2, 0)); + dashPaint.setPathEffect(SkDashPathEffect::Create(intervals, 2, 0))->unref(); SkPath fillPath; dashPaint.getFillPath(fDashedfPath, &fillPath); canvas->translate(0, 20); diff --git a/gm/stroketext.cpp b/gm/stroketext.cpp index b247d8a711..d0a9882256 100644 --- a/gm/stroketext.cpp +++ b/gm/stroketext.cpp @@ -55,7 +55,7 @@ static void draw_text_set(SkCanvas* canvas, const SkPaint& paint) { canvas->translate(200, 0); SkPaint p(paint); - p.setPathEffect(SkDashPathEffect::Make(intervals, SK_ARRAY_COUNT(intervals), phase)); + p.setPathEffect(SkDashPathEffect::Create(intervals, SK_ARRAY_COUNT(intervals), phase))->unref(); draw_text_stroked(canvas, p, 10); } diff --git a/gm/textbloblooper.cpp b/gm/textbloblooper.cpp index d54490272c..8d462c9b09 100644 --- a/gm/textbloblooper.cpp +++ b/gm/textbloblooper.cpp @@ -66,18 +66,18 @@ static void mask_filter(SkPaint* paint) { paint->setMaskFilter(mf)->unref(); } -static sk_sp<SkPathEffect> make_tile_effect() { +static SkPathEffect* make_tile_effect() { SkMatrix m; m.setScale(1.f, 1.f); SkPath path; path.addCircle(0, 0, SkIntToScalar(5)); - return SkPath2DPathEffect::Make(m, path); + return SkPath2DPathEffect::Create(m, path); } static void path_effect(SkPaint* paint) { - paint->setPathEffect(make_tile_effect()); + paint->setPathEffect(make_tile_effect())->unref(); } static sk_sp<SkShader> make_shader(const SkRect& bounds) { diff --git a/gm/texteffects.cpp b/gm/texteffects.cpp index aa3d3758ab..6ad3d23bf2 100644 --- a/gm/texteffects.cpp +++ b/gm/texteffects.cpp @@ -77,7 +77,7 @@ static void r4(SkLayerRasterizer::Builder* rastBuilder, SkPaint& p) { static void r5(SkLayerRasterizer::Builder* rastBuilder, SkPaint& p) { rastBuilder->addLayer(p); - p.setPathEffect(SkDiscretePathEffect::Make(SK_Scalar1*4, SK_Scalar1*3)); + p.setPathEffect(SkDiscretePathEffect::Create(SK_Scalar1*4, SK_Scalar1*3))->unref(); p.setXfermodeMode(SkXfermode::kSrcOut_Mode); rastBuilder->addLayer(p); } @@ -95,17 +95,17 @@ static void r6(SkLayerRasterizer::Builder* rastBuilder, SkPaint& p) { #include "Sk2DPathEffect.h" -static sk_sp<SkPathEffect> MakeDotEffect(SkScalar radius, const SkMatrix& matrix) { +static SkPathEffect* MakeDotEffect(SkScalar radius, const SkMatrix& matrix) { SkPath path; path.addCircle(0, 0, radius); - return SkPath2DPathEffect::Make(matrix, path); + return SkPath2DPathEffect::Create(matrix, path); } static void r7(SkLayerRasterizer::Builder* rastBuilder, SkPaint& p) { SkMatrix lattice; lattice.setScale(SK_Scalar1*6, SK_Scalar1*6, 0, 0); lattice.postSkew(SK_Scalar1/3, 0, 0, 0); - p.setPathEffect(MakeDotEffect(SK_Scalar1*4, lattice)); + p.setPathEffect(MakeDotEffect(SK_Scalar1*4, lattice))->unref(); rastBuilder->addLayer(p); } @@ -115,7 +115,7 @@ static void r8(SkLayerRasterizer::Builder* rastBuilder, SkPaint& p) { SkMatrix lattice; lattice.setScale(SK_Scalar1*6, SK_Scalar1*6, 0, 0); lattice.postSkew(SK_Scalar1/3, 0, 0, 0); - p.setPathEffect(MakeDotEffect(SK_Scalar1*2, lattice)); + p.setPathEffect(MakeDotEffect(SK_Scalar1*2, lattice))->unref(); p.setXfermodeMode(SkXfermode::kClear_Mode); rastBuilder->addLayer(p); @@ -132,7 +132,7 @@ static void r9(SkLayerRasterizer::Builder* rastBuilder, SkPaint& p) { SkMatrix lattice; lattice.setScale(SK_Scalar1, SK_Scalar1*6, 0, 0); lattice.postRotate(SkIntToScalar(30), 0, 0); - p.setPathEffect(SkLine2DPathEffect::Make(SK_Scalar1*2, lattice)); + p.setPathEffect(SkLine2DPathEffect::Create(SK_Scalar1*2, lattice))->unref(); p.setXfermodeMode(SkXfermode::kClear_Mode); rastBuilder->addLayer(p); diff --git a/gyp/skia_for_android_framework_defines.gypi b/gyp/skia_for_android_framework_defines.gypi index d6324bd40a..10995f4c0e 100644 --- a/gyp/skia_for_android_framework_defines.gypi +++ b/gyp/skia_for_android_framework_defines.gypi @@ -20,7 +20,6 @@ 'SK_SUPPORT_LEGACY_GRADIENT_DITHERING', 'SK_SUPPORT_LEGACY_DRAWFILTER', 'SK_SUPPORT_LEGACY_CREATESHADER_PTR', - 'SK_SUPPORT_LEGACY_PATHEFFECT_PTR', ], }, } diff --git a/include/core/SkPaint.h b/include/core/SkPaint.h index 9dc9f91ac3..39ee1e0de1 100644 --- a/include/core/SkPaint.h +++ b/include/core/SkPaint.h @@ -561,13 +561,8 @@ public: paint @return effect */ + SkPathEffect* setPathEffect(SkPathEffect* effect); void setPathEffect(sk_sp<SkPathEffect>); -#ifdef SK_SUPPORT_LEGACY_PATHEFFECT_PTR - SkPathEffect* setPathEffect(SkPathEffect* effect) { - this->setPathEffect(sk_ref_sp(effect)); - return effect; - } -#endif /** Get the paint's maskfilter object. <p /> diff --git a/include/core/SkPathEffect.h b/include/core/SkPathEffect.h index 405a504774..a77b9467e4 100644 --- a/include/core/SkPathEffect.h +++ b/include/core/SkPathEffect.h @@ -18,10 +18,6 @@ class SkPath; class SkStrokeRec; -#ifndef SK_SUPPORT_LEGACY_PATHEFFECT_PTR - #define SK_SUPPORT_LEGACY_PATHEFFECT_PTR -#endif - /** \class SkPathEffect SkPathEffect is the base class for objects in the SkPaint that affect @@ -158,14 +154,16 @@ private: for managing the lifetimes of its two arguments. */ class SkPairPathEffect : public SkPathEffect { +public: + virtual ~SkPairPathEffect(); + protected: - SkPairPathEffect(sk_sp<SkPathEffect> pe0, sk_sp<SkPathEffect> pe1); + SkPairPathEffect(SkPathEffect* pe0, SkPathEffect* pe1); void flatten(SkWriteBuffer&) const override; // these are visible to our subclasses - sk_sp<SkPathEffect> fPE0; - sk_sp<SkPathEffect> fPE1; + SkPathEffect* fPE0, *fPE1; SK_TO_STRING_OVERRIDE() @@ -185,22 +183,16 @@ public: The reference counts for outer and inner are both incremented in the constructor, and decremented in the destructor. */ - static sk_sp<SkPathEffect> Make(sk_sp<SkPathEffect> outer, sk_sp<SkPathEffect> inner) { + static SkPathEffect* Create(SkPathEffect* outer, SkPathEffect* inner) { if (!outer) { - return inner; + return SkSafeRef(inner); } if (!inner) { - return outer; + return SkSafeRef(outer); } - return sk_sp<SkPathEffect>(new SkComposePathEffect(outer, inner)); + return new SkComposePathEffect(outer, inner); } -#ifdef SK_SUPPORT_LEGACY_PATHEFFECT_PTR - static SkPathEffect* Create(SkPathEffect* outer, SkPathEffect* inner) { - return Make(sk_ref_sp(outer), sk_ref_sp(inner)).release(); - } -#endif - virtual bool filterPath(SkPath* dst, const SkPath& src, SkStrokeRec*, const SkRect*) const override; @@ -212,8 +204,7 @@ public: #endif protected: - SkComposePathEffect(sk_sp<SkPathEffect> outer, sk_sp<SkPathEffect> inner) - : INHERITED(outer, inner) {} + SkComposePathEffect(SkPathEffect* outer, SkPathEffect* inner) : INHERITED(outer, inner) {} private: // illegal @@ -235,21 +226,16 @@ public: The reference counts for first and second are both incremented in the constructor, and decremented in the destructor. */ - static sk_sp<SkPathEffect> Make(sk_sp<SkPathEffect> first, sk_sp<SkPathEffect> second) { + static SkPathEffect* Create(SkPathEffect* first, SkPathEffect* second) { if (!first) { - return second; + return SkSafeRef(second); } if (!second) { - return first; + return SkSafeRef(first); } - return sk_sp<SkPathEffect>(new SkSumPathEffect(first, second)); + return new SkSumPathEffect(first, second); } -#ifdef SK_SUPPORT_LEGACY_PATHEFFECT_PTR - static SkPathEffect* Create(SkPathEffect* first, SkPathEffect* second) { - return Make(sk_ref_sp(first), sk_ref_sp(second)).release(); - } -#endif virtual bool filterPath(SkPath* dst, const SkPath& src, SkStrokeRec*, const SkRect*) const override; @@ -261,8 +247,7 @@ public: #endif protected: - SkSumPathEffect(sk_sp<SkPathEffect> first, sk_sp<SkPathEffect> second) - : INHERITED(first, second) {} + SkSumPathEffect(SkPathEffect* first, SkPathEffect* second) : INHERITED(first, second) {} private: // illegal diff --git a/include/effects/Sk1DPathEffect.h b/include/effects/Sk1DPathEffect.h index d5315a8735..03c6966943 100644 --- a/include/effects/Sk1DPathEffect.h +++ b/include/effects/Sk1DPathEffect.h @@ -56,13 +56,7 @@ public: @param style how to transform path at each point (based on the current position and tangent) */ - static sk_sp<SkPathEffect> Make(const SkPath& path, SkScalar advance, SkScalar phase, Style); - -#ifdef SK_SUPPORT_LEGACY_PATHEFFECT_PTR - static SkPathEffect* Create(const SkPath& path, SkScalar advance, SkScalar phase, Style s) { - return Make(path, advance, phase, s).release(); - } -#endif + static SkPathEffect* Create(const SkPath& path, SkScalar advance, SkScalar phase, Style); virtual bool filterPath(SkPath*, const SkPath&, SkStrokeRec*, const SkRect*) const override; diff --git a/include/effects/Sk2DPathEffect.h b/include/effects/Sk2DPathEffect.h index 823a6ad9d8..73da83c4b9 100644 --- a/include/effects/Sk2DPathEffect.h +++ b/include/effects/Sk2DPathEffect.h @@ -55,8 +55,8 @@ private: class SK_API SkLine2DPathEffect : public Sk2DPathEffect { public: - static sk_sp<SkPathEffect> Make(SkScalar width, const SkMatrix& matrix) { - return sk_sp<SkPathEffect>(new SkLine2DPathEffect(width, matrix)); + static SkPathEffect* Create(SkScalar width, const SkMatrix& matrix) { + return new SkLine2DPathEffect(width, matrix); } virtual bool filterPath(SkPath* dst, const SkPath& src, @@ -84,8 +84,8 @@ public: * Stamp the specified path to fill the shape, using the matrix to define * the latice. */ - static sk_sp<SkPathEffect> Make(const SkMatrix& matrix, const SkPath& path) { - return sk_sp<SkPathEffect>(new SkPath2DPathEffect(matrix, path)); + static SkPathEffect* Create(const SkMatrix& matrix, const SkPath& path) { + return new SkPath2DPathEffect(matrix, path); } SK_TO_STRING_OVERRIDE() diff --git a/include/effects/SkArcToPathEffect.h b/include/effects/SkArcToPathEffect.h index fcf4a3a5dc..4716ea125d 100644 --- a/include/effects/SkArcToPathEffect.h +++ b/include/effects/SkArcToPathEffect.h @@ -15,11 +15,11 @@ public: /** radius must be > 0 to have an effect. It specifies the distance from each corner that should be "rounded". */ - static sk_sp<SkPathEffect> Make(SkScalar radius) { + static SkPathEffect* Create(SkScalar radius) { if (radius <= 0) { return NULL; } - return sk_sp<SkPathEffect>(new SkArcToPathEffect(radius)); + return new SkArcToPathEffect(radius); } bool filterPath(SkPath* dst, const SkPath& src, SkStrokeRec*, const SkRect*) const override; diff --git a/include/effects/SkCornerPathEffect.h b/include/effects/SkCornerPathEffect.h index cf03463530..13095f0e6c 100644 --- a/include/effects/SkCornerPathEffect.h +++ b/include/effects/SkCornerPathEffect.h @@ -20,15 +20,7 @@ public: /** radius must be > 0 to have an effect. It specifies the distance from each corner that should be "rounded". */ - static sk_sp<SkPathEffect> Make(SkScalar radius) { - return sk_sp<SkPathEffect>(new SkCornerPathEffect(radius)); - } - -#ifdef SK_SUPPORT_LEGACY_PATHEFFECT_PTR - static SkPathEffect* Create(SkScalar radius) { - return Make(radius).release(); - } -#endif + static SkPathEffect* Create(SkScalar radius) { return new SkCornerPathEffect(radius); } virtual bool filterPath(SkPath* dst, const SkPath& src, SkStrokeRec*, const SkRect*) const override; diff --git a/include/effects/SkDashPathEffect.h b/include/effects/SkDashPathEffect.h index ccb1a4e440..08b0a4693f 100644 --- a/include/effects/SkDashPathEffect.h +++ b/include/effects/SkDashPathEffect.h @@ -36,13 +36,7 @@ public: Note: only affects stroked paths. */ - static sk_sp<SkPathEffect> Make(const SkScalar intervals[], int count, SkScalar phase); - -#ifdef SK_SUPPORT_LEGACY_PATHEFFECT_PTR - static SkPathEffect* Create(const SkScalar intervals[], int count, SkScalar phase) { - return Make(intervals, count, phase).release(); - } -#endif + static SkPathEffect* Create(const SkScalar intervals[], int count, SkScalar phase); virtual bool filterPath(SkPath* dst, const SkPath& src, SkStrokeRec*, const SkRect*) const override; diff --git a/include/effects/SkDiscretePathEffect.h b/include/effects/SkDiscretePathEffect.h index 78d4516ee6..a49e2d89a7 100644 --- a/include/effects/SkDiscretePathEffect.h +++ b/include/effects/SkDiscretePathEffect.h @@ -29,13 +29,9 @@ public: they can pass in a different seedAssist to get a different set of path segments. */ - static sk_sp<SkPathEffect> Make(SkScalar segLength, SkScalar dev, uint32_t seedAssist = 0); - -#ifdef SK_SUPPORT_LEGACY_PATHEFFECT_PTR static SkPathEffect* Create(SkScalar segLength, SkScalar deviation, uint32_t seedAssist = 0) { - return Make(segLength, deviation, seedAssist).release(); + return new SkDiscretePathEffect(segLength, deviation, seedAssist); } -#endif virtual bool filterPath(SkPath* dst, const SkPath& src, SkStrokeRec*, const SkRect*) const override; diff --git a/samplecode/ClockFaceView.cpp b/samplecode/ClockFaceView.cpp index f5b43fb82f..11684e11ad 100644 --- a/samplecode/ClockFaceView.cpp +++ b/samplecode/ClockFaceView.cpp @@ -132,16 +132,16 @@ private: SkFlattenable* InverseFillPE::CreateProc(SkReadBuffer& buffer) { return new InverseFillPE; } -static sk_sp<SkPathEffect> makepe(float interp, SkTDArray<SkPoint>* pts) { +static SkPathEffect* makepe(float interp, SkTDArray<SkPoint>* pts) { SkMatrix lattice; SkScalar rad = 3 + SkIntToScalar(4) * (1 - interp); lattice.setScale(rad*2, rad*2, 0, 0); lattice.postSkew(SK_Scalar1/3, 0, 0, 0); - return sk_make_sp<Dot2DPathEffect>(rad, lattice, pts); + return new Dot2DPathEffect(rad, lattice, pts); } static void r7(SkLayerRasterizer::Builder* rastBuilder, SkPaint& p, SkScalar interp) { - p.setPathEffect(makepe(SkScalarToFloat(interp), nullptr)); + p.setPathEffect(makepe(SkScalarToFloat(interp), nullptr))->unref(); rastBuilder->addLayer(p); #if 0 p.setPathEffect(new InverseFillPE())->unref(); @@ -201,7 +201,7 @@ protected: static void drawdots(SkCanvas* canvas, const SkPaint& orig) { SkTDArray<SkPoint> pts; - auto pe = makepe(0, &pts); + SkPathEffect* pe = makepe(0, &pts); SkStrokeRec rec(SkStrokeRec::kFill_InitStyle); SkPath path, dstPath; @@ -212,7 +212,8 @@ protected: p.setAntiAlias(true); p.setStrokeWidth(10); p.setColor(SK_ColorRED); - canvas->drawPoints(SkCanvas::kPoints_PointMode, pts.count(), pts.begin(), p); + canvas->drawPoints(SkCanvas::kPoints_PointMode, pts.count(), pts.begin(), + p); } virtual void onDraw(SkCanvas* canvas) { diff --git a/samplecode/SampleAll.cpp b/samplecode/SampleAll.cpp index 7c0557fc40..90fc5bdb16 100644 --- a/samplecode/SampleAll.cpp +++ b/samplecode/SampleAll.cpp @@ -141,7 +141,7 @@ static void r4(SkLayerRasterizer::Builder* rastBuilder, SkPaint& p) { static void r5(SkLayerRasterizer::Builder* rastBuilder, SkPaint& p) { rastBuilder->addLayer(p); - p.setPathEffect(SkDiscretePathEffect::Make(SK_Scalar1*4, SK_Scalar1*3)); + p.setPathEffect(SkDiscretePathEffect::Create(SK_Scalar1*4, SK_Scalar1*3))->unref(); p.setXfermodeMode(SkXfermode::kSrcOut_Mode); rastBuilder->addLayer(p); } @@ -184,7 +184,7 @@ static void r7(SkLayerRasterizer::Builder* rastBuilder, SkPaint& p) { SkMatrix lattice; lattice.setScale(SK_Scalar1*6, SK_Scalar1*6, 0, 0); lattice.postSkew(SK_Scalar1/3, 0, 0, 0); - p.setPathEffect(sk_make_sp<Dot2DPathEffect>(SK_Scalar1*4, lattice)); + p.setPathEffect(new Dot2DPathEffect(SK_Scalar1*4, lattice))->unref(); rastBuilder->addLayer(p); } @@ -194,7 +194,7 @@ static void r8(SkLayerRasterizer::Builder* rastBuilder, SkPaint& p) { SkMatrix lattice; lattice.setScale(SK_Scalar1*6, SK_Scalar1*6, 0, 0); lattice.postSkew(SK_Scalar1/3, 0, 0, 0); - p.setPathEffect(sk_make_sp<Dot2DPathEffect>(SK_Scalar1*2, lattice)); + p.setPathEffect(new Dot2DPathEffect(SK_Scalar1*2, lattice))->unref(); p.setXfermodeMode(SkXfermode::kClear_Mode); rastBuilder->addLayer(p); @@ -211,7 +211,7 @@ static void r9(SkLayerRasterizer::Builder* rastBuilder, SkPaint& p) { SkMatrix lattice; lattice.setScale(SK_Scalar1, SK_Scalar1*6, 0, 0); lattice.postRotate(SkIntToScalar(30), 0, 0); - p.setPathEffect(SkLine2DPathEffect::Make(SK_Scalar1*2, lattice)); + p.setPathEffect(SkLine2DPathEffect::Create(SK_Scalar1*2, lattice))->unref(); p.setXfermodeMode(SkXfermode::kClear_Mode); rastBuilder->addLayer(p); @@ -416,7 +416,7 @@ protected: canvas->translate(SkIntToScalar(50), 0); paint.setColor(SK_ColorYELLOW); paint.setShader(linear); - paint.setPathEffect(pathEffectTest()); + paint.setPathEffect(pathEffectTest())->unref(); canvas->drawRect(rect, paint); paint.setPathEffect(nullptr); @@ -481,7 +481,7 @@ protected: return this->INHERITED::onFindClickHandler(x, y, modi); } - sk_sp<SkPathEffect> pathEffectTest() { + SkPathEffect* pathEffectTest() { static const int gXY[] = { 1, 0, 0, -1, 2, -1, 3, 0, 2, 1, 0, 1 }; SkScalar gPhase = 0; SkPath path; @@ -490,11 +490,14 @@ protected: path.lineTo(SkIntToScalar(gXY[i]), SkIntToScalar(gXY[i+1])); path.close(); path.offset(SkIntToScalar(-6), 0); - auto outer = SkPath1DPathEffect::Make(path, SkIntToScalar(12), + SkPathEffect* outer = SkPath1DPathEffect::Create(path, SkIntToScalar(12), gPhase, SkPath1DPathEffect::kRotate_Style); - auto inner = SkDiscretePathEffect::Make(SkIntToScalar(2), + SkPathEffect* inner = SkDiscretePathEffect::Create(SkIntToScalar(2), SkIntToScalar(1)/10); // SkCornerPathEffect(SkIntToScalar(2)); - return SkComposePathEffect::Make(outer, inner); + SkPathEffect* result = SkComposePathEffect::Create(outer, inner); + outer->unref(); + inner->unref(); + return result; } sk_sp<SkShader> shaderTest() { diff --git a/samplecode/SampleFilterFuzz.cpp b/samplecode/SampleFilterFuzz.cpp index fe2fb0b2ff..0dd01e95b2 100644 --- a/samplecode/SampleFilterFuzz.cpp +++ b/samplecode/SampleFilterFuzz.cpp @@ -422,20 +422,22 @@ static SkPath make_path() { return path; } -static sk_sp<SkPathEffect> make_path_effect(bool canBeNull = true) { - sk_sp<SkPathEffect> pathEffect; +static SkPathEffect* make_path_effect(bool canBeNull = true) { + SkPathEffect* pathEffect = nullptr; if (canBeNull && (R(3) == 1)) { return pathEffect; } switch (R(9)) { case 0: - pathEffect = SkArcToPathEffect::Make(make_scalar(true)); + pathEffect = SkArcToPathEffect::Create(make_scalar(true)); break; - case 1: - pathEffect = SkComposePathEffect::Make(make_path_effect(false), - make_path_effect(false)); + case 1: { + SkAutoTUnref<SkPathEffect> outer(make_path_effect(false)); + SkAutoTUnref<SkPathEffect> inner(make_path_effect(false)); + pathEffect = SkComposePathEffect::Create(outer, inner); break; + } case 2: - pathEffect = SkCornerPathEffect::Make(make_scalar()); + pathEffect = SkCornerPathEffect::Create(make_scalar()); break; case 3: { int count = R(10); @@ -443,26 +445,28 @@ static sk_sp<SkPathEffect> make_path_effect(bool canBeNull = true) { for (int i = 0; i < count; ++i) { intervals[i] = make_scalar(); } - pathEffect = SkDashPathEffect::Make(intervals, count, make_scalar()); + pathEffect = SkDashPathEffect::Create(intervals, count, make_scalar()); break; } case 4: - pathEffect = SkDiscretePathEffect::Make(make_scalar(), make_scalar()); + pathEffect = SkDiscretePathEffect::Create(make_scalar(), make_scalar()); break; case 5: - pathEffect = SkPath1DPathEffect::Make(make_path(), make_scalar(), make_scalar(), - make_path_1d_path_effect_style()); + pathEffect = SkPath1DPathEffect::Create(make_path(), + make_scalar(), + make_scalar(), + make_path_1d_path_effect_style()); break; case 6: - pathEffect = SkLine2DPathEffect::Make(make_scalar(), make_matrix()); + pathEffect = SkLine2DPathEffect::Create(make_scalar(), make_matrix()); break; case 7: - pathEffect = SkPath2DPathEffect::Make(make_matrix(), make_path()); + pathEffect = SkPath2DPathEffect::Create(make_matrix(), make_path()); break; case 8: default: - pathEffect = SkSumPathEffect::Make(make_path_effect(false), - make_path_effect(false)); + pathEffect = SkSumPathEffect::Create(make_path_effect(false), + make_path_effect(false)); break; } return pathEffect; diff --git a/samplecode/SamplePath.cpp b/samplecode/SamplePath.cpp index 9ef1c851d8..c977ca0dc2 100644 --- a/samplecode/SamplePath.cpp +++ b/samplecode/SamplePath.cpp @@ -254,13 +254,13 @@ public: fArcToPaint.setStyle(SkPaint::kStroke_Style); fArcToPaint.setStrokeWidth(9); fArcToPaint.setColor(0x800000FF); - fArcToPaint.setPathEffect(SkArcToPathEffect::Make(rad)); + fArcToPaint.setPathEffect(SkArcToPathEffect::Create(rad))->unref(); fCornerPaint.setAntiAlias(true); fCornerPaint.setStyle(SkPaint::kStroke_Style); fCornerPaint.setStrokeWidth(13); fCornerPaint.setColor(SK_ColorGREEN); - fCornerPaint.setPathEffect(SkCornerPathEffect::Make(rad*2)); + fCornerPaint.setPathEffect(SkCornerPathEffect::Create(rad*2))->unref(); fSkeletonPaint.setAntiAlias(true); fSkeletonPaint.setStyle(SkPaint::kStroke_Style); diff --git a/samplecode/SamplePathEffects.cpp b/samplecode/SamplePathEffects.cpp index 10715f382a..a162cf33ad 100644 --- a/samplecode/SamplePathEffects.cpp +++ b/samplecode/SamplePathEffects.cpp @@ -26,10 +26,9 @@ static const int gXY[] = { 4, 0, 0, -4, 8, -4, 12, 0, 8, 4, 0, 4 }; -static sk_sp<SkPathEffect> make_pe(int flags, SkScalar phase) { - if (flags == 1) { - return SkCornerPathEffect::Make(SkIntToScalar(CORNER_RADIUS)); - } +static SkPathEffect* make_pe(int flags, SkScalar phase) { + if (flags == 1) + return SkCornerPathEffect::Create(SkIntToScalar(CORNER_RADIUS)); SkPath path; path.moveTo(SkIntToScalar(gXY[0]), SkIntToScalar(gXY[1])); @@ -38,30 +37,36 @@ static sk_sp<SkPathEffect> make_pe(int flags, SkScalar phase) { path.close(); path.offset(SkIntToScalar(-6), 0); - auto outer = SkPath1DPathEffect::Make(path, 12, phase, SkPath1DPathEffect::kRotate_Style); + SkPathEffect* outer = SkPath1DPathEffect::Create(path, 12, phase, + SkPath1DPathEffect::kRotate_Style); if (flags == 2) return outer; - auto inner = SkCornerPathEffect::Make(SkIntToScalar(CORNER_RADIUS)); + SkPathEffect* inner = SkCornerPathEffect::Create(SkIntToScalar(CORNER_RADIUS)); - return SkComposePathEffect::Make(outer, inner); + SkPathEffect* pe = SkComposePathEffect::Create(outer, inner); + outer->unref(); + inner->unref(); + return pe; } -static sk_sp<SkPathEffect> make_warp_pe(SkScalar phase) { +static SkPathEffect* make_warp_pe(SkScalar phase) { SkPath path; path.moveTo(SkIntToScalar(gXY[0]), SkIntToScalar(gXY[1])); - for (unsigned i = 2; i < SK_ARRAY_COUNT(gXY); i += 2) { + for (unsigned i = 2; i < SK_ARRAY_COUNT(gXY); i += 2) path.lineTo(SkIntToScalar(gXY[i]), SkIntToScalar(gXY[i+1])); - } path.close(); path.offset(SkIntToScalar(-6), 0); - auto outer = SkPath1DPathEffect::Make( + SkPathEffect* outer = SkPath1DPathEffect::Create( path, 12, phase, SkPath1DPathEffect::kMorph_Style); - auto inner = SkCornerPathEffect::Make(SkIntToScalar(CORNER_RADIUS)); + SkPathEffect* inner = SkCornerPathEffect::Create(SkIntToScalar(CORNER_RADIUS)); - return SkComposePathEffect::Make(outer, inner); + SkPathEffect* pe = SkComposePathEffect::Create(outer, inner); + outer->unref(); + inner->unref(); + return pe; } /////////////////////////////////////////////////////////// @@ -138,19 +143,19 @@ protected: canvas->translate(0, 50); paint.setColor(SK_ColorBLUE); - paint.setPathEffect(make_pe(2, fPhase)); + paint.setPathEffect(make_pe(2, fPhase))->unref(); canvas->drawPath(fPath, paint); canvas->translate(0, 50); paint.setARGB(0xFF, 0, 0xBB, 0); - paint.setPathEffect(make_pe(3, fPhase)); + paint.setPathEffect(make_pe(3, fPhase))->unref(); canvas->drawPath(fPath, paint); canvas->translate(0, 50); paint.setARGB(0xFF, 0, 0, 0); - paint.setPathEffect(make_warp_pe(fPhase)); + paint.setPathEffect(make_warp_pe(fPhase))->unref(); TestRastBuilder testRastBuilder; paint.setRasterizer(testRastBuilder.detachRasterizer())->unref(); canvas->drawPath(fPath, paint); diff --git a/samplecode/SampleSlides.cpp b/samplecode/SampleSlides.cpp index 38fd7402c7..c3cc2bbd6f 100644 --- a/samplecode/SampleSlides.cpp +++ b/samplecode/SampleSlides.cpp @@ -31,14 +31,15 @@ typedef void (*SlideProc)(SkCanvas*); static void compose_pe(SkPaint* paint) { SkPathEffect* pe = paint->getPathEffect(); - sk_sp<SkPathEffect> corner = SkCornerPathEffect::Make(25); - sk_sp<SkPathEffect> compose; + SkPathEffect* corner = SkCornerPathEffect::Create(25); + SkPathEffect* compose; if (pe) { - compose = SkComposePathEffect::Make(sk_ref_sp(pe), corner); + compose = SkComposePathEffect::Create(pe, corner); + corner->unref(); } else { compose = corner; } - paint->setPathEffect(compose); + paint->setPathEffect(compose)->unref(); } static void hair_pe(SkPaint* paint) { @@ -58,7 +59,8 @@ static void stroke_pe(SkPaint* paint) { static void dash_pe(SkPaint* paint) { SkScalar inter[] = { 20, 10, 10, 10 }; paint->setStrokeWidth(12); - paint->setPathEffect(SkDashPathEffect::Make(inter, SK_ARRAY_COUNT(inter), 0)); + paint->setPathEffect(SkDashPathEffect::Create(inter, SK_ARRAY_COUNT(inter), + 0))->unref(); compose_pe(paint); } @@ -81,8 +83,8 @@ static void one_d_pe(SkPaint* paint) { path.offset(SkIntToScalar(-6), 0); scale(&path, 1.5f); - paint->setPathEffect(SkPath1DPathEffect::Make(path, SkIntToScalar(21), 0, - SkPath1DPathEffect::kRotate_Style)); + paint->setPathEffect(SkPath1DPathEffect::Create(path, SkIntToScalar(21), 0, + SkPath1DPathEffect::kRotate_Style))->unref(); compose_pe(paint); } @@ -95,21 +97,21 @@ static void fill_pe(SkPaint* paint) { } static void discrete_pe(SkPaint* paint) { - paint->setPathEffect(SkDiscretePathEffect::Make(10, 4)); + paint->setPathEffect(SkDiscretePathEffect::Create(10, 4))->unref(); } -static sk_sp<SkPathEffect> MakeTileEffect() { +static SkPathEffect* MakeTileEffect() { SkMatrix m; m.setScale(SkIntToScalar(12), SkIntToScalar(12)); SkPath path; path.addCircle(0, 0, SkIntToScalar(5)); - return SkPath2DPathEffect::Make(m, path); + return SkPath2DPathEffect::Create(m, path); } static void tile_pe(SkPaint* paint) { - paint->setPathEffect(MakeTileEffect()); + paint->setPathEffect(MakeTileEffect())->unref(); } static const PE_Proc gPE2[] = { fill_pe, discrete_pe, tile_pe }; @@ -532,7 +534,7 @@ static void r5(SkLayerRasterizer::Builder* rastBuilder, SkPaint& p) { rastBuilder->addLayer(p); - p.setPathEffect(SkDiscretePathEffect::Make(SK_Scalar1*4, SK_Scalar1*3)); + p.setPathEffect(SkDiscretePathEffect::Create(SK_Scalar1*4, SK_Scalar1*3))->unref(); p.setXfermodeMode(SkXfermode::kSrcOut_Mode); rastBuilder->addLayer(p); } @@ -551,10 +553,10 @@ static void r6(SkLayerRasterizer::Builder* rastBuilder, SkPaint& p) #include "Sk2DPathEffect.h" -static sk_sp<SkPathEffect> MakeDotEffect(SkScalar radius, const SkMatrix& matrix) { +static SkPathEffect* MakeDotEffect(SkScalar radius, const SkMatrix& matrix) { SkPath path; path.addCircle(0, 0, radius); - return SkPath2DPathEffect::Make(matrix, path); + return SkPath2DPathEffect::Create(matrix, path); } static void r7(SkLayerRasterizer::Builder* rastBuilder, SkPaint& p) @@ -562,7 +564,7 @@ static void r7(SkLayerRasterizer::Builder* rastBuilder, SkPaint& p) SkMatrix lattice; lattice.setScale(SK_Scalar1*6, SK_Scalar1*6, 0, 0); lattice.postSkew(SK_Scalar1/3, 0, 0, 0); - p.setPathEffect(MakeDotEffect(SK_Scalar1*4, lattice)); + p.setPathEffect(MakeDotEffect(SK_Scalar1*4, lattice))->unref(); rastBuilder->addLayer(p); } @@ -573,7 +575,7 @@ static void r8(SkLayerRasterizer::Builder* rastBuilder, SkPaint& p) SkMatrix lattice; lattice.setScale(SK_Scalar1*6, SK_Scalar1*6, 0, 0); lattice.postSkew(SK_Scalar1/3, 0, 0, 0); - p.setPathEffect(MakeDotEffect(SK_Scalar1*2, lattice)); + p.setPathEffect(MakeDotEffect(SK_Scalar1*2, lattice))->unref(); p.setXfermodeMode(SkXfermode::kClear_Mode); rastBuilder->addLayer(p); @@ -591,7 +593,7 @@ static void r9(SkLayerRasterizer::Builder* rastBuilder, SkPaint& p) SkMatrix lattice; lattice.setScale(SK_Scalar1, SK_Scalar1*6, 0, 0); lattice.postRotate(SkIntToScalar(30), 0, 0); - p.setPathEffect(SkLine2DPathEffect::Make(SK_Scalar1*2, lattice)); + p.setPathEffect(SkLine2DPathEffect::Create(SK_Scalar1*2, lattice))->unref(); p.setXfermodeMode(SkXfermode::kClear_Mode); rastBuilder->addLayer(p); diff --git a/src/animator/SkDrawPaint.cpp b/src/animator/SkDrawPaint.cpp index 5f6efd8cc9..d1af4f42ff 100644 --- a/src/animator/SkDrawPaint.cpp +++ b/src/animator/SkDrawPaint.cpp @@ -233,7 +233,7 @@ void SkDrawPaint::setupPaint(SkPaint* paint) const { if (pathEffect == nullptr) paint->setPathEffect(nullptr); else if (pathEffect != (SkDrawPathEffect*) -1) - paint->setPathEffect(sk_ref_sp(pathEffect->getPathEffect())); + SkSafeUnref(paint->setPathEffect(pathEffect->getPathEffect())); if (shader == nullptr) paint->setShader(nullptr); else if (shader != (SkDrawShader*) -1) diff --git a/src/core/SkDraw.cpp b/src/core/SkDraw.cpp index 60db401aea..c35247bd99 100644 --- a/src/core/SkDraw.cpp +++ b/src/core/SkDraw.cpp @@ -1615,7 +1615,7 @@ void SkDraw::drawPosText_asPaths(const char text[], size_t byteLength, // Now restore the original settings, so we "draw" with whatever style/stroking. paint.setStyle(origPaint.getStyle()); - paint.setPathEffect(sk_ref_sp(origPaint.getPathEffect())); + paint.setPathEffect(origPaint.getPathEffect()); while (text < stop) { const SkGlyph& glyph = glyphCacheProc(cache.get(), &text); diff --git a/src/core/SkPaint.cpp b/src/core/SkPaint.cpp index 2d6c72714d..5e813f78c4 100644 --- a/src/core/SkPaint.cpp +++ b/src/core/SkPaint.cpp @@ -375,6 +375,7 @@ SET_PTR(ImageFilter) SET_PTR(Shader) SET_PTR(ColorFilter) SET_PTR(Xfermode) +SET_PTR(PathEffect) SET_PTR(MaskFilter) #undef SET_PTR @@ -1929,7 +1930,7 @@ void SkPaint::unflatten(SkReadBuffer& buffer) { } if (flatFlags & kHasEffects_FlatFlag) { - this->setPathEffect(buffer.readPathEffect()); + SkSafeUnref(this->setPathEffect(buffer.readPathEffect())); this->setShader(buffer.readShader()); SkSafeUnref(this->setXfermode(buffer.readXfermode())); SkSafeUnref(this->setMaskFilter(buffer.readMaskFilter())); @@ -2249,11 +2250,11 @@ SkTextBaseIter::SkTextBaseIter(const char text[], size_t length, fCache = fPaint.detachCache(nullptr, SkPaint::FakeGamma::On, nullptr); SkPaint::Style style = SkPaint::kFill_Style; - sk_sp<SkPathEffect> pe; + SkPathEffect* pe = nullptr; if (!applyStrokeAndPathEffects) { style = paint.getStyle(); // restore - pe = sk_ref_sp(paint.getPathEffect()); // restore + pe = paint.getPathEffect(); // restore } fPaint.setStyle(style); fPaint.setPathEffect(pe); diff --git a/src/core/SkPathEffect.cpp b/src/core/SkPathEffect.cpp index b2e29bc09d..293bb53b2c 100644 --- a/src/core/SkPathEffect.cpp +++ b/src/core/SkPathEffect.cpp @@ -1,3 +1,4 @@ + /* * Copyright 2006 The Android Open Source Project * @@ -27,19 +28,25 @@ SkPathEffect::DashType SkPathEffect::asADash(DashInfo* info) const { /////////////////////////////////////////////////////////////////////////////// -SkPairPathEffect::SkPairPathEffect(sk_sp<SkPathEffect> pe0, sk_sp<SkPathEffect> pe1) - : fPE0(std::move(pe0)), fPE1(std::move(pe1)) -{ - SkASSERT(fPE0.get()); - SkASSERT(fPE1.get()); +SkPairPathEffect::SkPairPathEffect(SkPathEffect* pe0, SkPathEffect* pe1) + : fPE0(pe0), fPE1(pe1) { + SkASSERT(pe0); + SkASSERT(pe1); + fPE0->ref(); + fPE1->ref(); +} + +SkPairPathEffect::~SkPairPathEffect() { + SkSafeUnref(fPE0); + SkSafeUnref(fPE1); } /* Format: [oe0-factory][pe1-factory][pe0-size][pe0-data][pe1-data] */ void SkPairPathEffect::flatten(SkWriteBuffer& buffer) const { - buffer.writeFlattenable(fPE0.get()); - buffer.writeFlattenable(fPE1.get()); + buffer.writeFlattenable(fPE0); + buffer.writeFlattenable(fPE1); } #ifndef SK_IGNORE_TO_STRING @@ -58,13 +65,22 @@ void SkPairPathEffect::toString(SkString* str) const { /////////////////////////////////////////////////////////////////////////////// SkFlattenable* SkComposePathEffect::CreateProc(SkReadBuffer& buffer) { - sk_sp<SkPathEffect> pe0(buffer.readPathEffect()); - sk_sp<SkPathEffect> pe1(buffer.readPathEffect()); - return SkComposePathEffect::Make(std::move(pe0), std::move(pe1)).release(); + SkAutoTUnref<SkPathEffect> pe0(buffer.readPathEffect()); + SkAutoTUnref<SkPathEffect> pe1(buffer.readPathEffect()); + if (pe0 && pe1) { + return SkComposePathEffect::Create(pe0, pe1); + } else { + return nullptr; + } } bool SkComposePathEffect::filterPath(SkPath* dst, const SkPath& src, SkStrokeRec* rec, const SkRect* cullRect) const { + // we may have failed to unflatten these, so we have to check + if (!fPE0 || !fPE1) { + return false; + } + SkPath tmp; const SkPath* ptr = &src; @@ -86,9 +102,13 @@ void SkComposePathEffect::toString(SkString* str) const { /////////////////////////////////////////////////////////////////////////////// SkFlattenable* SkSumPathEffect::CreateProc(SkReadBuffer& buffer) { - sk_sp<SkPathEffect> pe0(buffer.readPathEffect()); - sk_sp<SkPathEffect> pe1(buffer.readPathEffect()); - return SkSumPathEffect::Make(pe0, pe1).release(); + SkAutoTUnref<SkPathEffect> pe0(buffer.readPathEffect()); + SkAutoTUnref<SkPathEffect> pe1(buffer.readPathEffect()); + if (pe0 && pe1) { + return SkSumPathEffect::Create(pe0, pe1); + } else { + return nullptr; + } } bool SkSumPathEffect::filterPath(SkPath* dst, const SkPath& src, diff --git a/src/core/SkReadBuffer.h b/src/core/SkReadBuffer.h index c7ac8480ec..7ce6d048e9 100644 --- a/src/core/SkReadBuffer.h +++ b/src/core/SkReadBuffer.h @@ -134,9 +134,7 @@ public: SkDrawLooper* readDrawLooper() { return this->readFlattenable<SkDrawLooper>(); } SkImageFilter* readImageFilter() { return this->readFlattenable<SkImageFilter>(); } SkMaskFilter* readMaskFilter() { return this->readFlattenable<SkMaskFilter>(); } - sk_sp<SkPathEffect> readPathEffect() { - return sk_sp<SkPathEffect>(this->readFlattenable<SkPathEffect>()); - } + SkPathEffect* readPathEffect() { return this->readFlattenable<SkPathEffect>(); } SkRasterizer* readRasterizer() { return this->readFlattenable<SkRasterizer>(); } sk_sp<SkShader> readShader() { return sk_sp<SkShader>(this->readFlattenable<SkShader>()); } SkXfermode* readXfermode() { return this->readFlattenable<SkXfermode>(); } diff --git a/src/effects/Sk1DPathEffect.cpp b/src/effects/Sk1DPathEffect.cpp index 1d147bd78f..4be6f975d3 100644 --- a/src/effects/Sk1DPathEffect.cpp +++ b/src/effects/Sk1DPathEffect.cpp @@ -153,7 +153,7 @@ SkFlattenable* SkPath1DPathEffect::CreateProc(SkReadBuffer& buffer) { buffer.readPath(&path); SkScalar phase = buffer.readScalar(); Style style = (Style)buffer.readUInt(); - return SkPath1DPathEffect::Make(path, advance, phase, style).release(); + return SkPath1DPathEffect::Create(path, advance, phase, style); } return nullptr; } @@ -204,10 +204,10 @@ void SkPath1DPathEffect::toString(SkString* str) const { /////////////////////////////////////////////////////////////////////////////////////////////////// -sk_sp<SkPathEffect> SkPath1DPathEffect::Make(const SkPath& path, SkScalar advance, SkScalar phase, - Style style) { +SkPathEffect* SkPath1DPathEffect::Create(const SkPath& path, SkScalar advance, SkScalar phase, + Style style) { if (advance <= 0 || path.isEmpty()) { return nullptr; } - return sk_sp<SkPathEffect>(new SkPath1DPathEffect(path, advance, phase, style)); + return new SkPath1DPathEffect(path, advance, phase, style); } diff --git a/src/effects/Sk2DPathEffect.cpp b/src/effects/Sk2DPathEffect.cpp index a54f453ecf..7144526dd0 100644 --- a/src/effects/Sk2DPathEffect.cpp +++ b/src/effects/Sk2DPathEffect.cpp @@ -111,7 +111,7 @@ SkFlattenable* SkLine2DPathEffect::CreateProc(SkReadBuffer& buffer) { SkMatrix matrix; buffer.readMatrix(&matrix); SkScalar width = buffer.readScalar(); - return SkLine2DPathEffect::Make(width, matrix).release(); + return SkLine2DPathEffect::Create(width, matrix); } void SkLine2DPathEffect::flatten(SkWriteBuffer &buffer) const { @@ -140,7 +140,7 @@ SkFlattenable* SkPath2DPathEffect::CreateProc(SkReadBuffer& buffer) { buffer.readMatrix(&matrix); SkPath path; buffer.readPath(&path); - return SkPath2DPathEffect::Make(matrix, path).release(); + return SkPath2DPathEffect::Create(matrix, path); } void SkPath2DPathEffect::flatten(SkWriteBuffer& buffer) const { diff --git a/src/effects/SkArcToPathEffect.cpp b/src/effects/SkArcToPathEffect.cpp index c660de9db4..06cba96109 100644 --- a/src/effects/SkArcToPathEffect.cpp +++ b/src/effects/SkArcToPathEffect.cpp @@ -62,7 +62,7 @@ DONE: } SkFlattenable* SkArcToPathEffect::CreateProc(SkReadBuffer& buffer) { - return SkArcToPathEffect::Make(buffer.readScalar()).release(); + return SkArcToPathEffect::Create(buffer.readScalar()); } void SkArcToPathEffect::flatten(SkWriteBuffer& buffer) const { diff --git a/src/effects/SkCornerPathEffect.cpp b/src/effects/SkCornerPathEffect.cpp index 325e2ca94a..4b81f261fe 100644 --- a/src/effects/SkCornerPathEffect.cpp +++ b/src/effects/SkCornerPathEffect.cpp @@ -140,7 +140,7 @@ DONE: } SkFlattenable* SkCornerPathEffect::CreateProc(SkReadBuffer& buffer) { - return SkCornerPathEffect::Make(buffer.readScalar()).release(); + return SkCornerPathEffect::Create(buffer.readScalar()); } void SkCornerPathEffect::flatten(SkWriteBuffer& buffer) const { diff --git a/src/effects/SkDashPathEffect.cpp b/src/effects/SkDashPathEffect.cpp index 51bf54839c..3816499915 100644 --- a/src/effects/SkDashPathEffect.cpp +++ b/src/effects/SkDashPathEffect.cpp @@ -365,7 +365,7 @@ SkFlattenable* SkDashPathEffect::CreateProc(SkReadBuffer& buffer) { uint32_t count = buffer.getArrayCount(); SkAutoSTArray<32, SkScalar> intervals(count); if (buffer.readScalarArray(intervals.get(), count)) { - return Make(intervals.get(), SkToInt(count), phase).release(); + return Create(intervals.get(), SkToInt(count), phase); } return nullptr; } @@ -386,9 +386,9 @@ void SkDashPathEffect::toString(SkString* str) const { ////////////////////////////////////////////////////////////////////////////////////////////////// -sk_sp<SkPathEffect> SkDashPathEffect::Make(const SkScalar intervals[], int count, SkScalar phase) { +SkPathEffect* SkDashPathEffect::Create(const SkScalar intervals[], int count, SkScalar phase) { if (!SkDashPath::ValidDashPath(phase, intervals, count)) { return nullptr; } - return sk_sp<SkPathEffect>(new SkDashPathEffect(intervals, count, phase)); + return new SkDashPathEffect(intervals, count, phase); } diff --git a/src/effects/SkDiscretePathEffect.cpp b/src/effects/SkDiscretePathEffect.cpp index 1989d9d603..acde041298 100644 --- a/src/effects/SkDiscretePathEffect.cpp +++ b/src/effects/SkDiscretePathEffect.cpp @@ -13,11 +13,6 @@ #include "SkPathMeasure.h" #include "SkStrokeRec.h" -sk_sp<SkPathEffect> SkDiscretePathEffect::Make(SkScalar segLength, SkScalar deviation, - uint32_t seedAssist) { - return sk_sp<SkPathEffect>(new SkDiscretePathEffect(segLength, deviation, seedAssist)); -} - static void Perterb(SkPoint* p, const SkVector& tangent, SkScalar scale) { SkVector normal = tangent; normal.rotateCCW(); @@ -126,7 +121,7 @@ SkFlattenable* SkDiscretePathEffect::CreateProc(SkReadBuffer& buffer) { SkScalar segLength = buffer.readScalar(); SkScalar perterb = buffer.readScalar(); uint32_t seed = buffer.readUInt(); - return Make(segLength, perterb, seed).release(); + return Create(segLength, perterb, seed); } void SkDiscretePathEffect::flatten(SkWriteBuffer& buffer) const { diff --git a/src/effects/SkLayerDrawLooper.cpp b/src/effects/SkLayerDrawLooper.cpp index 83f21e5b40..bca65ef77a 100644 --- a/src/effects/SkLayerDrawLooper.cpp +++ b/src/effects/SkLayerDrawLooper.cpp @@ -93,7 +93,7 @@ void SkLayerDrawLooper::LayerDrawLooperContext::ApplyInfo( } if (bits & kPathEffect_Bit) { - dst->setPathEffect(sk_ref_sp(src.getPathEffect())); + dst->setPathEffect(src.getPathEffect()); } if (bits & kMaskFilter_Bit) { dst->setMaskFilter(src.getMaskFilter()); diff --git a/src/gpu/text/GrTextUtils.cpp b/src/gpu/text/GrTextUtils.cpp index edf813dcc0..c46ea73d05 100644 --- a/src/gpu/text/GrTextUtils.cpp +++ b/src/gpu/text/GrTextUtils.cpp @@ -517,7 +517,7 @@ void GrTextUtils::DrawPosTextAsPath(GrContext* context, // Now restore the original settings, so we "draw" with whatever style/stroking. paint.setStyle(origPaint.getStyle()); - paint.setPathEffect(sk_ref_sp(origPaint.getPathEffect())); + paint.setPathEffect(origPaint.getPathEffect()); while (text < stop) { const SkGlyph& glyph = glyphCacheProc(cache, &text); diff --git a/src/pdf/SkPDFDevice.cpp b/src/pdf/SkPDFDevice.cpp index f5e341b043..6e0dd4b7c7 100644 --- a/src/pdf/SkPDFDevice.cpp +++ b/src/pdf/SkPDFDevice.cpp @@ -15,7 +15,6 @@ #include "SkGlyphCache.h" #include "SkPaint.h" #include "SkPath.h" -#include "SkPathEffect.h" #include "SkPathOps.h" #include "SkPDFBitmap.h" #include "SkPDFCanon.h" diff --git a/src/xps/SkXPSDevice.cpp b/src/xps/SkXPSDevice.cpp index febd0278ff..5d12c499ed 100644 --- a/src/xps/SkXPSDevice.cpp +++ b/src/xps/SkXPSDevice.cpp @@ -32,7 +32,6 @@ #include "SkIStream.h" #include "SkMaskFilter.h" #include "SkPaint.h" -#include "SkPathEffect.h" #include "SkPathOps.h" #include "SkPoint.h" #include "SkRasterizer.h" diff --git a/tests/AsADashTest.cpp b/tests/AsADashTest.cpp index 2077b66425..fc4efecbb2 100644 --- a/tests/AsADashTest.cpp +++ b/tests/AsADashTest.cpp @@ -12,7 +12,7 @@ #include "SkCornerPathEffect.h" DEF_TEST(AsADashTest_noneDash, reporter) { - sk_sp<SkPathEffect> pe(SkCornerPathEffect::Make(1.0)); + SkAutoTUnref<SkPathEffect> pe(SkCornerPathEffect::Create(1.0)); SkPathEffect::DashInfo info; SkPathEffect::DashType dashType = pe->asADash(&info); @@ -22,7 +22,7 @@ DEF_TEST(AsADashTest_noneDash, reporter) { DEF_TEST(AsADashTest_nullInfo, reporter) { SkScalar inIntervals[] = { 4.0, 2.0, 1.0, 3.0 }; const SkScalar phase = 2.0; - sk_sp<SkPathEffect> pe(SkDashPathEffect::Make(inIntervals, 4, phase)); + SkAutoTUnref<SkPathEffect> pe(SkDashPathEffect::Create(inIntervals, 4, phase)); SkPathEffect::DashType dashType = pe->asADash(nullptr); REPORTER_ASSERT(reporter, SkPathEffect::kDash_DashType == dashType); @@ -33,7 +33,7 @@ DEF_TEST(AsADashTest_usingDash, reporter) { SkScalar totalIntSum = 10.0; const SkScalar phase = 2.0; - sk_sp<SkPathEffect> pe(SkDashPathEffect::Make(inIntervals, 4, phase)); + SkAutoTUnref<SkPathEffect> pe(SkDashPathEffect::Create(inIntervals, 4, phase)); SkPathEffect::DashInfo info; diff --git a/tests/DashPathEffectTest.cpp b/tests/DashPathEffectTest.cpp index 7e832cdd66..fa2395ef75 100644 --- a/tests/DashPathEffectTest.cpp +++ b/tests/DashPathEffectTest.cpp @@ -18,7 +18,7 @@ DEF_TEST(DashPathEffectTest_crbug_348821, r) { SkScalar intervals[] = { 1.76934361e+36f, 2.80259693e-45f }; // Values from bug. const int count = 2; SkScalar phase = SK_ScalarInfinity; // Used to force a nonsense effect. - sk_sp<SkPathEffect> dash(SkDashPathEffect::Make(intervals, count, phase)); + SkAutoTUnref<SkPathEffect> dash(SkDashPathEffect::Create(intervals, count, phase)); REPORTER_ASSERT(r, dash == nullptr); } @@ -28,7 +28,7 @@ DEF_TEST(DashPathEffectTest_asPoints, r) { const SkScalar intervals[] = { 1.0f, 1.0f }; const int count = 2; - sk_sp<SkPathEffect> dash(SkDashPathEffect::Make(intervals, count, 0.0f)); + SkAutoTUnref<SkPathEffect> dash(SkDashPathEffect::Create(intervals, count, 0.0f)); SkRect cull = SkRect::MakeWH(1.0f, 1.0f); @@ -90,7 +90,7 @@ DEF_TEST(DashPath_bug4871, r) { path.close(); SkScalar intervals[2] = { 1, 1 }; - sk_sp<SkPathEffect> dash(SkDashPathEffect::Make(intervals, 2, 0)); + SkAutoTUnref<SkPathEffect> dash(SkDashPathEffect::Create(intervals, 2, 0)); SkPaint paint; paint.setStyle(SkPaint::kStroke_Style); diff --git a/tests/DrawPathTest.cpp b/tests/DrawPathTest.cpp index 8c46b100b3..e9aa4499d9 100644 --- a/tests/DrawPathTest.cpp +++ b/tests/DrawPathTest.cpp @@ -192,7 +192,7 @@ static void test_crbug_140642() { */ const SkScalar vals[] = { 27734, 35660, 2157846850.0f, 247 }; - auto dontAssert = SkDashPathEffect::Make(vals, 4, -248.135982067f); + SkAutoTUnref<SkPathEffect> dontAssert(SkDashPathEffect::Create(vals, 4, -248.135982067f)); } static void test_crbug_124652() { @@ -202,7 +202,7 @@ static void test_crbug_124652() { large values can "swamp" small ones. */ SkScalar intervals[2] = {837099584, 33450}; - auto dontAssert = SkDashPathEffect::Make(intervals, 2, -10); + SkAutoTUnref<SkPathEffect> dash(SkDashPathEffect::Create(intervals, 2, -10)); } static void test_bigcubic() { @@ -281,7 +281,7 @@ static void test_infinite_dash(skiatest::Reporter* reporter) { path.lineTo(5000000, 0); SkScalar intervals[] = { 0.2f, 0.2f }; - sk_sp<SkPathEffect> dash(SkDashPathEffect::Make(intervals, 2, 0)); + SkAutoTUnref<SkPathEffect> dash(SkDashPathEffect::Create(intervals, 2, 0)); SkPath filteredPath; SkPaint paint; @@ -301,7 +301,7 @@ static void test_crbug_165432(skiatest::Reporter* reporter) { path.lineTo(10000000, 0); SkScalar intervals[] = { 0.5f, 0.5f }; - sk_sp<SkPathEffect> dash(SkDashPathEffect::Make(intervals, 2, 0)); + SkAutoTUnref<SkPathEffect> dash(SkDashPathEffect::Create(intervals, 2, 0)); SkPaint paint; paint.setStyle(SkPaint::kStroke_Style); diff --git a/tests/GpuDrawPathTest.cpp b/tests/GpuDrawPathTest.cpp index 1f9361ad1e..d454d9bb67 100644 --- a/tests/GpuDrawPathTest.cpp +++ b/tests/GpuDrawPathTest.cpp @@ -49,7 +49,7 @@ static void test_drawPathEmpty(skiatest::Reporter*, SkCanvas* canvas) { } static void fill_and_stroke(SkCanvas* canvas, const SkPath& p1, const SkPath& p2, - sk_sp<SkPathEffect> effect) { + SkPathEffect* effect) { SkPaint paint; paint.setAntiAlias(true); paint.setPathEffect(effect); @@ -73,7 +73,8 @@ static void test_drawSameRectOvals(skiatest::Reporter*, SkCanvas* canvas) { fill_and_stroke(canvas, oval1, oval2, nullptr); const SkScalar intervals[] = { 1, 1 }; - fill_and_stroke(canvas, oval1, oval2, SkDashPathEffect::Make(intervals, 2, 0)); + SkAutoTUnref<SkPathEffect> dashEffect(SkDashPathEffect::Create(intervals, 2, 0)); + fill_and_stroke(canvas, oval1, oval2, dashEffect); } DEF_GPUTEST_FOR_ALL_CONTEXTS(GpuDrawPath, reporter, context) { diff --git a/tests/PictureTest.cpp b/tests/PictureTest.cpp index 58a08ecc34..0ac50d97f9 100644 --- a/tests/PictureTest.cpp +++ b/tests/PictureTest.cpp @@ -144,7 +144,7 @@ static void test_gpu_veto(skiatest::Reporter* reporter) { path.lineTo(50, 50); SkScalar intervals[] = { 1.0f, 1.0f }; - sk_sp<SkPathEffect> dash(SkDashPathEffect::Make(intervals, 2, 0)); + SkAutoTUnref<SkPathEffect> dash(SkDashPathEffect::Create(intervals, 2, 0)); SkPaint paint; paint.setStyle(SkPaint::kStroke_Style); @@ -233,7 +233,8 @@ static void test_gpu_veto(skiatest::Reporter* reporter) { { SkPaint paint; SkScalar intervals [] = { 10, 20 }; - paint.setPathEffect(SkDashPathEffect::Make(intervals, 2, 25)); + SkPathEffect* pe = SkDashPathEffect::Create(intervals, 2, 25); + paint.setPathEffect(pe)->unref(); SkPoint points [2] = { { 0, 0 }, { 100, 0 } }; @@ -249,7 +250,8 @@ static void test_gpu_veto(skiatest::Reporter* reporter) { { SkPaint paint; SkScalar intervals [] = { 10, 20 }; - paint.setPathEffect(SkDashPathEffect::Make(intervals, 2, 25)); + SkPathEffect* pe = SkDashPathEffect::Create(intervals, 2, 25); + paint.setPathEffect(pe)->unref(); for (int i = 0; i < 50; ++i) { canvas->drawRect(SkRect::MakeWH(10, 10), paint); diff --git a/tools/debugger/SkDrawCommand.cpp b/tools/debugger/SkDrawCommand.cpp index ab9c9de53c..847254a30f 100644 --- a/tools/debugger/SkDrawCommand.cpp +++ b/tools/debugger/SkDrawCommand.cpp @@ -1106,10 +1106,10 @@ static void extract_json_paint_patheffect(Json::Value& jsonPaint, UrlDataManager SkPaint* target) { if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_PATHEFFECT)) { Json::Value jsonPathEffect = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_PATHEFFECT]; - sk_sp<SkPathEffect> pathEffect((SkPathEffect*)load_flattenable(jsonPathEffect, - urlDataManager)); + SkPathEffect* pathEffect = (SkPathEffect*) load_flattenable(jsonPathEffect, urlDataManager); if (pathEffect != nullptr) { target->setPathEffect(pathEffect); + pathEffect->unref(); } } } @@ -1329,7 +1329,7 @@ static void extract_json_paint_dashing(Json::Value& jsonPaint, SkPaint* target) intervals[i] = jsonIntervals[i].asFloat(); } SkScalar phase = dash[SKDEBUGCANVAS_ATTRIBUTE_PHASE].asFloat(); - target->setPathEffect(SkDashPathEffect::Make(intervals, count, phase)); + target->setPathEffect(SkDashPathEffect::Create(intervals, count, phase)); sk_free(intervals); } } |