Update SkBlurImageFilter to sk_sp

TBR=reed@google.com

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

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

28 files changed, 313 insertions, 297 deletions

diff --git a/bench/BlurImageFilterBench.cpp b/bench/BlurImageFilterBench.cpp
index cf93774178..9560263f1d 100644
--- a/bench/BlurImageFilterBench.cpp
+++ b/bench/BlurImageFilterBench.cpp
@@ -34,6 +34,30 @@
 // of the source (not inset). This is intended to exercise blurring a smaller source bitmap to a
 // larger destination.
 
+static SkBitmap make_checkerboard(int width, int height) {
+    SkBitmap bm;
+    bm.allocN32Pixels(width, height);
+    SkCanvas canvas(bm);
+    canvas.clear(0x00000000);
+    SkPaint darkPaint;
+    darkPaint.setColor(0xFF804020);
+    SkPaint lightPaint;
+    lightPaint.setColor(0xFF244484);
+    for (int y = 0; y < height; y += 16) {
+        for (int x = 0; x < width; x += 16) {
+            canvas.save();
+            canvas.translate(SkIntToScalar(x), SkIntToScalar(y));
+            canvas.drawRect(SkRect::MakeXYWH(0, 0, 8, 8), darkPaint);
+            canvas.drawRect(SkRect::MakeXYWH(8, 0, 8, 8), lightPaint);
+            canvas.drawRect(SkRect::MakeXYWH(0, 8, 8, 8), lightPaint);
+            canvas.drawRect(SkRect::MakeXYWH(8, 8, 8, 8), darkPaint);
+            canvas.restore();
+        }
+    }
+
+    return bm;
+}
+
 class BlurImageFilterBench : public Benchmark {
 public:
     BlurImageFilterBench(SkScalar sigmaX, SkScalar sigmaY,  bool small, bool cropped,
@@ -59,13 +83,13 @@ protected:
 
     void onDelayedSetup() override {
         if (!fInitialized) {
-            make_checkerboard();
+            fCheckerboard = make_checkerboard(fIsSmall ? FILTER_WIDTH_SMALL : FILTER_WIDTH_LARGE,
+                                              fIsSmall ? FILTER_HEIGHT_SMALL : FILTER_HEIGHT_LARGE);
             fInitialized = true;
         }
     }
 
     void onDraw(int loops, SkCanvas* canvas) override {
-        SkPaint paint;
         static const SkScalar kX = 0;
         static const SkScalar kY = 0;
         const SkRect bmpRect = SkRect::MakeXYWH(kX, kY,
@@ -73,14 +97,15 @@ protected:
                                                 SkIntToScalar(fCheckerboard.height()));
         const SkImageFilter::CropRect cropRect(bmpRect.makeInset(10.f, 10.f));
         const SkImageFilter::CropRect cropRectLarge(bmpRect);
-        sk_sp<SkImageFilter> noOpCropped(SkOffsetImageFilter::Make(0, 0, nullptr, &cropRect));
 
-        SkImageFilter* input = fIsExpanded ? noOpCropped.get() : nullptr;
+        sk_sp<SkImageFilter> input = fIsExpanded 
+                                        ? SkOffsetImageFilter::Make(0, 0, nullptr, &cropRect)
+                                        : nullptr;
 
         const SkImageFilter::CropRect* crop =
             fIsExpanded ? &cropRectLarge : fIsCropped ? &cropRect : nullptr;
-        SkAutoTUnref<SkImageFilter> blur(SkBlurImageFilter::Create(fSigmaX, fSigmaY, input, crop));
-        paint.setImageFilter(blur);
+        SkPaint paint;
+        paint.setImageFilter(SkBlurImageFilter::Make(fSigmaX, fSigmaY, std::move(input), crop));
 
         for (int i = 0; i < loops; i++) {
             canvas->drawBitmap(fCheckerboard, kX, kY, &paint);
@@ -88,28 +113,6 @@ protected:
     }
 
 private:
-    void make_checkerboard() {
-        const int w = fIsSmall ? FILTER_WIDTH_SMALL : FILTER_WIDTH_LARGE;
-        const int h = fIsSmall ? FILTER_HEIGHT_LARGE : FILTER_HEIGHT_LARGE;
-        fCheckerboard.allocN32Pixels(w, h);
-        SkCanvas canvas(fCheckerboard);
-        canvas.clear(0x00000000);
-        SkPaint darkPaint;
-        darkPaint.setColor(0xFF804020);
-        SkPaint lightPaint;
-        lightPaint.setColor(0xFF244484);
-        for (int y = 0; y < h; y += 16) {
-            for (int x = 0; x < w; x += 16) {
-                canvas.save();
-                canvas.translate(SkIntToScalar(x), SkIntToScalar(y));
-                canvas.drawRect(SkRect::MakeXYWH(0, 0, 8, 8), darkPaint);
-                canvas.drawRect(SkRect::MakeXYWH(8, 0, 8, 8), lightPaint);
-                canvas.drawRect(SkRect::MakeXYWH(0, 8, 8, 8), lightPaint);
-                canvas.drawRect(SkRect::MakeXYWH(8, 8, 8, 8), darkPaint);
-                canvas.restore();
-            }
-        }
-    }
 
     SkString fName;
     bool fIsSmall;
diff --git a/bench/ImageFilterDAGBench.cpp b/bench/ImageFilterDAGBench.cpp
index 5fdf95b06d..308b3b0037 100644
--- a/bench/ImageFilterDAGBench.cpp
+++ b/bench/ImageFilterDAGBench.cpp
@@ -28,7 +28,7 @@ protected:
         const SkRect rect = SkRect::Make(SkIRect::MakeWH(400, 400));
 
         for (int j = 0; j < loops; j++) {
-            sk_sp<SkImageFilter> blur(SkBlurImageFilter::Create(20.0f, 20.0f));
+            sk_sp<SkImageFilter> blur(SkBlurImageFilter::Make(20.0f, 20.0f, nullptr));
             sk_sp<SkImageFilter> inputs[kNumInputs];
             for (int i = 0; i < kNumInputs; ++i) {
                 inputs[i] = blur;
@@ -58,14 +58,14 @@ protected:
 
     void onDraw(int loops, SkCanvas* canvas) override {
         for (int j = 0; j < loops; j++) {
-            SkAutoTUnref<SkImageFilter> blur(SkBlurImageFilter::Create(4.0f, 4.0f));
-            SkDisplacementMapEffect::ChannelSelectorType xSelector = SkDisplacementMapEffect::kR_ChannelSelectorType;
-            SkDisplacementMapEffect::ChannelSelectorType ySelector = SkDisplacementMapEffect::kB_ChannelSelectorType;
+            sk_sp<SkImageFilter> blur(SkBlurImageFilter::Make(4.0f, 4.0f, nullptr));
+            auto xSelector = SkDisplacementMapEffect::kR_ChannelSelectorType;
+            auto ySelector = SkDisplacementMapEffect::kB_ChannelSelectorType;
             SkScalar scale = 2;
-            SkAutoTUnref<SkImageFilter> displ(SkDisplacementMapEffect::Create(xSelector, ySelector, scale,
-                                                                              blur.get(), blur.get()));
+            sk_sp<SkImageFilter> displ(SkDisplacementMapEffect::Create(xSelector, ySelector, scale,
+                                                                       blur.get(), blur.get()));
             SkPaint paint;
-            paint.setImageFilter(displ);
+            paint.setImageFilter(std::move(displ));
             SkRect rect = SkRect::Make(SkIRect::MakeWH(400, 400));
             canvas->drawRect(rect, paint);
         }
diff --git a/gm/coloremoji.cpp b/gm/coloremoji.cpp
index 4be8202d19..5132d71ae0 100644
--- a/gm/coloremoji.cpp
+++ b/gm/coloremoji.cpp
@@ -27,19 +27,19 @@ static sk_sp<SkShader> MakeLinear() {
                                         SkShader::kClamp_TileMode);
 }
 
-static SkImageFilter* make_grayscale(SkImageFilter* input = nullptr) {
+static sk_sp<SkImageFilter> make_grayscale(sk_sp<SkImageFilter> input) {
     SkScalar matrix[20];
     memset(matrix, 0, 20 * sizeof(SkScalar));
     matrix[0] = matrix[5] = matrix[10] = 0.2126f;
     matrix[1] = matrix[6] = matrix[11] = 0.7152f;
     matrix[2] = matrix[7] = matrix[12] = 0.0722f;
     matrix[18] = 1.0f;
-    auto filter(SkColorFilter::MakeMatrixFilterRowMajor255(matrix));
-    return SkColorFilterImageFilter::Create(filter.get(), input);
+    sk_sp<SkColorFilter> filter(SkColorFilter::MakeMatrixFilterRowMajor255(matrix));
+    return sk_sp<SkImageFilter>(SkColorFilterImageFilter::Create(filter.get(), input.get()));
 }
 
-static SkImageFilter* make_blur(float amount, SkImageFilter* input = nullptr) {
-    return SkBlurImageFilter::Create(amount, amount, input);
+static sk_sp<SkImageFilter> make_blur(float amount, sk_sp<SkImageFilter> input) {
+    return SkBlurImageFilter::Make(amount, amount, std::move(input));
 }
 
 namespace skiagm {
@@ -98,15 +98,13 @@ protected:
                     }
 
                     if (SkToBool(makeBlur) && SkToBool(makeGray)) {
-                        SkAutoTUnref<SkImageFilter> grayScale(make_grayscale(nullptr));
-                        SkAutoTUnref<SkImageFilter> blur(make_blur(3.0f, grayScale));
-                        shaderPaint.setImageFilter(blur);
+                        sk_sp<SkImageFilter> grayScale(make_grayscale(nullptr));
+                        sk_sp<SkImageFilter> blur(make_blur(3.0f, std::move(grayScale)));
+                        shaderPaint.setImageFilter(std::move(blur));
                     } else if (SkToBool(makeBlur)) {
-                        SkAutoTUnref<SkImageFilter> blur(make_blur(3.0f, nullptr));
-                        shaderPaint.setImageFilter(blur);
+                        shaderPaint.setImageFilter(make_blur(3.0f, nullptr));
                     } else if (SkToBool(makeGray)) {
-                        SkAutoTUnref<SkImageFilter> grayScale(make_grayscale(nullptr));
-                        shaderPaint.setImageFilter(grayScale);
+                        shaderPaint.setImageFilter(make_grayscale(nullptr));
                     }
                     shaderPaint.setTextSize(30);
                     canvas->drawText(text, strlen(text), 380, SkIntToScalar(y_offset),
@@ -160,7 +158,6 @@ protected:
 
 //////////////////////////////////////////////////////////////////////////////
 
-static GM* MyFactory(void*) { return new ColorEmojiGM; }
-static GMRegistry reg(MyFactory);
+DEF_GM(return new ColorEmojiGM;)
 
 }
diff --git a/gm/colorfilterimagefilter.cpp b/gm/colorfilterimagefilter.cpp
index 497757e128..38ff0ddb22 100644
--- a/gm/colorfilterimagefilter.cpp
+++ b/gm/colorfilterimagefilter.cpp
@@ -87,26 +87,29 @@ static void sk_gm_get_shaders(SkTDArray<SkShader*>* array) {
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-static SkImageFilter* make_blur(float amount, SkImageFilter* input = nullptr) {
-    return SkBlurImageFilter::Create(amount, amount, input);
+static sk_sp<SkImageFilter> make_blur(float amount, sk_sp<SkImageFilter> input) {
+    return SkBlurImageFilter::Make(amount, amount, std::move(input));
 }
 
-static SkImageFilter* make_brightness(float amount, SkImageFilter* input = nullptr) {
-    return SkColorFilterImageFilter::Create(cf_make_brightness(amount).get(), input);
+static sk_sp<SkImageFilter> make_brightness(float amount, sk_sp<SkImageFilter> input) {
+    return sk_sp<SkImageFilter>(SkColorFilterImageFilter::Create(cf_make_brightness(amount).get(),
+                                                                 input.get()));
 }
 
-static SkImageFilter* make_grayscale(SkImageFilter* input = nullptr) {
-    return SkColorFilterImageFilter::Create(cf_make_grayscale().get(), input);
+static sk_sp<SkImageFilter> make_grayscale(sk_sp<SkImageFilter> input) {
+    return sk_sp<SkImageFilter>(SkColorFilterImageFilter::Create(cf_make_grayscale().get(),
+                                                                 input.get()));
 }
 
-static SkImageFilter* make_mode_blue(SkImageFilter* input = nullptr) {
-    return SkColorFilterImageFilter::Create(cf_make_colorize(SK_ColorBLUE).get(), input);
+static sk_sp<SkImageFilter> make_mode_blue(sk_sp<SkImageFilter> input) {
+    return sk_sp<SkImageFilter>(SkColorFilterImageFilter::Create(cf_make_colorize(SK_ColorBLUE).get(),
+                                                                 input.get()));
 }
 
-static void drawClippedRect(SkCanvas* canvas,
-                            const SkRect& r,
-                            const SkPaint& paint,
-                            float outset = 0.0f) {
+static void draw_clipped_rect(SkCanvas* canvas,
+                              const SkRect& r,
+                              const SkPaint& paint,
+                              float outset = 0.0f) {
         canvas->save();
         SkRect clip(r);
         clip.outset(outset, outset);
@@ -121,53 +124,53 @@ DEF_SIMPLE_GM(colorfilterimagefilter, canvas, 400, 100){
         paint.setColor(SK_ColorRED);
         canvas->save();
         for (float brightness = -1.0f; brightness <= 1.0f; brightness += 0.2f) {
-            SkAutoTUnref<SkImageFilter> dim(make_brightness(-brightness));
-            SkAutoTUnref<SkImageFilter> bright(make_brightness(brightness, dim));
-            paint.setImageFilter(bright);
-            drawClippedRect(canvas, r, paint);
+            sk_sp<SkImageFilter> dim(make_brightness(-brightness, nullptr));
+            sk_sp<SkImageFilter> bright(make_brightness(brightness, std::move(dim)));
+            paint.setImageFilter(std::move(bright));
+            draw_clipped_rect(canvas, r, paint);
             canvas->translate(FILTER_WIDTH + MARGIN, 0);
         }
         canvas->restore();
         canvas->translate(0, FILTER_HEIGHT + MARGIN);
         {
-            SkAutoTUnref<SkImageFilter> brightness(make_brightness(0.9f));
-            SkAutoTUnref<SkImageFilter> grayscale(make_grayscale(brightness));
-            paint.setImageFilter(grayscale);
-            drawClippedRect(canvas, r, paint);
+            sk_sp<SkImageFilter> brightness(make_brightness(0.9f, nullptr));
+            sk_sp<SkImageFilter> grayscale(make_grayscale(std::move(brightness)));
+            paint.setImageFilter(std::move(grayscale));
+            draw_clipped_rect(canvas, r, paint);
             canvas->translate(FILTER_WIDTH + MARGIN, 0);
         }
         {
-            SkAutoTUnref<SkImageFilter> grayscale(make_grayscale());
-            SkAutoTUnref<SkImageFilter> brightness(make_brightness(0.9f, grayscale));
-            paint.setImageFilter(brightness);
-            drawClippedRect(canvas, r, paint);
+            sk_sp<SkImageFilter> grayscale(make_grayscale(nullptr));
+            sk_sp<SkImageFilter> brightness(make_brightness(0.9f, std::move(grayscale)));
+            paint.setImageFilter(std::move(brightness));
+            draw_clipped_rect(canvas, r, paint);
             canvas->translate(FILTER_WIDTH + MARGIN, 0);
         }
         {
-            SkAutoTUnref<SkImageFilter> blue(make_mode_blue());
-            SkAutoTUnref<SkImageFilter> brightness(make_brightness(1.0f, blue));
-            paint.setImageFilter(brightness);
-            drawClippedRect(canvas, r, paint);
+            sk_sp<SkImageFilter> blue(make_mode_blue(nullptr));
+            sk_sp<SkImageFilter> brightness(make_brightness(1.0f, std::move(blue)));
+            paint.setImageFilter(std::move(brightness));
+            draw_clipped_rect(canvas, r, paint);
             canvas->translate(FILTER_WIDTH + MARGIN, 0);
         }
         {
-            SkAutoTUnref<SkImageFilter> brightness(make_brightness(1.0f));
-            SkAutoTUnref<SkImageFilter> blue(make_mode_blue(brightness));
-            paint.setImageFilter(blue);
-            drawClippedRect(canvas, r, paint);
+            sk_sp<SkImageFilter> brightness(make_brightness(1.0f, nullptr));
+            sk_sp<SkImageFilter> blue(make_mode_blue(std::move(brightness)));
+            paint.setImageFilter(std::move(blue));
+            draw_clipped_rect(canvas, r, paint);
             canvas->translate(FILTER_WIDTH + MARGIN, 0);
         }
         {
-            SkAutoTUnref<SkImageFilter> blur(make_blur(3.0f));
-            SkAutoTUnref<SkImageFilter> brightness(make_brightness(0.5f, blur));
-            paint.setImageFilter(brightness);
-            drawClippedRect(canvas, r, paint, 3);
+            sk_sp<SkImageFilter> blur(make_blur(3.0f, nullptr));
+            sk_sp<SkImageFilter> brightness(make_brightness(0.5f, std::move(blur)));
+            paint.setImageFilter(std::move(brightness));
+            draw_clipped_rect(canvas, r, paint, 3);
             canvas->translate(FILTER_WIDTH + MARGIN, 0);
         }
         {
-            SkAutoTUnref<SkImageFilter> blue(make_mode_blue());
-            paint.setImageFilter(blue.get());
-            drawClippedRect(canvas, r, paint, 5);
+            sk_sp<SkImageFilter> blue(make_mode_blue(nullptr));
+            paint.setImageFilter(std::move(blue));
+            draw_clipped_rect(canvas, r, paint, 5);
             canvas->translate(FILTER_WIDTH + MARGIN, 0);
         }
 }
@@ -177,9 +180,9 @@ DEF_SIMPLE_GM(colorfilterimagefilter_layer, canvas, 32, 32) {
     SkColorMatrix cm;
     cm.setSaturation(0.0f);
     auto cf(SkColorFilter::MakeMatrixFilterRowMajor255(cm.fMat));
-    SkAutoTUnref<SkImageFilter> imf(SkColorFilterImageFilter::Create(cf.get()));
+    sk_sp<SkImageFilter> imf(SkColorFilterImageFilter::Create(cf.get()));
     SkPaint p;
-    p.setImageFilter(imf);
+    p.setImageFilter(std::move(imf));
     canvas->saveLayer(NULL, &p);
     canvas->clear(SK_ColorRED);
 }
diff --git a/gm/complexclip_blur_tiled.cpp b/gm/complexclip_blur_tiled.cpp
index 9413e64e07..979c7e7423 100644
--- a/gm/complexclip_blur_tiled.cpp
+++ b/gm/complexclip_blur_tiled.cpp
@@ -31,22 +31,21 @@ protected:
 
     void onDraw(SkCanvas* canvas) override {
         SkPaint blurPaint;
-        SkAutoTUnref<SkImageFilter> blur(SkBlurImageFilter::Create(5.0f, 5.0f));
-        blurPaint.setImageFilter(blur);
-        const SkScalar tile_size = SkIntToScalar(128);
+        blurPaint.setImageFilter(SkBlurImageFilter::Make(5.0f, 5.0f, nullptr));
+        const SkScalar tileSize = SkIntToScalar(128);
         SkRect bounds;
         if (!canvas->getClipBounds(&bounds)) {
             bounds.setEmpty();
         }
-        int ts = SkScalarCeilToInt(tile_size);
+        int ts = SkScalarCeilToInt(tileSize);
         SkImageInfo info = SkImageInfo::MakeN32Premul(ts, ts);
         auto tileSurface(canvas->makeSurface(info));
         if (!tileSurface) {
             tileSurface = SkSurface::MakeRaster(info);
         }
         SkCanvas* tileCanvas = tileSurface->getCanvas();
-        for (SkScalar y = bounds.top(); y < bounds.bottom(); y += tile_size) {
-            for (SkScalar x = bounds.left(); x < bounds.right(); x += tile_size) {
+        for (SkScalar y = bounds.top(); y < bounds.bottom(); y += tileSize) {
+            for (SkScalar x = bounds.left(); x < bounds.right(); x += tileSize) {
                 tileCanvas->save();
                 tileCanvas->clear(0);
                 tileCanvas->translate(-x, -y);
@@ -69,7 +68,6 @@ private:
 
 //////////////////////////////////////////////////////////////////////////////
 
-static GM* MyFactory1(void*) { return new ComplexClipBlurTiledGM(); }
-static GMRegistry reg1(MyFactory1);
+DEF_GM(return new ComplexClipBlurTiledGM;)
 
 }
diff --git a/gm/filterfastbounds.cpp b/gm/filterfastbounds.cpp
index 9d07095855..a254ec92c3 100644
--- a/gm/filterfastbounds.cpp
+++ b/gm/filterfastbounds.cpp
@@ -82,79 +82,68 @@ static const drawMth gDrawMthds[] = {
     draw_rect, draw_oval, draw_rrect, draw_drrect, draw_path, draw_points, draw_bitmap
 };
 
-static void add_paint(SkImageFilter* filter, SkTArray<SkPaint>* paints) {
+static void add_paint(SkTArray<SkPaint>* paints, sk_sp<SkImageFilter> filter) {
     SkPaint& p = paints->push_back();
-    p.setImageFilter(filter);
+    p.setImageFilter(std::move(filter));
     SkASSERT(p.canComputeFastBounds());
 }
 
 // Create a selection of imagefilter-based paints to test
-static void create_paints(SkImageFilter* source, SkTArray<SkPaint>* paints) {
+static void create_paints(SkTArray<SkPaint>* paints, sk_sp<SkImageFilter> source) {
     {
         SkMatrix scale;
         scale.setScale(2.0f, 2.0f);
 
-        SkAutoTUnref<SkImageFilter> scaleMIF(
-            SkImageFilter::CreateMatrixFilter(scale, kLow_SkFilterQuality, source));
+        sk_sp<SkImageFilter> scaleMIF(
+            SkImageFilter::CreateMatrixFilter(scale, kLow_SkFilterQuality, source.get()));
 
-        add_paint(scaleMIF, paints);
+        add_paint(paints, std::move(scaleMIF));
     }
 
     {
         SkMatrix rot;
         rot.setRotate(-33.3f);
 
-        SkAutoTUnref<SkImageFilter> rotMIF(
-            SkImageFilter::CreateMatrixFilter(rot, kLow_SkFilterQuality, source));
+        sk_sp<SkImageFilter> rotMIF(
+            SkImageFilter::CreateMatrixFilter(rot, kLow_SkFilterQuality, source.get()));
 
-        add_paint(rotMIF, paints);
+        add_paint(paints, std::move(rotMIF));
     }
 
     {
         SkRect src = SkRect::MakeXYWH(20, 20, 10, 10);
         SkRect dst = SkRect::MakeXYWH(30, 30, 30, 30);
-        SkAutoTUnref<SkImageFilter> tileIF(
-            SkTileImageFilter::Create(src, dst, nullptr));
+        sk_sp<SkImageFilter> tileIF(SkTileImageFilter::Create(src, dst, nullptr));
 
-        add_paint(tileIF, paints);
+        add_paint(paints, std::move(tileIF));
     }
 
     {
         static const SkDropShadowImageFilter::ShadowMode kBoth =
                     SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode;
 
-        SkAutoTUnref<SkImageFilter> dsif(
+        sk_sp<SkImageFilter> dsif(
             SkDropShadowImageFilter::Create(10.0f, 10.0f,
                                             3.0f, 3.0f,
                                             SK_ColorRED, kBoth,
-                                            source, nullptr));
+                                            source.get(), nullptr));
 
-        add_paint(dsif, paints);
+        add_paint(paints, std::move(dsif));
     }
 
     {
-        SkAutoTUnref<SkImageFilter> dsif(
+        sk_sp<SkImageFilter> dsif(
             SkDropShadowImageFilter::Create(27.0f, 27.0f,
                                             3.0f, 3.0f,
                                             SK_ColorRED,
                                             SkDropShadowImageFilter::kDrawShadowOnly_ShadowMode,
-                                            source, nullptr));
+                                            source.get(), nullptr));
 
-        add_paint(dsif, paints);
+        add_paint(paints, std::move(dsif));
     }
 
-    {
-        SkAutoTUnref<SkImageFilter> bif(SkBlurImageFilter::Create(3, 3, source));
-
-        add_paint(bif, paints);
-    }
-
-    {
-        sk_sp<SkImageFilter> oif(SkOffsetImageFilter::Make(15, 15,
-                                                           sk_ref_sp<SkImageFilter>(source)));
-
-        add_paint(oif.get(), paints);
-    }
+    add_paint(paints, SkBlurImageFilter::Make(3, 3, source));
+    add_paint(paints, SkOffsetImageFilter::Make(15, 15, source));
 }
 
 // This GM visualizes the fast bounds for various combinations of geometry
@@ -243,7 +232,7 @@ protected:
         //-----------
         // Normal paints (no source)
         SkTArray<SkPaint> paints;
-        create_paints(nullptr, &paints);
+        create_paints(&paints, nullptr);
 
         //-----------
         // Paints with a PictureImageFilter as a source
@@ -257,10 +246,8 @@ protected:
             pic = rec.finishRecordingAsPicture();
         }
 
-        sk_sp<SkImageFilter> pif(SkPictureImageFilter::Make(pic));
-
         SkTArray<SkPaint> pifPaints;
-        create_paints(pif.get(), &pifPaints);
+        create_paints(&pifPaints, SkPictureImageFilter::Make(pic));
 
         //-----------
         // Paints with a SkImageSource as a source
@@ -278,9 +265,8 @@ protected:
 
         sk_sp<SkImage> image(surface->makeImageSnapshot());
         sk_sp<SkImageFilter> imageSource(SkImageSource::Make(std::move(image)));
-
         SkTArray<SkPaint> bmsPaints;
-        create_paints(imageSource.get(), &bmsPaints);
+        create_paints(&bmsPaints, std::move(imageSource));
 
         //-----------
         SkASSERT(paints.count() == kNumVertTiles);
diff --git a/gm/imageblur.cpp b/gm/imageblur.cpp
index 22ea408e27..6a27c65beb 100644
--- a/gm/imageblur.cpp
+++ b/gm/imageblur.cpp
@@ -14,8 +14,7 @@
 
 void imageblurgm_draw(SkScalar fSigmaX, SkScalar fSigmaY, SkCanvas* canvas) {
         SkPaint paint;
-        SkAutoTUnref<SkImageFilter> blur(SkBlurImageFilter::Create(fSigmaX, fSigmaY));
-        paint.setImageFilter(blur);
+        paint.setImageFilter(SkBlurImageFilter::Make(fSigmaX, fSigmaY, nullptr));
         canvas->saveLayer(nullptr, &paint);
         const char* str = "The quick brown fox jumped over the lazy dog.";
 
diff --git a/gm/imageblur2.cpp b/gm/imageblur2.cpp
index 2b95c02ab1..c6835d8407 100644
--- a/gm/imageblur2.cpp
+++ b/gm/imageblur2.cpp
@@ -58,8 +58,7 @@ protected:
                 SkScalar sigmaY = kBlurSigmas[y];
 
                 SkPaint paint;
-                SkAutoTUnref<SkImageFilter> blur(SkBlurImageFilter::Create(sigmaX, sigmaY));
-                paint.setImageFilter(blur);
+                paint.setImageFilter(SkBlurImageFilter::Make(sigmaX, sigmaY, nullptr));
                 canvas->saveLayer(nullptr, &paint);
 
                 SkRandom rand;
@@ -89,7 +88,6 @@ private:
 
 //////////////////////////////////////////////////////////////////////////////
 
-static GM* MyFactory(void*) { return new BlurImageFilter; }
-static GMRegistry reg(MyFactory);
+DEF_GM(return new BlurImageFilter;)
 
 }
diff --git a/gm/imageblurtiled.cpp b/gm/imageblurtiled.cpp
index 9f8bfe510f..415fa7315a 100644
--- a/gm/imageblurtiled.cpp
+++ b/gm/imageblurtiled.cpp
@@ -21,27 +21,26 @@ public:
     }
 
 protected:
-    virtual SkString onShortName() {
+    SkString onShortName() override {
         return SkString("imageblurtiled");
     }
 
-    virtual SkISize onISize() {
+    SkISize onISize() override {
         return SkISize::Make(WIDTH, HEIGHT);
     }
 
-    virtual void onDraw(SkCanvas* canvas) {
+    void onDraw(SkCanvas* canvas) override {
         SkPaint paint;
-        SkAutoTUnref<SkImageFilter> blur(SkBlurImageFilter::Create(fSigmaX, fSigmaY));
-        paint.setImageFilter(blur);
-        const SkScalar tile_size = SkIntToScalar(128);
+        paint.setImageFilter(SkBlurImageFilter::Make(fSigmaX, fSigmaY, nullptr));
+        const SkScalar tileSize = SkIntToScalar(128);
         SkRect bounds;
         if (!canvas->getClipBounds(&bounds)) {
             bounds.setEmpty();
         }
-        for (SkScalar y = bounds.top(); y < bounds.bottom(); y += tile_size) {
-            for (SkScalar x = bounds.left(); x < bounds.right(); x += tile_size) {
+        for (SkScalar y = bounds.top(); y < bounds.bottom(); y += tileSize) {
+            for (SkScalar x = bounds.left(); x < bounds.right(); x += tileSize) {
                 canvas->save();
-                canvas->clipRect(SkRect::MakeXYWH(x, y, tile_size, tile_size));
+                canvas->clipRect(SkRect::MakeXYWH(x, y, tileSize, tileSize));
                 canvas->saveLayer(nullptr, &paint);
                 const char* str[] = {
                     "The quick",
@@ -74,7 +73,6 @@ private:
 
 //////////////////////////////////////////////////////////////////////////////
 
-static GM* MyFactory1(void*) { return new ImageBlurTiledGM(3.0f, 3.0f); }
-static GMRegistry reg1(MyFactory1);
+DEF_GM(return new  ImageBlurTiledGM(3.0f, 3.0f);)
 
 }
diff --git a/gm/imagefilters.cpp b/gm/imagefilters.cpp
index ab9ddf4098..10072c897e 100644
--- a/gm/imagefilters.cpp
+++ b/gm/imagefilters.cpp
@@ -87,8 +87,7 @@ DEF_SIMPLE_GM(fast_slow_blurimagefilter, canvas, 620, 260) {
     canvas->translate(10, 10);
     for (SkScalar sigma = 8; sigma <= 128; sigma *= 2) {
         SkPaint paint;
-        SkAutoTUnref<SkImageFilter> blur(SkBlurImageFilter::Create(sigma, sigma));
-        paint.setImageFilter(blur);
+        paint.setImageFilter(SkBlurImageFilter::Make(sigma, sigma, nullptr));
 
         canvas->save();
         // we outset the clip by 1, to fall out of the fast-case in drawImage
@@ -143,7 +142,7 @@ DEF_SIMPLE_GM(savelayer_with_backdrop, canvas, 830, 550) {
     auto cf(SkColorFilter::MakeMatrixFilterRowMajor255(cm.fMat));
     const SkScalar kernel[] = { 4, 0, 4, 0, -15, 0, 4, 0, 4 };
     SkImageFilter* filters[] = {
-        SkBlurImageFilter::Create(10, 10),
+        SkBlurImageFilter::Make(10, 10, nullptr).release(),
         SkDilateImageFilter::Create(8, 8),
         SkMatrixConvolutionImageFilter::Create({ 3, 3 }, kernel, 1, 0, { 0, 0 },
                                            SkMatrixConvolutionImageFilter::kClampToBlack_TileMode,
diff --git a/gm/imagefiltersbase.cpp b/gm/imagefiltersbase.cpp
index 3c1cf0991c..d2367e285a 100644
--- a/gm/imagefiltersbase.cpp
+++ b/gm/imagefiltersbase.cpp
@@ -198,7 +198,7 @@ protected:
             IdentityImageFilter::Create(),
             FailImageFilter::Create(),
             SkColorFilterImageFilter::Create(cf.get()),
-            SkBlurImageFilter::Create(12.0f, 0.0f),
+            SkBlurImageFilter::Make(12.0f, 0.0f, nullptr).release(),
             SkDropShadowImageFilter::Create(10.0f, 5.0f, 3.0f, 3.0f, SK_ColorBLUE,
                 SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode),
         };
@@ -308,7 +308,7 @@ public:
     ImageFiltersText_IF() : ImageFiltersTextBaseGM("image") {}
 
     void installFilter(SkPaint* paint) override {
-        paint->setImageFilter(SkBlurImageFilter::Create(1.5f, 1.5f))->unref();
+        paint->setImageFilter(SkBlurImageFilter::Make(1.5f, 1.5f, nullptr));
     }
 };
 DEF_GM( return new ImageFiltersText_IF; )
diff --git a/gm/imagefiltersclipped.cpp b/gm/imagefiltersclipped.cpp
index 31f8ad2787..85c5438bca 100644
--- a/gm/imagefiltersclipped.cpp
+++ b/gm/imagefiltersclipped.cpp
@@ -94,7 +94,7 @@ protected:
         SkPoint3 pointLocation = SkPoint3::Make(32, 32, SkIntToScalar(10));
 
         SkImageFilter* filters[] = {
-            SkBlurImageFilter::Create(SkIntToScalar(12), SkIntToScalar(12)),
+            SkBlurImageFilter::Make(SkIntToScalar(12), SkIntToScalar(12), nullptr).release(),
             SkDropShadowImageFilter::Create(SkIntToScalar(10), SkIntToScalar(10),
                 SkIntToScalar(3), SkIntToScalar(3), SK_ColorGREEN,
                 SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode),
diff --git a/gm/imagefilterscropexpand.cpp b/gm/imagefilterscropexpand.cpp
index 82df81cbdb..f1a132369a 100644
--- a/gm/imagefilterscropexpand.cpp
+++ b/gm/imagefilterscropexpand.cpp
@@ -80,15 +80,13 @@ protected:
                                                                        noopCropped.get(),
                                                                        &bigRect)));
 
-            Draw(canvas, checkerboard, rect,
-                 sk_sp<SkImageFilter>(SkBlurImageFilter::Create(0.3f, 0.3f,
-                                                                noopCropped.get(),
-                                                                &bigRect)));
+            Draw(canvas, checkerboard, rect, SkBlurImageFilter::Make(0.3f, 0.3f,
+                                                                     noopCropped,
+                                                                     &bigRect));
 
-            Draw(canvas, checkerboard, rect,
-                 sk_sp<SkImageFilter>(SkBlurImageFilter::Create(8.0f, 8.0f,
-                                                                noopCropped.get(),
-                                                                &bigRect)));
+            Draw(canvas, checkerboard, rect, SkBlurImageFilter::Make(8.0f, 8.0f,
+                                                                     noopCropped,
+                                                                     &bigRect));
 
             Draw(canvas, checkerboard, rect,
                  sk_sp<SkImageFilter>(SkDilateImageFilter::Create(2, 2,
diff --git a/gm/imagefilterscropped.cpp b/gm/imagefilterscropped.cpp
index 9c8705cfae..1e880fe68a 100644
--- a/gm/imagefilterscropped.cpp
+++ b/gm/imagefilterscropped.cpp
@@ -131,18 +131,18 @@ protected:
         SkImageFilter* filters[] = {
             nullptr,
             SkColorFilterImageFilter::Create(cf.get(), nullptr, &cropRect),
-            SkBlurImageFilter::Create(0.0f, 0.0f, nullptr, &cropRect),
-            SkBlurImageFilter::Create(1.0f, 1.0f, nullptr, &cropRect),
-            SkBlurImageFilter::Create(8.0f, 0.0f, nullptr, &cropRect),
-            SkBlurImageFilter::Create(0.0f, 8.0f, nullptr, &cropRect),
-            SkBlurImageFilter::Create(8.0f, 8.0f, nullptr, &cropRect),
+            SkBlurImageFilter::Make(0.0f, 0.0f, nullptr, &cropRect).release(),
+            SkBlurImageFilter::Make(1.0f, 1.0f, nullptr, &cropRect).release(),
+            SkBlurImageFilter::Make(8.0f, 0.0f, nullptr, &cropRect).release(),
+            SkBlurImageFilter::Make(0.0f, 8.0f, nullptr, &cropRect).release(),
+            SkBlurImageFilter::Make(8.0f, 8.0f, nullptr, &cropRect).release(),
             SkErodeImageFilter::Create(1, 1, nullptr, &cropRect),
             SkErodeImageFilter::Create(8, 0, erodeY, &cropRect),
             SkErodeImageFilter::Create(0, 8, erodeX, &cropRect),
             SkErodeImageFilter::Create(8, 8, nullptr, &cropRect),
             SkMergeImageFilter::Make(nullptr, std::move(cfOffset),
                                      SkXfermode::kSrcOver_Mode, &cropRect).release(),
-            SkBlurImageFilter::Create(8.0f, 8.0f, nullptr, &bogusRect),
+            SkBlurImageFilter::Make(8.0f, 8.0f, nullptr, &bogusRect).release(),
             SkColorFilterImageFilter::Create(cf.get(), nullptr, &bogusRect),
         };
 
diff --git a/gm/imagefiltersgraph.cpp b/gm/imagefiltersgraph.cpp
index c0c652b46d..b7402eea1b 100644
--- a/gm/imagefiltersgraph.cpp
+++ b/gm/imagefiltersgraph.cpp
@@ -121,7 +121,7 @@ protected:
             sk_sp<SkImageFilter> bitmapSource(SkImageSource::Make(fImage));
             sk_sp<SkColorFilter> cf(SkColorFilter::MakeModeFilter(SK_ColorRED,
                                                                   SkXfermode::kSrcIn_Mode));
-            sk_sp<SkImageFilter> blur(SkBlurImageFilter::Create(4.0f, 4.0f, bitmapSource.get()));
+            sk_sp<SkImageFilter> blur(SkBlurImageFilter::Make(4.0f, 4.0f, std::move(bitmapSource)));
             sk_sp<SkImageFilter> erode(SkErodeImageFilter::Create(4, 4, blur.get()));
             sk_sp<SkImageFilter> color(SkColorFilterImageFilter::Create(cf.get(), erode.get()));
             sk_sp<SkImageFilter> merge(SkMergeImageFilter::Make(blur, color));
@@ -167,13 +167,14 @@ protected:
             canvas->translate(SkIntToScalar(100), 0);
         }
         {
-            SkAutoTUnref<SkImageFilter> blur(SkBlurImageFilter::Create(
-              SkIntToScalar(10), SkIntToScalar(10)));
+            sk_sp<SkImageFilter> blur(SkBlurImageFilter::Make(SkIntToScalar(10),
+                                                              SkIntToScalar(10),
+                                                              nullptr));
 
             SkImageFilter::CropRect cropRect(SkRect::MakeWH(SkIntToScalar(95), SkIntToScalar(100)));
             SkPaint paint;
             paint.setImageFilter(
-                SkXfermodeImageFilter::Make(SkXfermode::Make(SkXfermode::kSrcIn_Mode), blur,
+                SkXfermodeImageFilter::Make(SkXfermode::Make(SkXfermode::kSrcIn_Mode), blur.get(),
                                             nullptr, &cropRect));
             DrawClippedImage(canvas, fImage.get(), paint);
             canvas->translate(SkIntToScalar(100), 0);
diff --git a/gm/imagefiltersscaled.cpp b/gm/imagefiltersscaled.cpp
index 61eb4690ba..56a1484f21 100644
--- a/gm/imagefiltersscaled.cpp
+++ b/gm/imagefiltersscaled.cpp
@@ -73,7 +73,7 @@ protected:
         resizeMatrix.setScale(RESIZE_FACTOR, RESIZE_FACTOR);
 
         SkImageFilter* filters[] = {
-            SkBlurImageFilter::Create(SkIntToScalar(4), SkIntToScalar(4)),
+            SkBlurImageFilter::Make(SkIntToScalar(4), SkIntToScalar(4), nullptr).release(),
             SkDropShadowImageFilter::Create(SkIntToScalar(5), SkIntToScalar(10),
                 SkIntToScalar(3), SkIntToScalar(3), SK_ColorYELLOW,
                 SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode),
diff --git a/gm/imagefiltersstroked.cpp b/gm/imagefiltersstroked.cpp
index 9275990573..81f814548c 100644
--- a/gm/imagefiltersstroked.cpp
+++ b/gm/imagefiltersstroked.cpp
@@ -58,7 +58,7 @@ protected:
         resizeMatrix.setScale(RESIZE_FACTOR_X, RESIZE_FACTOR_Y);
 
         SkImageFilter* filters[] = {
-            SkBlurImageFilter::Create(5, 5),
+            SkBlurImageFilter::Make(5, 5, nullptr).release(),
             SkDropShadowImageFilter::Create(10, 10, 3, 3, SK_ColorGREEN,
                 SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode),
             SkOffsetImageFilter::Make(-16, 32, nullptr).release(),
diff --git a/gm/imagefilterstransformed.cpp b/gm/imagefilterstransformed.cpp
index a9b1863ace..687e458f1f 100644
--- a/gm/imagefilterstransformed.cpp
+++ b/gm/imagefilterstransformed.cpp
@@ -66,7 +66,7 @@ protected:
         sk_sp<SkImageFilter> gradient(SkImageSource::Make(fGradientCircle));
         sk_sp<SkImageFilter> checkerboard(SkImageSource::Make(fCheckerboard));
         SkImageFilter* filters[] = {
-            SkBlurImageFilter::Create(12, 0),
+            SkBlurImageFilter::Make(12, 0, nullptr).release(),
             SkDropShadowImageFilter::Create(0, 15, 8, 0, SK_ColorGREEN,
                 SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode),
             SkDisplacementMapEffect::Create(SkDisplacementMapEffect::kR_ChannelSelectorType,
diff --git a/gm/localmatriximagefilter.cpp b/gm/localmatriximagefilter.cpp
index 5c49671cd6..baa44b9d0b 100644
--- a/gm/localmatriximagefilter.cpp
+++ b/gm/localmatriximagefilter.cpp
@@ -65,7 +65,7 @@ protected:
         sk_sp<SkImage> image0(make_image(canvas));
 
         const ImageFilterFactory factories[] = {
-            IFCCast([]{ return SkBlurImageFilter::Create(8, 8); }),
+            IFCCast([]{ return SkBlurImageFilter::Make(8, 8, nullptr).release(); }),
             IFCCast([]{ return SkDilateImageFilter::Create(8, 8); }),
             IFCCast([]{ return SkErodeImageFilter::Create(8, 8); }),
             IFCCast([]{ return SkOffsetImageFilter::Make(8, 8, nullptr).release(); }),
diff --git a/gm/spritebitmap.cpp b/gm/spritebitmap.cpp
index 6c438fad11..38fe9f4302 100644
--- a/gm/spritebitmap.cpp
+++ b/gm/spritebitmap.cpp
@@ -23,7 +23,7 @@ static void make_bm(SkBitmap* bm) {
 }
 
 static void draw_1_bitmap(SkCanvas* canvas, const SkBitmap& bm, bool doClip,
-                         int dx, int dy, SkImageFilter* filter = nullptr) {
+                         int dx, int dy, sk_sp<SkImageFilter> filter) {
     SkAutoCanvasRestore acr(canvas, true);
     SkPaint paint;
 
@@ -32,7 +32,7 @@ static void draw_1_bitmap(SkCanvas* canvas, const SkBitmap& bm, bool doClip,
                                     SkIntToScalar(bm.width()),
                                     SkIntToScalar(bm.height()));
 
-    paint.setImageFilter(filter);
+    paint.setImageFilter(std::move(filter));
     clipR.inset(5, 5);
 
     canvas->translate(SkIntToScalar(bm.width() + 20), 0);
@@ -72,13 +72,13 @@ protected:
         int dy = 10;
 
         SkScalar sigma = 8;
-        SkAutoTUnref<SkImageFilter> filter(SkBlurImageFilter::Create(sigma, sigma));
+        sk_sp<SkImageFilter> filter(SkBlurImageFilter::Make(sigma, sigma, nullptr));
 
-        draw_1_bitmap(canvas, bm, false, dx, dy);
+        draw_1_bitmap(canvas, bm, false, dx, dy, nullptr);
         dy += bm.height() + 20;
         draw_1_bitmap(canvas, bm, false, dx, dy, filter);
         dy += bm.height() + 20;
-        draw_1_bitmap(canvas, bm, true, dx, dy);
+        draw_1_bitmap(canvas, bm, true, dx, dy, nullptr);
         dy += bm.height() + 20;
         draw_1_bitmap(canvas, bm, true, dx, dy, filter);
     }
diff --git a/gm/testimagefilters.cpp b/gm/testimagefilters.cpp
index 9c2a5a9d4c..ab277716d7 100644
--- a/gm/testimagefilters.cpp
+++ b/gm/testimagefilters.cpp
@@ -35,7 +35,7 @@ static sk_sp<SkImageFilter> make2() {
 }
 
 static sk_sp<SkImageFilter> make3() {
-    return sk_sp<SkImageFilter>(SkBlurImageFilter::Create(8, 0));
+    return SkBlurImageFilter::Make(8, 0, nullptr);
 }
 
 static sk_sp<SkImageFilter> make4() {
diff --git a/include/effects/SkBlurImageFilter.h b/include/effects/SkBlurImageFilter.h
index 682c08f294..607e76de51 100644
--- a/include/effects/SkBlurImageFilter.h
+++ b/include/effects/SkBlurImageFilter.h
@@ -13,12 +13,12 @@
 
 class SK_API SkBlurImageFilter : public SkImageFilter {
 public:
-    static SkImageFilter* Create(SkScalar sigmaX, SkScalar sigmaY, SkImageFilter* input = NULL,
-                                 const CropRect* cropRect = NULL) {
+    static sk_sp<SkImageFilter> Make(SkScalar sigmaX, SkScalar sigmaY, sk_sp<SkImageFilter> input,
+                                     const CropRect* cropRect = nullptr) {
         if (0 == sigmaX && 0 == sigmaY && nullptr == cropRect) {
-            return SkSafeRef(input);
+            return input;
         }
-        return new SkBlurImageFilter(sigmaX, sigmaY, input, cropRect);
+        return sk_sp<SkImageFilter>(new SkBlurImageFilter(sigmaX, sigmaY, input, cropRect));
     }
 
     SkRect computeFastBounds(const SkRect&) const override;
@@ -26,6 +26,13 @@ public:
     SK_TO_STRING_OVERRIDE()
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkBlurImageFilter)
 
+#ifdef SK_SUPPORT_LEGACY_IMAGEFILTER_PTR
+    static SkImageFilter* Create(SkScalar sigmaX, SkScalar sigmaY, SkImageFilter* input = nullptr,
+                                 const CropRect* cropRect = nullptr) {
+        return Make(sigmaX, sigmaY, sk_ref_sp<SkImageFilter>(input), cropRect).release();
+    }
+#endif
+
 protected:
     void flatten(SkWriteBuffer&) const override;
     sk_sp<SkSpecialImage> onFilterImage(SkSpecialImage* source, const Context&,
@@ -35,7 +42,7 @@ protected:
 private:
     SkBlurImageFilter(SkScalar sigmaX,
                       SkScalar sigmaY,
-                      SkImageFilter* input,
+                      sk_sp<SkImageFilter> input,
                       const CropRect* cropRect);
 
     SkSize   fSigma;
diff --git a/samplecode/SampleFilterFuzz.cpp b/samplecode/SampleFilterFuzz.cpp
index dd17e7ee70..6413aa103f 100644
--- a/samplecode/SampleFilterFuzz.cpp
+++ b/samplecode/SampleFilterFuzz.cpp
@@ -583,13 +583,11 @@ static sk_sp<SkImageFilter> make_image_filter(bool canBeNull) {
                     : nullptr;
         break;
     }
-    case BLUR: {
-        sk_sp<SkImageFilter> subFilter(make_image_filter());
-        filter = sk_sp<SkImageFilter>(SkBlurImageFilter::Create(make_scalar(true),
-                                                                make_scalar(true),
-                                                                subFilter.get()));
+    case BLUR:
+        filter = SkBlurImageFilter::Make(make_scalar(true),
+                                         make_scalar(true),
+                                         make_image_filter());
         break;
-    }
     case MAGNIFIER:
         filter = sk_sp<SkImageFilter>(SkMagnifierImageFilter::Create(make_rect(), 
                                                                      make_scalar(true)));
diff --git a/src/effects/SkBlurImageFilter.cpp b/src/effects/SkBlurImageFilter.cpp
index e7b326b7a9..b7745e27bf 100644
--- a/src/effects/SkBlurImageFilter.cpp
+++ b/src/effects/SkBlurImageFilter.cpp
@@ -37,17 +37,17 @@ static SkVector map_sigma(const SkSize& localSigma, const SkMatrix& ctm) {
 
 SkBlurImageFilter::SkBlurImageFilter(SkScalar sigmaX,
                                      SkScalar sigmaY,
-                                     SkImageFilter* input,
+                                     sk_sp<SkImageFilter> input,
                                      const CropRect* cropRect)
-    : INHERITED(1, &input, cropRect), fSigma(SkSize::Make(sigmaX, sigmaY)) {
+    : INHERITED(&input, 1, cropRect)
+    , fSigma(SkSize::Make(sigmaX, sigmaY)) {
 }
 
 sk_sp<SkFlattenable> SkBlurImageFilter::CreateProc(SkReadBuffer& buffer) {
     SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
     SkScalar sigmaX = buffer.readScalar();
     SkScalar sigmaY = buffer.readScalar();
-    return sk_sp<SkFlattenable>(Create(sigmaX, sigmaY, common.getInput(0).get(),
-                                       &common.cropRect()));
+    return Make(sigmaX, sigmaY, common.getInput(0), &common.cropRect());
 }
 
 void SkBlurImageFilter::flatten(SkWriteBuffer& buffer) const {
diff --git a/src/effects/SkDropShadowImageFilter.cpp b/src/effects/SkDropShadowImageFilter.cpp
index 331cfbd68b..9cacad5513 100644
--- a/src/effects/SkDropShadowImageFilter.cpp
+++ b/src/effects/SkDropShadowImageFilter.cpp
@@ -84,9 +84,8 @@ sk_sp<SkSpecialImage> SkDropShadowImageFilter::onFilterImage(SkSpecialImage* sou
     sigma.fX = SkMaxScalar(0, sigma.fX);
     sigma.fY = SkMaxScalar(0, sigma.fY);
 
-    SkAutoTUnref<SkImageFilter> blurFilter(SkBlurImageFilter::Create(sigma.fX, sigma.fY));
     SkPaint paint;
-    paint.setImageFilter(blurFilter.get());
+    paint.setImageFilter(SkBlurImageFilter::Make(sigma.fX, sigma.fY, nullptr));
     paint.setColorFilter(SkColorFilter::MakeModeFilter(fColor, SkXfermode::kSrcIn_Mode));
     paint.setXfermodeMode(SkXfermode::kSrcOver_Mode);
 
diff --git a/src/utils/SkLua.cpp b/src/utils/SkLua.cpp
index 9af5bfd84e..9369a6bd9d 100644
--- a/src/utils/SkLua.cpp
+++ b/src/utils/SkLua.cpp
@@ -1963,11 +1963,11 @@ static int lsk_newDocumentPDF(lua_State* L) {
 static int lsk_newBlurImageFilter(lua_State* L) {
     SkScalar sigmaX = lua2scalar_def(L, 1, 0);
     SkScalar sigmaY = lua2scalar_def(L, 2, 0);
-    SkImageFilter* imf = SkBlurImageFilter::Create(sigmaX, sigmaY);
-    if (nullptr == imf) {
+    sk_sp<SkImageFilter> imf(SkBlurImageFilter::Make(sigmaX, sigmaY, nullptr));
+    if (!imf) {
         lua_pushnil(L);
     } else {
-        push_ref(L, imf)->unref();
+        push_ref(L, std::move(imf));
     }
     return 1;
 }
@@ -1982,7 +1982,8 @@ static int lsk_newLinearGradient(lua_State* L) {
 
     SkPoint pts[] = { { x0, y0 }, { x1, y1 } };
     SkColor colors[] = { c0, c1 };
-    auto s = SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode);
+    sk_sp<SkShader> s(SkGradientShader::MakeLinear(pts, colors, nullptr, 2,
+                                                   SkShader::kClamp_TileMode));
     if (!s) {
         lua_pushnil(L);
     } else {
diff --git a/tests/ImageFilterTest.cpp b/tests/ImageFilterTest.cpp
index 3f60286e39..f873fa0822 100644
--- a/tests/ImageFilterTest.cpp
+++ b/tests/ImageFilterTest.cpp
@@ -106,7 +106,6 @@ SkBitmap make_gradient_circle(int width, int height) {
 class FilterList {
 public:
     FilterList(SkImageFilter* input = nullptr, const SkImageFilter::CropRect* cropRect = nullptr) {
-        auto cf(SkColorFilter::MakeModeFilter(SK_ColorRED, SkXfermode::kSrcIn_Mode));
         SkPoint3 location = SkPoint3::Make(0, 0, SK_Scalar1);
         SkScalar kernel[9] = {
             SkIntToScalar( 1), SkIntToScalar( 1), SkIntToScalar( 1),
@@ -117,46 +116,33 @@ public:
         const SkScalar gain = SK_Scalar1, bias = 0;
         const SkScalar five = SkIntToScalar(5);
 
-        sk_sp<SkImage> gradientImage(SkImage::MakeFromBitmap(make_gradient_circle(64, 64)));
-        sk_sp<SkImageFilter> gradientSource(SkImageSource::Make(std::move(gradientImage)));
-        sk_sp<SkImageFilter> blur(SkBlurImageFilter::Create(five, five, input));
         SkMatrix matrix;
 
         matrix.setTranslate(SK_Scalar1, SK_Scalar1);
         matrix.postRotate(SkIntToScalar(45), SK_Scalar1, SK_Scalar1);
 
-        SkRTreeFactory factory;
-        SkPictureRecorder recorder;
-        SkCanvas* recordingCanvas = recorder.beginRecording(64, 64, &factory, 0);
+        {
+            sk_sp<SkColorFilter> cf(SkColorFilter::MakeModeFilter(SK_ColorRED,
+                                                                  SkXfermode::kSrcIn_Mode));
 
-        SkPaint greenPaint;
-        greenPaint.setColor(SK_ColorGREEN);
-        recordingCanvas->drawRect(SkRect::Make(SkIRect::MakeXYWH(10, 10, 30, 20)), greenPaint);
-        sk_sp<SkPicture> picture(recorder.finishRecordingAsPicture());
-        sk_sp<SkImageFilter> pictureFilter(SkPictureImageFilter::Make(picture));
-        sk_sp<SkShader> shader(SkPerlinNoiseShader::MakeTurbulence(SK_Scalar1, SK_Scalar1, 1, 0));
+            this->addFilter("color filter",
+                SkColorFilterImageFilter::Create(cf.get(), input, cropRect));
+        }
 
-        SkPaint paint;
-        paint.setShader(shader);
-        sk_sp<SkImageFilter> paintFilter(SkPaintImageFilter::Make(paint));
-
-        sk_sp<SkShader> greenColorShader(SkShader::MakeColorShader(SK_ColorGREEN));
-        SkPaint greenColorShaderPaint;
-        greenColorShaderPaint.setShader(greenColorShader);
-        SkImageFilter::CropRect leftSideCropRect(SkRect::MakeXYWH(0, 0, 32, 64));
-        sk_sp<SkImageFilter> paintFilterLeft(SkPaintImageFilter::Make(greenColorShaderPaint,
-                                                                      &leftSideCropRect));
-        SkImageFilter::CropRect rightSideCropRect(SkRect::MakeXYWH(32, 0, 32, 64));
-        sk_sp<SkImageFilter> paintFilterRight(SkPaintImageFilter::Make(greenColorShaderPaint,
-                                                                       &rightSideCropRect));
-
-        this->addFilter("color filter",
-            SkColorFilterImageFilter::Create(cf.get(), input, cropRect));
-        this->addFilter("displacement map", SkDisplacementMapEffect::Create(
-            SkDisplacementMapEffect::kR_ChannelSelectorType,
-            SkDisplacementMapEffect::kB_ChannelSelectorType,
-            20.0f, gradientSource.get(), input, cropRect));
-        this->addFilter("blur", SkBlurImageFilter::Create(SK_Scalar1, SK_Scalar1, input, cropRect));
+        {
+            sk_sp<SkImage> gradientImage(SkImage::MakeFromBitmap(make_gradient_circle(64, 64)));
+            sk_sp<SkImageFilter> gradientSource(SkImageSource::Make(std::move(gradientImage)));
+
+            this->addFilter("displacement map", SkDisplacementMapEffect::Create(
+                SkDisplacementMapEffect::kR_ChannelSelectorType,
+                SkDisplacementMapEffect::kB_ChannelSelectorType,
+                20.0f, gradientSource.get(), input, cropRect));
+        }
+
+        this->addFilter("blur", SkBlurImageFilter::Make(SK_Scalar1,
+                                                        SK_Scalar1,
+                                                        sk_ref_sp<SkImageFilter>(input),
+                                                        cropRect).release());
         this->addFilter("drop shadow", SkDropShadowImageFilter::Create(
                   SK_Scalar1, SK_Scalar1, SK_Scalar1, SK_Scalar1, SK_ColorGREEN,
                   SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode, input, cropRect));
@@ -173,9 +159,23 @@ public:
                                                           sk_ref_sp<SkImageFilter>(input),
                                                           SkXfermode::kSrcOver_Mode,
                                                           cropRect).release());
-        this->addFilter("merge with disjoint inputs", SkMergeImageFilter::Make(
+        {
+            SkPaint greenColorShaderPaint;
+            greenColorShaderPaint.setShader(SkShader::MakeColorShader(SK_ColorGREEN));
+
+            SkImageFilter::CropRect leftSideCropRect(SkRect::MakeXYWH(0, 0, 32, 64));
+            sk_sp<SkImageFilter> paintFilterLeft(SkPaintImageFilter::Make(greenColorShaderPaint,
+                                                                          &leftSideCropRect));
+            SkImageFilter::CropRect rightSideCropRect(SkRect::MakeXYWH(32, 0, 32, 64));
+            sk_sp<SkImageFilter> paintFilterRight(SkPaintImageFilter::Make(greenColorShaderPaint,
+                                                                           &rightSideCropRect));
+
+
+            this->addFilter("merge with disjoint inputs", SkMergeImageFilter::Make(
                   std::move(paintFilterLeft), std::move(paintFilterRight),
                   SkXfermode::kSrcOver_Mode, cropRect).release());
+        }
+
         this->addFilter("offset",
                         SkOffsetImageFilter::Make(SK_Scalar1, SK_Scalar1,
                                                   sk_ref_sp<SkImageFilter>(input),
@@ -190,13 +190,39 @@ public:
             this->addFilter("matrix", SkImageFilter::CreateMatrixFilter(
                 matrix, kLow_SkFilterQuality, input));
         }
-        this->addFilter("blur and offset",
-                        SkOffsetImageFilter::Make(five, five, blur,
-                                                  cropRect).release());
-        this->addFilter("picture and blur", SkBlurImageFilter::Create(
-            five, five, pictureFilter.get(), cropRect));
-        this->addFilter("paint and blur", SkBlurImageFilter::Create(
-            five, five, paintFilter.get(), cropRect));
+
+        {
+            sk_sp<SkImageFilter> blur(SkBlurImageFilter::Make(five, five, 
+                                                              sk_ref_sp<SkImageFilter>(input)));
+
+            this->addFilter("blur and offset", SkOffsetImageFilter::Make(five, five,
+                                                                         std::move(blur),
+                                                                         cropRect).release());
+        }
+        {
+            SkRTreeFactory factory;
+            SkPictureRecorder recorder;
+            SkCanvas* recordingCanvas = recorder.beginRecording(64, 64, &factory, 0);
+
+            SkPaint greenPaint;
+            greenPaint.setColor(SK_ColorGREEN);
+            recordingCanvas->drawRect(SkRect::Make(SkIRect::MakeXYWH(10, 10, 30, 20)), greenPaint);
+            sk_sp<SkPicture> picture(recorder.finishRecordingAsPicture());
+            sk_sp<SkImageFilter> pictureFilter(SkPictureImageFilter::Make(std::move(picture)));
+
+            this->addFilter("picture and blur", SkBlurImageFilter::Make(five, five,
+                                                                        std::move(pictureFilter),
+                                                                        cropRect).release());
+        }
+        {
+            SkPaint paint;
+            paint.setShader(SkPerlinNoiseShader::MakeTurbulence(SK_Scalar1, SK_Scalar1, 1, 0));
+            sk_sp<SkImageFilter> paintFilter(SkPaintImageFilter::Make(paint));
+
+            this->addFilter("paint and blur", SkBlurImageFilter::Make(five, five,
+                                                                      std::move(paintFilter),
+                                                                      cropRect).release());
+        }
         this->addFilter("xfermode", SkXfermodeImageFilter::Make(
             SkXfermode::Make(SkXfermode::kSrc_Mode), input, input, cropRect).release());
     }
@@ -477,8 +503,8 @@ static void test_negative_blur_sigma(SkImageFilter::Proxy* proxy,
     const int width = 32, height = 32;
     const SkScalar five = SkIntToScalar(5);
 
-    SkAutoTUnref<SkImageFilter> positiveFilter(SkBlurImageFilter::Create(five, five));
-    SkAutoTUnref<SkImageFilter> negativeFilter(SkBlurImageFilter::Create(-five, five));
+    sk_sp<SkImageFilter> positiveFilter(SkBlurImageFilter::Make(five, five, nullptr));
+    sk_sp<SkImageFilter> negativeFilter(SkBlurImageFilter::Make(-five, five, nullptr));
 
     SkBitmap gradient = make_gradient_circle(width, height);
     sk_sp<SkSpecialImage> imgSrc(SkSpecialImage::MakeFromRaster(proxy,
@@ -599,7 +625,7 @@ static void test_zero_blur_sigma(SkImageFilter::Proxy* proxy,
     // Check that SkBlurImageFilter with a zero sigma and a non-zero srcOffset works correctly.
     SkImageFilter::CropRect cropRect(SkRect::Make(SkIRect::MakeXYWH(5, 0, 5, 10)));
     sk_sp<SkImageFilter> input(SkOffsetImageFilter::Make(0, 0, nullptr, &cropRect));
-    sk_sp<SkImageFilter> filter(SkBlurImageFilter::Create(0, 0, input.get(), &cropRect));
+    sk_sp<SkImageFilter> filter(SkBlurImageFilter::Make(0, 0, std::move(input), &cropRect));
 
     sk_sp<SkSpecialSurface> surf(create_empty_special_surface(context, proxy, 10));
     surf->getCanvas()->clear(SK_ColorGREEN);
@@ -742,21 +768,21 @@ DEF_TEST(ImageFilterDrawMatrixBBH, reporter) {
     }
 }
 
-static SkImageFilter* makeBlur(SkImageFilter* input = nullptr) {
-    return SkBlurImageFilter::Create(SK_Scalar1, SK_Scalar1, input);
+static sk_sp<SkImageFilter> make_blur(sk_sp<SkImageFilter> input) {
+    return SkBlurImageFilter::Make(SK_Scalar1, SK_Scalar1, std::move(input));
 }
 
-static SkImageFilter* makeDropShadow(SkImageFilter* input = nullptr) {
-    return SkDropShadowImageFilter::Create(
+static sk_sp<SkImageFilter> make_drop_shadow(sk_sp<SkImageFilter> input) {
+    return sk_sp<SkImageFilter>(SkDropShadowImageFilter::Create(
         SkIntToScalar(100), SkIntToScalar(100),
         SkIntToScalar(10), SkIntToScalar(10),
         SK_ColorBLUE, SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode,
-        input, nullptr);
+        input.get(), nullptr));
 }
 
 DEF_TEST(ImageFilterBlurThenShadowBounds, reporter) {
-    SkAutoTUnref<SkImageFilter> filter1(makeBlur());
-    SkAutoTUnref<SkImageFilter> filter2(makeDropShadow(filter1.get()));
+    sk_sp<SkImageFilter> filter1(make_blur(nullptr));
+    sk_sp<SkImageFilter> filter2(make_drop_shadow(std::move(filter1)));
 
     SkIRect bounds = SkIRect::MakeXYWH(0, 0, 100, 100);
     SkIRect expectedBounds = SkIRect::MakeXYWH(-133, -133, 236, 236);
@@ -766,8 +792,8 @@ DEF_TEST(ImageFilterBlurThenShadowBounds, reporter) {
 }
 
 DEF_TEST(ImageFilterShadowThenBlurBounds, reporter) {
-    SkAutoTUnref<SkImageFilter> filter1(makeDropShadow());
-    SkAutoTUnref<SkImageFilter> filter2(makeBlur(filter1.get()));
+    sk_sp<SkImageFilter> filter1(make_drop_shadow(nullptr));
+    sk_sp<SkImageFilter> filter2(make_blur(std::move(filter1)));
 
     SkIRect bounds = SkIRect::MakeXYWH(0, 0, 100, 100);
     SkIRect expectedBounds = SkIRect::MakeXYWH(-133, -133, 236, 236);
@@ -777,8 +803,8 @@ DEF_TEST(ImageFilterShadowThenBlurBounds, reporter) {
 }
 
 DEF_TEST(ImageFilterDilateThenBlurBounds, reporter) {
-    SkAutoTUnref<SkImageFilter> filter1(SkDilateImageFilter::Create(2, 2));
-    SkAutoTUnref<SkImageFilter> filter2(makeDropShadow(filter1.get()));
+    sk_sp<SkImageFilter> filter1(SkDilateImageFilter::Create(2, 2));
+    sk_sp<SkImageFilter> filter2(make_drop_shadow(std::move(filter1)));
 
     SkIRect bounds = SkIRect::MakeXYWH(0, 0, 100, 100);
     SkIRect expectedBounds = SkIRect::MakeXYWH(-132, -132, 234, 234);
@@ -788,8 +814,8 @@ DEF_TEST(ImageFilterDilateThenBlurBounds, reporter) {
 }
 
 DEF_TEST(ImageFilterComposedBlurFastBounds, reporter) {
-    sk_sp<SkImageFilter> filter1(makeBlur());
-    sk_sp<SkImageFilter> filter2(makeBlur());
+    sk_sp<SkImageFilter> filter1(make_blur(nullptr));
+    sk_sp<SkImageFilter> filter2(make_blur(nullptr));
     sk_sp<SkImageFilter> composedFilter(SkComposeImageFilter::Make(std::move(filter1),
                                                                    std::move(filter2)));
 
@@ -854,10 +880,9 @@ DEF_GPUTEST_FOR_NATIVE_CONTEXT(ImageFilterMergeResultSize_Gpu, reporter, context
 #endif
 
 static void draw_blurred_rect(SkCanvas* canvas) {
-    SkAutoTUnref<SkImageFilter> filter(SkBlurImageFilter::Create(SkIntToScalar(8), 0));
     SkPaint filterPaint;
     filterPaint.setColor(SK_ColorWHITE);
-    filterPaint.setImageFilter(filter);
+    filterPaint.setImageFilter(SkBlurImageFilter::Make(SkIntToScalar(8), 0, nullptr));
     canvas->saveLayer(nullptr, &filterPaint);
     SkPaint whitePaint;
     whitePaint.setColor(SK_ColorWHITE);
@@ -1172,10 +1197,10 @@ static void test_huge_blur(SkCanvas* canvas, skiatest::Reporter* reporter) {
     bitmap.eraseARGB(0, 0, 0, 0);
 
     // Check that a blur with an insane radius does not crash or assert.
-    SkAutoTUnref<SkImageFilter> blur(SkBlurImageFilter::Create(SkIntToScalar(1<<30), SkIntToScalar(1<<30)));
-
     SkPaint paint;
-    paint.setImageFilter(blur);
+    paint.setImageFilter(SkBlurImageFilter::Make(SkIntToScalar(1<<30),
+                                                 SkIntToScalar(1<<30),
+                                                 nullptr));
     canvas->drawBitmap(bitmap, 0, 0, &paint);
 }
 
@@ -1344,8 +1369,8 @@ static void test_composed_imagefilter_offset(SkImageFilter::Proxy* proxy,
 
     SkImageFilter::CropRect cropRect(SkRect::MakeXYWH(1, 0, 20, 20));
     sk_sp<SkImageFilter> offsetFilter(SkOffsetImageFilter::Make(0, 0, nullptr, &cropRect));
-    sk_sp<SkImageFilter> blurFilter(SkBlurImageFilter::Create(SK_Scalar1, SK_Scalar1,
-                                                              nullptr, &cropRect));
+    sk_sp<SkImageFilter> blurFilter(SkBlurImageFilter::Make(SK_Scalar1, SK_Scalar1,
+                                                            nullptr, &cropRect));
     sk_sp<SkImageFilter> composedFilter(SkComposeImageFilter::Make(std::move(blurFilter),
                                                                    std::move(offsetFilter)));
     SkIPoint offset;
@@ -1447,31 +1472,37 @@ DEF_TEST(ImageFilterCanComputeFastBounds, reporter) {
           location, SK_ColorGREEN, 0, 0));
     REPORTER_ASSERT(reporter, !lighting->canComputeFastBounds());
 
-    SkAutoTUnref<SkImageFilter> gray(make_grayscale(nullptr, nullptr));
-    REPORTER_ASSERT(reporter, gray->canComputeFastBounds());
     {
-        SkColorFilter* grayCF;
-        REPORTER_ASSERT(reporter, gray->asAColorFilter(&grayCF));
-        REPORTER_ASSERT(reporter, !grayCF->affectsTransparentBlack());
-        grayCF->unref();
-    }
-    REPORTER_ASSERT(reporter, gray->canComputeFastBounds());
-
-    SkAutoTUnref<SkImageFilter> grayBlur(SkBlurImageFilter::Create(SK_Scalar1, SK_Scalar1, gray.get()));
-    REPORTER_ASSERT(reporter, grayBlur->canComputeFastBounds());
-
-    SkScalar greenMatrix[20] = { 0, 0, 0, 0, 0,
-                                 0, 0, 0, 0, 1,
-                                 0, 0, 0, 0, 0,
-                                 0, 0, 0, 0, 1 };
-    auto greenCF(SkColorFilter::MakeMatrixFilterRowMajor255(greenMatrix));
-    SkAutoTUnref<SkImageFilter> green(SkColorFilterImageFilter::Create(greenCF.get()));
+        sk_sp<SkImageFilter> gray(make_grayscale(nullptr, nullptr));
+        REPORTER_ASSERT(reporter, gray->canComputeFastBounds());
+        {
+            SkColorFilter* grayCF;
+            REPORTER_ASSERT(reporter, gray->asAColorFilter(&grayCF));
+            REPORTER_ASSERT(reporter, !grayCF->affectsTransparentBlack());
+            grayCF->unref();
+        }
+        REPORTER_ASSERT(reporter, gray->canComputeFastBounds());
 
-    REPORTER_ASSERT(reporter, greenCF->affectsTransparentBlack());
-    REPORTER_ASSERT(reporter, !green->canComputeFastBounds());
+        sk_sp<SkImageFilter> grayBlur(SkBlurImageFilter::Make(SK_Scalar1, SK_Scalar1,
+                                                              std::move(gray)));
+        REPORTER_ASSERT(reporter, grayBlur->canComputeFastBounds());
+    }
 
-    SkAutoTUnref<SkImageFilter> greenBlur(SkBlurImageFilter::Create(SK_Scalar1, SK_Scalar1, green.get()));
-    REPORTER_ASSERT(reporter, !greenBlur->canComputeFastBounds());
+    {
+        SkScalar greenMatrix[20] = { 0, 0, 0, 0, 0,
+                                     0, 0, 0, 0, 1,
+                                     0, 0, 0, 0, 0,
+                                     0, 0, 0, 0, 1 };
+        sk_sp<SkColorFilter> greenCF(SkColorFilter::MakeMatrixFilterRowMajor255(greenMatrix));
+        sk_sp<SkImageFilter> green(SkColorFilterImageFilter::Create(greenCF.get()));
+
+        REPORTER_ASSERT(reporter, greenCF->affectsTransparentBlack());
+        REPORTER_ASSERT(reporter, !green->canComputeFastBounds());
+
+        sk_sp<SkImageFilter> greenBlur(SkBlurImageFilter::Make(SK_Scalar1, SK_Scalar1,
+                                                               std::move(green)));
+        REPORTER_ASSERT(reporter, !greenBlur->canComputeFastBounds());
+    }
 
     uint8_t allOne[256], identity[256];
     for (int i = 0; i < 256; ++i) {
@@ -1545,7 +1576,7 @@ static void test_large_blur_input(skiatest::Reporter* reporter, SkCanvas* canvas
         return;
     }
 
-    sk_sp<SkImageFilter> blur(SkBlurImageFilter::Create(10.f, 10.f, largeSource.get()));
+    sk_sp<SkImageFilter> blur(SkBlurImageFilter::Make(10.f, 10.f, std::move(largeSource)));
     if (!blur) {
         ERRORF(reporter, "Failed to create SkBlurImageFilter.");
         return;
diff --git a/tests/RecordOptsTest.cpp b/tests/RecordOptsTest.cpp
index 242712da3b..4341b870bf 100644
--- a/tests/RecordOptsTest.cpp
+++ b/tests/RecordOptsTest.cpp
@@ -188,8 +188,8 @@ DEF_TEST(RecordOpts_NoopSaveLayerDrawRestore, r) {
     REPORTER_ASSERT(r, drawRect->paint.getColor() == 0x03020202);
 
     // saveLayer w/ backdrop should NOT go away
-    SkAutoTUnref<SkImageFilter> filter(SkBlurImageFilter::Create(3, 3));
-    recorder.saveLayer({ nullptr, nullptr, filter, 0});
+    sk_sp<SkImageFilter> filter(SkBlurImageFilter::Make(3, 3, nullptr));
+    recorder.saveLayer({ nullptr, nullptr, filter.get(), 0});
         recorder.drawRect(draw, opaqueDrawPaint);
     recorder.restore();
     assert_savelayer_draw_restore(r, &record, 18, false);
@@ -244,7 +244,7 @@ DEF_TEST(RecordOpts_MergeSvgOpacityAndFilterLayers, r) {
     int index = 0;
 
     {
-        SkAutoTUnref<SkImageFilter> filter(SkBlurImageFilter::Create(3, 3));
+        sk_sp<SkImageFilter> filter(SkBlurImageFilter::Make(3, 3, nullptr));
         // first (null) should be optimized, 2nd should not
         SkImageFilter* filters[] = { nullptr, filter.get() };