Update DropShadowImageFilter to sk_sp

TBR=reed@google.com

GOLD_TRYBOT_URL= https://gold.skia.org/search2?unt=true&query=source_type%3Dgm&master=false&issue=1861843002

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

14 files changed, 103 insertions, 106 deletions

diff --git a/fuzz/FilterFuzz.cpp b/fuzz/FilterFuzz.cpp
index db3dc8f8a7..12ae50dd71 100644
--- a/fuzz/FilterFuzz.cpp
+++ b/fuzz/FilterFuzz.cpp
@@ -680,19 +680,16 @@ static sk_sp<SkImageFilter> make_image_filter(bool canBeNull) {
         filter = SkPaintImageFilter::Make(paint, &cropR);
         break;
     }
-    case DROP_SHADOW: {
-        sk_sp<SkImageFilter> subFilter(make_image_filter());
-
-        filter = sk_sp<SkImageFilter>(SkDropShadowImageFilter::Create(make_scalar(),
-                                                                      make_scalar(),
-                                                                      make_scalar(true),
-                                                                      make_scalar(true),
-                                                                      make_color(),
-                                                                      make_shadow_mode(),
-                                                                      subFilter.get(),
-                                                                      nullptr));
+    case DROP_SHADOW:
+        filter = SkDropShadowImageFilter::Make(make_scalar(),
+                                               make_scalar(),
+                                               make_scalar(true),
+                                               make_scalar(true),
+                                               make_color(),
+                                               make_shadow_mode(),
+                                               make_image_filter(),
+                                               nullptr);
         break;
-    }
     case MORPHOLOGY:
         if (R(2) == 1) {
             filter = SkDilateImageFilter::Make(R(static_cast<float>(kBitmapSize)),
diff --git a/gm/dropshadowimagefilter.cpp b/gm/dropshadowimagefilter.cpp
index 11fa9a86fa..370b569b83 100644
--- a/gm/dropshadowimagefilter.cpp
+++ b/gm/dropshadowimagefilter.cpp
@@ -13,9 +13,9 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-static void draw_paint(SkCanvas* canvas, const SkRect& r, SkImageFilter* imf) {
+static void draw_paint(SkCanvas* canvas, const SkRect& r, sk_sp<SkImageFilter> imf) {
     SkPaint paint;
-    paint.setImageFilter(imf);
+    paint.setImageFilter(std::move(imf));
     paint.setColor(SK_ColorBLACK);
     canvas->save();
     canvas->clipRect(r);
@@ -23,10 +23,10 @@ static void draw_paint(SkCanvas* canvas, const SkRect& r, SkImageFilter* imf) {
     canvas->restore();
 }
 
-static void draw_path(SkCanvas* canvas, const SkRect& r, SkImageFilter* imf) {
+static void draw_path(SkCanvas* canvas, const SkRect& r, sk_sp<SkImageFilter> imf) {
     SkPaint paint;
     paint.setColor(SK_ColorGREEN);
-    paint.setImageFilter(imf);
+    paint.setImageFilter(std::move(imf));
     paint.setAntiAlias(true);
     canvas->save();
     canvas->clipRect(r);
@@ -34,9 +34,9 @@ static void draw_path(SkCanvas* canvas, const SkRect& r, SkImageFilter* imf) {
     canvas->restore();
 }
 
-static void draw_text(SkCanvas* canvas, const SkRect& r, SkImageFilter* imf) {
+static void draw_text(SkCanvas* canvas, const SkRect& r, sk_sp<SkImageFilter> imf) {
     SkPaint paint;
-    paint.setImageFilter(imf);
+    paint.setImageFilter(std::move(imf));
     paint.setColor(SK_ColorGREEN);
     paint.setAntiAlias(true);
     sk_tool_utils::set_portable_typeface(&paint);
@@ -48,7 +48,7 @@ static void draw_text(SkCanvas* canvas, const SkRect& r, SkImageFilter* imf) {
     canvas->restore();
 }
 
-static void draw_bitmap(SkCanvas* canvas, const SkRect& r, SkImageFilter* imf) {
+static void draw_bitmap(SkCanvas* canvas, const SkRect& r, sk_sp<SkImageFilter> imf) {
     SkPaint paint;
 
     SkIRect bounds;
@@ -60,7 +60,7 @@ static void draw_bitmap(SkCanvas* canvas, const SkRect& r, SkImageFilter* imf) {
     SkCanvas c(bm);
     draw_path(&c, r, nullptr);
 
-    paint.setImageFilter(imf);
+    paint.setImageFilter(std::move(imf));
     canvas->save();
     canvas->clipRect(r);
     canvas->drawBitmap(bm, 0, 0, &paint);
@@ -75,21 +75,14 @@ public:
 
 protected:
 
-    virtual SkString onShortName() {
+    SkString onShortName() override {
         return SkString("dropshadowimagefilter");
     }
 
-    virtual SkISize onISize() { return SkISize::Make(400, 656); }
+    SkISize onISize() override { return SkISize::Make(400, 656); }
 
-    void draw_frame(SkCanvas* canvas, const SkRect& r) {
-        SkPaint paint;
-        paint.setStyle(SkPaint::kStroke_Style);
-        paint.setColor(SK_ColorRED);
-        canvas->drawRect(r, paint);
-    }
-
-    virtual void onDraw(SkCanvas* canvas) {
-        void (*drawProc[])(SkCanvas*, const SkRect&, SkImageFilter*) = {
+    void onDraw(SkCanvas* canvas) override {
+        void (*drawProc[])(SkCanvas*, const SkRect&, sk_sp<SkImageFilter>) = {
             draw_bitmap, draw_path, draw_paint, draw_text
         };
 
@@ -101,22 +94,22 @@ protected:
         SkImageFilter::CropRect bogusRect(SkRect::Make(SkIRect::MakeXYWH(-100, -100, 10, 10)),
                                           SkImageFilter::CropRect::kHasAll_CropEdge);
 
-        SkImageFilter* filters[] = {
+        sk_sp<SkImageFilter> filters[] = {
             nullptr,
-            SkDropShadowImageFilter::Create(7.0f, 0.0f, 0.0f, 3.0f, SK_ColorBLUE,
-                SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode),
-            SkDropShadowImageFilter::Create(0.0f, 7.0f, 3.0f, 0.0f, SK_ColorBLUE,
-                SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode),
-            SkDropShadowImageFilter::Create(7.0f, 7.0f, 3.0f, 3.0f, SK_ColorBLUE,
-                SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode),
-            SkDropShadowImageFilter::Create(7.0f, 7.0f, 3.0f, 3.0f, SK_ColorBLUE,
-                SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode, cfif.get(), nullptr),
-            SkDropShadowImageFilter::Create(7.0f, 7.0f, 3.0f, 3.0f, SK_ColorBLUE,
+            SkDropShadowImageFilter::Make(7.0f, 0.0f, 0.0f, 3.0f, SK_ColorBLUE,
+                SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode, nullptr),
+            SkDropShadowImageFilter::Make(0.0f, 7.0f, 3.0f, 0.0f, SK_ColorBLUE,
+                SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode, nullptr),
+            SkDropShadowImageFilter::Make(7.0f, 7.0f, 3.0f, 3.0f, SK_ColorBLUE,
+                SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode, nullptr),
+            SkDropShadowImageFilter::Make(7.0f, 7.0f, 3.0f, 3.0f, SK_ColorBLUE,
+                SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode, std::move(cfif)),
+            SkDropShadowImageFilter::Make(7.0f, 7.0f, 3.0f, 3.0f, SK_ColorBLUE,
                 SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode, nullptr, &cropRect),
-            SkDropShadowImageFilter::Create(7.0f, 7.0f, 3.0f, 3.0f, SK_ColorBLUE,
+            SkDropShadowImageFilter::Make(7.0f, 7.0f, 3.0f, 3.0f, SK_ColorBLUE,
                 SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode, nullptr, &bogusRect),
-            SkDropShadowImageFilter::Create(7.0f, 7.0f, 3.0f, 3.0f, SK_ColorBLUE,
-                SkDropShadowImageFilter::kDrawShadowOnly_ShadowMode),
+            SkDropShadowImageFilter::Make(7.0f, 7.0f, 3.0f, 3.0f, SK_ColorBLUE,
+                SkDropShadowImageFilter::kDrawShadowOnly_ShadowMode, nullptr),
         };
 
         SkRect r = SkRect::MakeWH(SkIntToScalar(64), SkIntToScalar(64));
@@ -134,10 +127,6 @@ protected:
             canvas->restore();
             canvas->translate(DX, 0);
         }
-
-        for(size_t j = 0; j < SK_ARRAY_COUNT(filters); ++j) {
-            SkSafeUnref(filters[j]);
-        }
     }
 
 private:
diff --git a/gm/filterfastbounds.cpp b/gm/filterfastbounds.cpp
index 6ae4e740de..43a1b1e6f7 100644
--- a/gm/filterfastbounds.cpp
+++ b/gm/filterfastbounds.cpp
@@ -122,22 +122,21 @@ static void create_paints(SkTArray<SkPaint>* paints, sk_sp<SkImageFilter> source
         static const SkDropShadowImageFilter::ShadowMode kBoth =
                     SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode;
 
-        sk_sp<SkImageFilter> dsif(
-            SkDropShadowImageFilter::Create(10.0f, 10.0f,
-                                            3.0f, 3.0f,
-                                            SK_ColorRED, kBoth,
-                                            source.get(), nullptr));
+        sk_sp<SkImageFilter> dsif(SkDropShadowImageFilter::Make(10.0f, 10.0f,
+                                                                3.0f, 3.0f,
+                                                                SK_ColorRED, kBoth,
+                                                                source));
 
         add_paint(paints, std::move(dsif));
     }
 
     {
         sk_sp<SkImageFilter> dsif(
-            SkDropShadowImageFilter::Create(27.0f, 27.0f,
+            SkDropShadowImageFilter::Make(27.0f, 27.0f,
                                             3.0f, 3.0f,
                                             SK_ColorRED,
                                             SkDropShadowImageFilter::kDrawShadowOnly_ShadowMode,
-                                            source.get(), nullptr));
+                                            source));
 
         add_paint(paints, std::move(dsif));
     }
diff --git a/gm/imagefiltersbase.cpp b/gm/imagefiltersbase.cpp
index ebbd8956a5..f35357fe34 100644
--- a/gm/imagefiltersbase.cpp
+++ b/gm/imagefiltersbase.cpp
@@ -202,9 +202,10 @@ protected:
             FailImageFilter::Make(),
             SkColorFilterImageFilter::Make(std::move(cf), nullptr),
             SkBlurImageFilter::Make(12.0f, 0.0f, nullptr),
-            sk_sp<SkImageFilter>(SkDropShadowImageFilter::Create(
+            SkDropShadowImageFilter::Make(
                                     10.0f, 5.0f, 3.0f, 3.0f, SK_ColorBLUE,
-                                    SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode)),
+                                    SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode,
+                                    nullptr),
         };
 
         SkRect r = SkRect::MakeWH(SkIntToScalar(64), SkIntToScalar(64));
diff --git a/gm/imagefiltersclipped.cpp b/gm/imagefiltersclipped.cpp
index 7296fd5d33..b24ca5af72 100644
--- a/gm/imagefiltersclipped.cpp
+++ b/gm/imagefiltersclipped.cpp
@@ -95,9 +95,10 @@ protected:
 
         SkImageFilter* filters[] = {
             SkBlurImageFilter::Make(SkIntToScalar(12), SkIntToScalar(12), nullptr).release(),
-            SkDropShadowImageFilter::Create(SkIntToScalar(10), SkIntToScalar(10),
+            SkDropShadowImageFilter::Make(SkIntToScalar(10), SkIntToScalar(10),
                 SkIntToScalar(3), SkIntToScalar(3), SK_ColorGREEN,
-                SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode),
+                SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode,
+                nullptr).release(),
             SkDisplacementMapEffect::Create(SkDisplacementMapEffect::kR_ChannelSelectorType,
                                             SkDisplacementMapEffect::kR_ChannelSelectorType,
                                             SkIntToScalar(12),
diff --git a/gm/imagefilterscropexpand.cpp b/gm/imagefilterscropexpand.cpp
index 907277fc6a..6f749dc7e5 100644
--- a/gm/imagefilterscropexpand.cpp
+++ b/gm/imagefilterscropexpand.cpp
@@ -96,15 +96,15 @@ protected:
                                                                       &bigRect));
 
             Draw(canvas, checkerboard, rect,
-                 sk_sp<SkImageFilter>(SkDropShadowImageFilter::Create(
+                 SkDropShadowImageFilter::Make(
                                     SkIntToScalar(10),
                                     SkIntToScalar(10),
                                     SkIntToScalar(3),
                                     SkIntToScalar(3),
                                     SK_ColorBLUE,
                                     SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode,
-                                    noopCropped.get(),
-                                    &bigRect)));
+                                    noopCropped,
+                                    &bigRect));
 
             Draw(canvas, checkerboard, rect,
                  sk_sp<SkImageFilter>(SkDisplacementMapEffect::Create(
diff --git a/gm/imagefiltersscaled.cpp b/gm/imagefiltersscaled.cpp
index a63e99af4a..46f998cc28 100644
--- a/gm/imagefiltersscaled.cpp
+++ b/gm/imagefiltersscaled.cpp
@@ -74,9 +74,9 @@ protected:
 
         SkImageFilter* filters[] = {
             SkBlurImageFilter::Make(SkIntToScalar(4), SkIntToScalar(4), nullptr).release(),
-            SkDropShadowImageFilter::Create(SkIntToScalar(5), SkIntToScalar(10),
+            SkDropShadowImageFilter::Make(SkIntToScalar(5), SkIntToScalar(10),
                 SkIntToScalar(3), SkIntToScalar(3), SK_ColorYELLOW,
-                SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode),
+                SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode, nullptr).release(),
             SkDisplacementMapEffect::Create(SkDisplacementMapEffect::kR_ChannelSelectorType,
                                             SkDisplacementMapEffect::kR_ChannelSelectorType,
                                             SkIntToScalar(12),
diff --git a/gm/imagefiltersstroked.cpp b/gm/imagefiltersstroked.cpp
index cca87375d4..13dc705433 100644
--- a/gm/imagefiltersstroked.cpp
+++ b/gm/imagefiltersstroked.cpp
@@ -59,8 +59,9 @@ protected:
 
         sk_sp<SkImageFilter> filters[] = {
             SkBlurImageFilter::Make(5, 5, nullptr),
-            sk_sp<SkImageFilter>(SkDropShadowImageFilter::Create(10, 10, 3, 3, SK_ColorGREEN,
-                            SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode)),
+            SkDropShadowImageFilter::Make(10, 10, 3, 3, SK_ColorGREEN,
+                SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode,
+                nullptr),
             SkOffsetImageFilter::Make(-16, 32, nullptr),
             SkImageFilter::MakeMatrixFilter(resizeMatrix, kNone_SkFilterQuality, nullptr),
         };
diff --git a/gm/imagefilterstransformed.cpp b/gm/imagefilterstransformed.cpp
index 1ab52b9f58..291d1d46ec 100644
--- a/gm/imagefilterstransformed.cpp
+++ b/gm/imagefilterstransformed.cpp
@@ -65,17 +65,18 @@ protected:
     void onDraw(SkCanvas* canvas) override {
         sk_sp<SkImageFilter> gradient(SkImageSource::Make(fGradientCircle));
         sk_sp<SkImageFilter> checkerboard(SkImageSource::Make(fCheckerboard));
-        SkImageFilter* filters[] = {
-            SkBlurImageFilter::Make(12, 0, nullptr).release(),
-            SkDropShadowImageFilter::Create(0, 15, 8, 0, SK_ColorGREEN,
-                SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode),
-            SkDisplacementMapEffect::Create(SkDisplacementMapEffect::kR_ChannelSelectorType,
+        sk_sp<SkImageFilter> filters[] = {
+            SkBlurImageFilter::Make(12, 0, nullptr),
+            SkDropShadowImageFilter::Make(0, 15, 8, 0, SK_ColorGREEN,
+                SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode, nullptr),
+            sk_sp<SkImageFilter>(SkDisplacementMapEffect::Create(
+                                            SkDisplacementMapEffect::kR_ChannelSelectorType,
                                             SkDisplacementMapEffect::kR_ChannelSelectorType,
                                             12,
                                             gradient.get(),
-                                            checkerboard.get()),
-            SkDilateImageFilter::Make(2, 2, checkerboard).release(),
-            SkErodeImageFilter::Make(2, 2, checkerboard).release(),
+                                            checkerboard.get())),
+            SkDilateImageFilter::Make(2, 2, checkerboard),
+            SkErodeImageFilter::Make(2, 2, checkerboard),
         };
 
         const SkScalar margin = SkIntToScalar(20);
@@ -106,10 +107,6 @@ protected:
             canvas->restore();
             canvas->translate(0, size + margin);
         }
-
-        for (size_t i = 0; i < SK_ARRAY_COUNT(filters); ++i) {
-            SkSafeUnref(filters[i]);
-        }
     }
 
 private:
diff --git a/include/effects/SkDropShadowImageFilter.h b/include/effects/SkDropShadowImageFilter.h
index 7f1aa33220..a4726f3247 100644
--- a/include/effects/SkDropShadowImageFilter.h
+++ b/include/effects/SkDropShadowImageFilter.h
@@ -23,17 +23,30 @@ public:
 
     static const int kShadowModeCount = kLast_ShadowMode+1;
 
-    static SkImageFilter* Create(SkScalar dx, SkScalar dy, SkScalar sigmaX, SkScalar sigmaY,
-                                 SkColor color, ShadowMode shadowMode, SkImageFilter* input = NULL,
-                                 const CropRect* cropRect = NULL) {
-        return new SkDropShadowImageFilter(dx, dy, sigmaX, sigmaY, color, shadowMode, input,
-                                           cropRect);
+    static sk_sp<SkImageFilter> Make(SkScalar dx, SkScalar dy, SkScalar sigmaX, SkScalar sigmaY,
+                                     SkColor color, ShadowMode shadowMode,
+                                     sk_sp<SkImageFilter> input,
+                                     const CropRect* cropRect = nullptr) {
+        return sk_sp<SkImageFilter>(new SkDropShadowImageFilter(dx, dy, sigmaX, sigmaY, 
+                                                                color, shadowMode,
+                                                                std::move(input),
+                                                                cropRect));
     }
 
     SkRect computeFastBounds(const SkRect&) const override;
     SK_TO_STRING_OVERRIDE()
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkDropShadowImageFilter)
 
+#ifdef SK_SUPPORT_LEGACY_IMAGEFILTER_PTR
+    static SkImageFilter* Create(SkScalar dx, SkScalar dy, SkScalar sigmaX, SkScalar sigmaY,
+                                 SkColor color, ShadowMode shadowMode,
+                                 SkImageFilter* input = nullptr,
+                                 const CropRect* cropRect = nullptr) {
+        return Make(dx, dy, sigmaX, sigmaY, color, shadowMode,
+                    sk_ref_sp<SkImageFilter>(input), cropRect).release();
+    }
+#endif
+
 protected:
     void flatten(SkWriteBuffer&) const override;
     sk_sp<SkSpecialImage> onFilterImage(SkSpecialImage* source, const Context&,
@@ -42,7 +55,8 @@ protected:
 
 private:
     SkDropShadowImageFilter(SkScalar dx, SkScalar dy, SkScalar sigmaX, SkScalar sigmaY, SkColor,
-                            ShadowMode shadowMode, SkImageFilter* input, const CropRect* cropRect);
+                            ShadowMode shadowMode, sk_sp<SkImageFilter> input,
+                            const CropRect* cropRect);
 
     SkScalar fDx, fDy, fSigmaX, fSigmaY;
     SkColor fColor;
diff --git a/samplecode/SampleFilterFuzz.cpp b/samplecode/SampleFilterFuzz.cpp
index 685ad90da6..8f83c3e465 100644
--- a/samplecode/SampleFilterFuzz.cpp
+++ b/samplecode/SampleFilterFuzz.cpp
@@ -683,19 +683,16 @@ static sk_sp<SkImageFilter> make_image_filter(bool canBeNull) {
         filter = SkPaintImageFilter::Make(paint, &cropR);
         break;
     }
-    case DROP_SHADOW: {
-        sk_sp<SkImageFilter> subFilter(make_image_filter());
-
-        filter = sk_sp<SkImageFilter>(SkDropShadowImageFilter::Create(make_scalar(),
-                                                                      make_scalar(),
-                                                                      make_scalar(true),
-                                                                      make_scalar(true),
-                                                                      make_color(),
-                                                                      make_shadow_mode(),
-                                                                      subFilter.get(),
-                                                                      nullptr));
+    case DROP_SHADOW:
+        filter = SkDropShadowImageFilter::Make(make_scalar(),
+                                               make_scalar(),
+                                               make_scalar(true),
+                                               make_scalar(true),
+                                               make_color(),
+                                               make_shadow_mode(),
+                                               make_image_filter(),
+                                               nullptr);
         break;
-    }
     case MORPHOLOGY:
         if (R(2) == 1) {
             filter = SkDilateImageFilter::Make(R(static_cast<float>(kBitmapSize)),
diff --git a/src/effects/SkDropShadowImageFilter.cpp b/src/effects/SkDropShadowImageFilter.cpp
index 9cacad5513..92e7e2c096 100644
--- a/src/effects/SkDropShadowImageFilter.cpp
+++ b/src/effects/SkDropShadowImageFilter.cpp
@@ -16,9 +16,9 @@
 
 SkDropShadowImageFilter::SkDropShadowImageFilter(SkScalar dx, SkScalar dy,
                                                  SkScalar sigmaX, SkScalar sigmaY, SkColor color,
-                                                 ShadowMode shadowMode, SkImageFilter* input,
+                                                 ShadowMode shadowMode, sk_sp<SkImageFilter> input,
                                                  const CropRect* cropRect)
-    : INHERITED(1, &input, cropRect)
+    : INHERITED(&input, 1, cropRect)
     , fDx(dx)
     , fDy(dy)
     , fSigmaX(sigmaX)
@@ -37,8 +37,7 @@ sk_sp<SkFlattenable> SkDropShadowImageFilter::CreateProc(SkReadBuffer& buffer) {
     ShadowMode shadowMode = buffer.isVersionLT(SkReadBuffer::kDropShadowMode_Version) ?
                             kDrawShadowAndForeground_ShadowMode :
                             static_cast<ShadowMode>(buffer.readInt());
-    return sk_sp<SkFlattenable>(Create(dx, dy, sigmaX, sigmaY, color, shadowMode,
-                                       common.getInput(0).get(), &common.cropRect()));
+    return Make(dx, dy, sigmaX, sigmaY, color, shadowMode, common.getInput(0), &common.cropRect());
 }
 
 void SkDropShadowImageFilter::flatten(SkWriteBuffer& buffer) const {
diff --git a/tests/ImageFilterTest.cpp b/tests/ImageFilterTest.cpp
index b0b7349aea..197dd32277 100644
--- a/tests/ImageFilterTest.cpp
+++ b/tests/ImageFilterTest.cpp
@@ -181,10 +181,10 @@ public:
                                                         SK_Scalar1,
                                                         input,
                                                         cropRect).release());
-        this->addFilter("drop shadow", SkDropShadowImageFilter::Create(
+        this->addFilter("drop shadow", SkDropShadowImageFilter::Make(
                   SK_Scalar1, SK_Scalar1, SK_Scalar1, SK_Scalar1, SK_ColorGREEN,
                   SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode,
-                  input.get(), cropRect));
+                  input, cropRect).release());
         this->addFilter("diffuse lighting", SkLightingImageFilter::CreatePointLitDiffuse(
                   location, SK_ColorGREEN, 0, 0, input.get(), cropRect));
         this->addFilter("specular lighting",
@@ -851,11 +851,11 @@ static sk_sp<SkImageFilter> make_blur(sk_sp<SkImageFilter> input) {
 }
 
 static sk_sp<SkImageFilter> make_drop_shadow(sk_sp<SkImageFilter> input) {
-    return sk_sp<SkImageFilter>(SkDropShadowImageFilter::Create(
+    return SkDropShadowImageFilter::Make(
         SkIntToScalar(100), SkIntToScalar(100),
         SkIntToScalar(10), SkIntToScalar(10),
         SK_ColorBLUE, SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode,
-        input.get(), nullptr));
+        std::move(input));
 }
 
 DEF_TEST(ImageFilterBlurThenShadowBounds, reporter) {
diff --git a/tests/RecordDrawTest.cpp b/tests/RecordDrawTest.cpp
index 17d971126c..cf8141a789 100644
--- a/tests/RecordDrawTest.cpp
+++ b/tests/RecordDrawTest.cpp
@@ -209,8 +209,10 @@ DEF_TEST(RecordDraw_SaveLayerAffectsClipBounds, r) {
     // We draw a rectangle with a long drop shadow.  We used to not update the clip
     // bounds based on SaveLayer paints, so the drop shadow could be cut off.
     SkPaint paint;
-    paint.setImageFilter(SkDropShadowImageFilter::Create(20, 0, 0, 0, SK_ColorBLACK,
-                         SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode))->unref();
+    paint.setImageFilter(SkDropShadowImageFilter::Make(
+                                 20, 0, 0, 0, SK_ColorBLACK,
+                                 SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode,
+                                 nullptr));
 
     recorder.saveLayer(nullptr, &paint);
         recorder.clipRect(SkRect::MakeWH(20, 40));