guard rasterizer and drawlooper setters

Need to land https://codereview.chromium.org/1823513002/ first

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

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

36 files changed, 151 insertions, 146 deletions

diff --git a/bench/BlurRoundRectBench.cpp b/bench/BlurRoundRectBench.cpp
index 5213276a0c..85852d581e 100644
--- a/bench/BlurRoundRectBench.cpp
+++ b/bench/BlurRoundRectBench.cpp
@@ -67,7 +67,7 @@ public:
         dullPaint.setAntiAlias(true);
 
         SkPaint loopedPaint;
-        loopedPaint.setLooper(looperBuilder.detachLooper())->unref();
+        loopedPaint.setLooper(looperBuilder.detach());
         loopedPaint.setAntiAlias(true);
         loopedPaint.setColor(SK_ColorCYAN);
 
diff --git a/bench/RectoriBench.cpp b/bench/RectoriBench.cpp
index 1f4da868b0..e2a44e383f 100644
--- a/bench/RectoriBench.cpp
+++ b/bench/RectoriBench.cpp
@@ -52,7 +52,7 @@ protected:
             SkScalar translate = 2.0f * size;
 
             SkPaint paint;
-            paint.setLooper(this->createLooper(-translate, blurSigma))->unref();
+            paint.setLooper(this->createLooper(-translate, blurSigma));
             paint.setColor(0xff000000 | Random.nextU());
             paint.setAntiAlias(true);
 
@@ -71,7 +71,7 @@ private:
         H = 480,
     };
 
-    SkLayerDrawLooper* createLooper(SkScalar xOff, SkScalar sigma) {
+    sk_sp<SkDrawLooper> createLooper(SkScalar xOff, SkScalar sigma) {
         SkLayerDrawLooper::Builder looperBuilder;
 
         //-----------------------------------------------
@@ -96,7 +96,7 @@ private:
         info.fOffset.set(0, 0);
 
         paint = looperBuilder.addLayer(info);
-        return looperBuilder.detachLooper();
+        return looperBuilder.detach();
     }
 
     typedef Benchmark INHERITED;
diff --git a/gm/blurroundrect.cpp b/gm/blurroundrect.cpp
index ef20e25860..fe4a939946 100644
--- a/gm/blurroundrect.cpp
+++ b/gm/blurroundrect.cpp
@@ -73,7 +73,7 @@ public:
         SkPaint paint;
         canvas->drawRect(fRRect.rect(), paint);
 
-        paint.setLooper(looperBuilder.detachLooper())->unref();
+        paint.setLooper(looperBuilder.detach());
         paint.setColor(SK_ColorCYAN);
         paint.setAntiAlias(true);
 
diff --git a/gm/circles.cpp b/gm/circles.cpp
index 4d3e33daee..d9b25c0df3 100644
--- a/gm/circles.cpp
+++ b/gm/circles.cpp
@@ -76,15 +76,12 @@ protected:
         // AA with blur
         SkPaint p;
         p.setAntiAlias(true);
-        SkDrawLooper* shadowLooper =
-            SkBlurDrawLooper::Create(SK_ColorBLUE,
+        p.setLooper(SkBlurDrawLooper::Make(SK_ColorBLUE,
                                      SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(10)),
                                      SkIntToScalar(5), SkIntToScalar(10),
                                      SkBlurDrawLooper::kIgnoreTransform_BlurFlag |
                                      SkBlurDrawLooper::kOverrideColor_BlurFlag |
-                                     SkBlurDrawLooper::kHighQuality_BlurFlag);
-        SkAutoUnref aurL0(shadowLooper);
-        p.setLooper(shadowLooper);
+                                     SkBlurDrawLooper::kHighQuality_BlurFlag));
         fPaints.push_back(p);
         }
 
diff --git a/gm/drawlooper.cpp b/gm/drawlooper.cpp
index 9f922a5ae4..7ee7747208 100644
--- a/gm/drawlooper.cpp
+++ b/gm/drawlooper.cpp
@@ -22,10 +22,6 @@ public:
         this->setBGColor(sk_tool_utils::color_to_565(0xFFDDDDDD));
     }
 
-    virtual ~DrawLooperGM() {
-        SkSafeUnref(fLooper);
-    }
-
 protected:
     virtual SkISize onISize() override {
         return SkISize::Make(520, 160);
@@ -55,7 +51,7 @@ protected:
     }
 
 private:
-    SkLayerDrawLooper*   fLooper;
+    sk_sp<SkDrawLooper> fLooper;
 
     void init() {
         if (fLooper) return;
@@ -91,7 +87,7 @@ private:
                 paint->setMaskFilter(mf)->unref();
             }
         }
-        fLooper = looperBuilder.detachLooper();
+        fLooper = looperBuilder.detach();
     }
 
     typedef GM INHERITED;
diff --git a/gm/megalooper.cpp b/gm/megalooper.cpp
index ae92971982..5fe9af298b 100644
--- a/gm/megalooper.cpp
+++ b/gm/megalooper.cpp
@@ -131,7 +131,7 @@ private:
         for (int i = 0; i < 4; ++i) {
             SkPaint loopPaint;
 
-            loopPaint.setLooper(create1Looper(-kOffsetToOutsideClip, 0, gColors[i]))->unref();
+            loopPaint.setLooper(create1Looper(-kOffsetToOutsideClip, 0, gColors[i]));
             loopPaint.setAntiAlias(true);
 
             SkRect outerClip = {
@@ -161,7 +161,7 @@ private:
     }
 
     // Create a 1-tier drawlooper
-    SkLayerDrawLooper* create1Looper(SkScalar xOff, SkScalar yOff, SkColor color) {
+    sk_sp<SkDrawLooper> create1Looper(SkScalar xOff, SkScalar yOff, SkColor color) {
         SkLayerDrawLooper::Builder looperBuilder;
         SkLayerDrawLooper::LayerInfo info;
 
@@ -178,7 +178,7 @@ private:
         SkColorFilter* cf = SkColorFilter::CreateModeFilter(color, SkXfermode::kSrcIn_Mode);
         paint->setColorFilter(cf)->unref();
 
-        return looperBuilder.detachLooper();
+        return looperBuilder.detach();
     }
 
     void draw1x4(SkCanvas* canvas, SkScalar x, SkScalar y) {
@@ -193,7 +193,7 @@ private:
 
         SkPaint paint;
         paint.setAntiAlias(true);
-        paint.setLooper(create4Looper(-kOffsetToOutsideClip-kHalfSquareSize, 0))->unref();
+        paint.setLooper(create4Looper(-kOffsetToOutsideClip-kHalfSquareSize, 0));
 
         canvas->save();
             canvas->clipRect(outerClip, SkRegion::kIntersect_Op);
@@ -205,7 +205,7 @@ private:
     }
 
     // Create a 4-tier draw looper
-    SkLayerDrawLooper* create4Looper(SkScalar xOff, SkScalar yOff) {
+    sk_sp<SkDrawLooper> create4Looper(SkScalar xOff, SkScalar yOff) {
         SkLayerDrawLooper::Builder looperBuilder;
         SkLayerDrawLooper::LayerInfo info;
 
@@ -226,7 +226,7 @@ private:
             paint->setColorFilter(cf)->unref();
         }
 
-        return looperBuilder.detachLooper();
+        return looperBuilder.detach();
     }
 
     typedef GM INHERITED;
diff --git a/gm/rects.cpp b/gm/rects.cpp
index 6f4c75e22f..51eeff0bfb 100644
--- a/gm/rects.cpp
+++ b/gm/rects.cpp
@@ -91,15 +91,12 @@ protected:
             SkPaint p;
             p.setColor(SK_ColorWHITE);
             p.setAntiAlias(true);
-            SkDrawLooper* shadowLooper =
-                SkBlurDrawLooper::Create(SK_ColorWHITE,
+            p.setLooper(SkBlurDrawLooper::Make(SK_ColorWHITE,
                                          SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(10)),
                                          SkIntToScalar(5), SkIntToScalar(10),
                                          SkBlurDrawLooper::kIgnoreTransform_BlurFlag |
                                          SkBlurDrawLooper::kOverrideColor_BlurFlag |
-                                         SkBlurDrawLooper::kHighQuality_BlurFlag);
-            SkAutoUnref aurL0(shadowLooper);
-            p.setLooper(shadowLooper);
+                                         SkBlurDrawLooper::kHighQuality_BlurFlag));
             fPaints.push_back(p);
         }
 
diff --git a/gm/shadows.cpp b/gm/shadows.cpp
index 5696240d21..6263af29bf 100644
--- a/gm/shadows.cpp
+++ b/gm/shadows.cpp
@@ -54,45 +54,36 @@ protected:
     }
 
     void onDraw(SkCanvas* canvas) override {
-        SkDrawLooper* shadowLoopers[5];
-        shadowLoopers[0] =
-            SkBlurDrawLooper::Create(SK_ColorBLUE,
+        sk_sp<SkDrawLooper> shadowLoopers[] = {
+              SkBlurDrawLooper::Make(SK_ColorBLUE,
                                      SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(10)),
                                      SkIntToScalar(5), SkIntToScalar(10),
                                      SkBlurDrawLooper::kIgnoreTransform_BlurFlag |
                                      SkBlurDrawLooper::kOverrideColor_BlurFlag |
-                                     SkBlurDrawLooper::kHighQuality_BlurFlag);
-        SkAutoUnref aurL0(shadowLoopers[0]);
-        shadowLoopers[1] =
-            SkBlurDrawLooper::Create(SK_ColorBLUE,
+                                     SkBlurDrawLooper::kHighQuality_BlurFlag),
+              SkBlurDrawLooper::Make(SK_ColorBLUE,
                                      SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(10)),
                                      SkIntToScalar(5), SkIntToScalar(10),
                                      SkBlurDrawLooper::kIgnoreTransform_BlurFlag |
-                                     SkBlurDrawLooper::kOverrideColor_BlurFlag);
-        SkAutoUnref aurL1(shadowLoopers[1]);
-        shadowLoopers[2] =
-            SkBlurDrawLooper::Create(SK_ColorBLACK,
+                                     SkBlurDrawLooper::kOverrideColor_BlurFlag),
+              SkBlurDrawLooper::Make(SK_ColorBLACK,
                                      SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(5)),
                                      SkIntToScalar(5),
                                      SkIntToScalar(10),
                                      SkBlurDrawLooper::kIgnoreTransform_BlurFlag |
-                                     SkBlurDrawLooper::kHighQuality_BlurFlag);
-        SkAutoUnref aurL2(shadowLoopers[2]);
-        shadowLoopers[3] =
-            SkBlurDrawLooper::Create(0x7FFF0000,
+                                     SkBlurDrawLooper::kHighQuality_BlurFlag),
+              SkBlurDrawLooper::Make(0x7FFF0000,
                                      SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(5)),
                                      SkIntToScalar(-5), SkIntToScalar(-10),
                                      SkBlurDrawLooper::kIgnoreTransform_BlurFlag |
                                      SkBlurDrawLooper::kOverrideColor_BlurFlag |
-                                     SkBlurDrawLooper::kHighQuality_BlurFlag);
-        SkAutoUnref aurL3(shadowLoopers[3]);
-        shadowLoopers[4] =
-            SkBlurDrawLooper::Create(SK_ColorBLACK, SkIntToScalar(0),
+                                     SkBlurDrawLooper::kHighQuality_BlurFlag),
+            SkBlurDrawLooper::Make(SK_ColorBLACK, SkIntToScalar(0),
                                      SkIntToScalar(5), SkIntToScalar(5),
                                      SkBlurDrawLooper::kIgnoreTransform_BlurFlag |
                                      SkBlurDrawLooper::kOverrideColor_BlurFlag |
-                                     SkBlurDrawLooper::kHighQuality_BlurFlag);
-        SkAutoUnref aurL4(shadowLoopers[4]);
+                                     SkBlurDrawLooper::kHighQuality_BlurFlag),
+        };
 
         static const struct {
             SkColor fColor;
diff --git a/gm/textbloblooper.cpp b/gm/textbloblooper.cpp
index d54490272c..d9701131a4 100644
--- a/gm/textbloblooper.cpp
+++ b/gm/textbloblooper.cpp
@@ -107,10 +107,10 @@ static void kitchen_sink(SkPaint* paint) {
 
 }
 
-static SkLayerDrawLooper* setupLooper(SkLayerDrawLooper::BitFlags bits,
-                                      LooperProc proc,
-                                      const LooperSettings settings[],
-                                      size_t size) {
+static sk_sp<SkDrawLooper> setupLooper(SkLayerDrawLooper::BitFlags bits,
+                                       LooperProc proc,
+                                       const LooperSettings settings[],
+                                       size_t size) {
     SkLayerDrawLooper::Builder looperBuilder;
 
     SkLayerDrawLooper::LayerInfo info;
@@ -129,7 +129,7 @@ static SkLayerDrawLooper* setupLooper(SkLayerDrawLooper::BitFlags bits,
             (*proc)(paint);
         }
     }
-    return looperBuilder.detachLooper();
+    return looperBuilder.detach();
 }
 
 class TextBlobLooperGM : public GM {
@@ -186,33 +186,33 @@ protected:
             { SkXfermode::kSrcOver_Mode, 0x50FF00FF, SkPaint::kFill_Style, 0, 20.f, 0, false },
         };
 
-        fLoopers.push_back().reset(setupLooper(SkLayerDrawLooper::kMaskFilter_Bit |
-                                               SkLayerDrawLooper::kXfermode_Bit |
-                                               SkLayerDrawLooper::kStyle_Bit, &mask_filter,
-                                               compound, SK_ARRAY_COUNT(compound)));
-        fLoopers.push_back().reset(setupLooper(SkLayerDrawLooper::kPathEffect_Bit |
-                                               SkLayerDrawLooper::kXfermode_Bit, &path_effect,
-                                               looperSandwhich, SK_ARRAY_COUNT(looperSandwhich)));
-        fLoopers.push_back().reset(setupLooper(SkLayerDrawLooper::kShader_Bit |
-                                               SkLayerDrawLooper::kColorFilter_Bit |
-                                               SkLayerDrawLooper::kXfermode_Bit, &color_filter,
-                                               looperSandwhich, SK_ARRAY_COUNT(looperSandwhich)));
-        fLoopers.push_back().reset(setupLooper(SkLayerDrawLooper::kShader_Bit |
-                                               SkLayerDrawLooper::kColorFilter_Bit |
-                                               SkLayerDrawLooper::kXfermode_Bit, &color_filter,
-                                               xfermode, SK_ARRAY_COUNT(xfermode)));
-        fLoopers.push_back().reset(setupLooper(0, nullptr, skew, SK_ARRAY_COUNT(skew)));
-        fLoopers.push_back().reset(setupLooper(SkLayerDrawLooper::kMaskFilter_Bit |
-                                               SkLayerDrawLooper::kShader_Bit |
-                                               SkLayerDrawLooper::kColorFilter_Bit |
-                                               SkLayerDrawLooper::kPathEffect_Bit |
-                                               SkLayerDrawLooper::kStyle_Bit |
-                                               SkLayerDrawLooper::kXfermode_Bit, &kitchen_sink,
-                                               kitchenSink, SK_ARRAY_COUNT(kitchenSink)));
+        fLoopers.push_back(setupLooper(SkLayerDrawLooper::kMaskFilter_Bit |
+                                       SkLayerDrawLooper::kXfermode_Bit |
+                                       SkLayerDrawLooper::kStyle_Bit, &mask_filter,
+                                       compound, SK_ARRAY_COUNT(compound)));
+        fLoopers.push_back(setupLooper(SkLayerDrawLooper::kPathEffect_Bit |
+                                       SkLayerDrawLooper::kXfermode_Bit, &path_effect,
+                                       looperSandwhich, SK_ARRAY_COUNT(looperSandwhich)));
+        fLoopers.push_back(setupLooper(SkLayerDrawLooper::kShader_Bit |
+                                       SkLayerDrawLooper::kColorFilter_Bit |
+                                       SkLayerDrawLooper::kXfermode_Bit, &color_filter,
+                                       looperSandwhich, SK_ARRAY_COUNT(looperSandwhich)));
+        fLoopers.push_back(setupLooper(SkLayerDrawLooper::kShader_Bit |
+                                       SkLayerDrawLooper::kColorFilter_Bit |
+                                       SkLayerDrawLooper::kXfermode_Bit, &color_filter,
+                                       xfermode, SK_ARRAY_COUNT(xfermode)));
+        fLoopers.push_back(setupLooper(0, nullptr, skew, SK_ARRAY_COUNT(skew)));
+        fLoopers.push_back(setupLooper(SkLayerDrawLooper::kMaskFilter_Bit |
+                                       SkLayerDrawLooper::kShader_Bit |
+                                       SkLayerDrawLooper::kColorFilter_Bit |
+                                       SkLayerDrawLooper::kPathEffect_Bit |
+                                       SkLayerDrawLooper::kStyle_Bit |
+                                       SkLayerDrawLooper::kXfermode_Bit, &kitchen_sink,
+                                       kitchenSink, SK_ARRAY_COUNT(kitchenSink)));
 
         // Test we respect overrides
-        fLoopers.push_back().reset(setupLooper(0, &kitchen_sink,
-                                               kitchenSink, SK_ARRAY_COUNT(kitchenSink)));
+        fLoopers.push_back(setupLooper(0, &kitchen_sink,
+                                       kitchenSink, SK_ARRAY_COUNT(kitchenSink)));
     }
 
     SkString onShortName() override {
@@ -247,7 +247,7 @@ protected:
 
 private:
     SkAutoTUnref<const SkTextBlob> fBlob;
-    SkTArray<SkAutoTUnref<SkLayerDrawLooper>, true> fLoopers;
+    SkTArray<sk_sp<SkDrawLooper>, true> fLoopers;
 
     typedef GM INHERITED;
 };
diff --git a/gm/texteffects.cpp b/gm/texteffects.cpp
index aa3d3758ab..5962cd7f16 100644
--- a/gm/texteffects.cpp
+++ b/gm/texteffects.cpp
@@ -88,7 +88,7 @@ static void r6(SkLayerRasterizer::Builder* rastBuilder, SkPaint& p) {
     p.setAntiAlias(false);
     SkLayerRasterizer::Builder rastBuilder2;
     r5(&rastBuilder2, p);
-    p.setRasterizer(rastBuilder2.detachRasterizer())->unref();
+    p.setRasterizer(rastBuilder2.detach());
     p.setXfermodeMode(SkXfermode::kClear_Mode);
     rastBuilder->addLayer(p);
 }
@@ -153,14 +153,13 @@ static const raster_proc gRastProcs[] = {
 
 static void apply_shader(SkPaint* paint, int index) {
     raster_proc proc = gRastProcs[index];
-    if (proc)
-    {
+    if (proc) {
         SkPaint p;
         SkLayerRasterizer::Builder rastBuilder;
 
         p.setAntiAlias(true);
         proc(&rastBuilder, p);
-        paint->setRasterizer(rastBuilder.detachRasterizer())->unref();
+        paint->setRasterizer(rastBuilder.detach());
     }
 
 #if 0
diff --git a/gyp/skia_for_android_framework_defines.gypi b/gyp/skia_for_android_framework_defines.gypi
index d6324bd40a..8660475463 100644
--- a/gyp/skia_for_android_framework_defines.gypi
+++ b/gyp/skia_for_android_framework_defines.gypi
@@ -17,6 +17,7 @@
       # Needed until we fix https://bug.skia.org/2440 .
       'SK_SUPPORT_LEGACY_CLIPTOLAYERFLAG',
       'SK_IGNORE_LINEONLY_AA_CONVEX_PATH_OPTS',
+      'SK_SUPPORT_LEGACY_MINOR_EFFECT_PTR',
       'SK_SUPPORT_LEGACY_GRADIENT_DITHERING',
       'SK_SUPPORT_LEGACY_DRAWFILTER',
       'SK_SUPPORT_LEGACY_CREATESHADER_PTR',
diff --git a/include/core/SkPaint.h b/include/core/SkPaint.h
index 8266eaaddc..f5c3bc3d4b 100644
--- a/include/core/SkPaint.h
+++ b/include/core/SkPaint.h
@@ -627,7 +627,9 @@ public:
                           the paint.
         @return           rasterizer
     */
+#ifdef SK_SUPPORT_LEGACY_MINOR_EFFECT_PTR
     SkRasterizer* setRasterizer(SkRasterizer* rasterizer);
+#endif
     void setRasterizer(sk_sp<SkRasterizer>);
 
     SkImageFilter* getImageFilter() const { return fImageFilter.get(); }
@@ -651,7 +653,9 @@ public:
      *  @param looper May be NULL. The new looper to be installed in the paint.
      *  @return looper
      */
+#ifdef SK_SUPPORT_LEGACY_MINOR_EFFECT_PTR
     SkDrawLooper* setLooper(SkDrawLooper* looper);
+#endif
     void setLooper(sk_sp<SkDrawLooper>);
 
     enum Align {
diff --git a/include/effects/SkBlurDrawLooper.h b/include/effects/SkBlurDrawLooper.h
index 930af15ff8..0371700ba4 100644
--- a/include/effects/SkBlurDrawLooper.h
+++ b/include/effects/SkBlurDrawLooper.h
@@ -35,10 +35,16 @@ public:
         kAll_BlurFlag               = 0x07
     };
 
+    static sk_sp<SkDrawLooper> Make(SkColor color, SkScalar sigma, SkScalar dx, SkScalar dy,
+                                    uint32_t flags = kNone_BlurFlag) {
+        return sk_sp<SkDrawLooper>(new SkBlurDrawLooper(color, sigma, dx, dy, flags));
+    }
+#ifdef SK_SUPPORT_LEGACY_MINOR_EFFECT_PTR
     static SkDrawLooper* Create(SkColor color, SkScalar sigma, SkScalar dx, SkScalar dy,
                                 uint32_t flags = kNone_BlurFlag) {
-        return new SkBlurDrawLooper(color, sigma, dx, dy, flags);
+        return Make(color, sigma, dx, dy, flags).release();
     }
+#endif
 
     virtual ~SkBlurDrawLooper();
 
diff --git a/include/effects/SkLayerDrawLooper.h b/include/effects/SkLayerDrawLooper.h
index 76172dfd4b..6ddde888eb 100644
--- a/include/effects/SkLayerDrawLooper.h
+++ b/include/effects/SkLayerDrawLooper.h
@@ -142,7 +142,12 @@ public:
           * Pass list of layers on to newly built looper and return it. This will
           * also reset the builder, so it can be used to build another looper.
           */
-        SkLayerDrawLooper* detachLooper();
+        sk_sp<SkDrawLooper> detach();
+#ifdef SK_SUPPORT_LEGACY_MINOR_EFFECT_PTR
+        SkLayerDrawLooper* detachLooper() {
+            return (SkLayerDrawLooper*)this->detach().release();
+        }
+#endif
 
     private:
         Rec* fRecs;
diff --git a/include/effects/SkLayerRasterizer.h b/include/effects/SkLayerRasterizer.h
index c6ac1de363..9ddcd4e6c3 100644
--- a/include/effects/SkLayerRasterizer.h
+++ b/include/effects/SkLayerRasterizer.h
@@ -1,4 +1,3 @@
-
 /*
  * Copyright 2006 The Android Open Source Project
  *
@@ -6,7 +5,6 @@
  * found in the LICENSE file.
  */
 
-
 #ifndef SkLayerRasterizer_DEFINED
 #define SkLayerRasterizer_DEFINED
 
@@ -44,7 +42,7 @@ public:
           *
           *  The caller is responsible for calling unref() on the returned object, if non NULL.
           */
-        SkLayerRasterizer* detachRasterizer();
+        sk_sp<SkLayerRasterizer> detach();
 
         /**
           *  Create and return a new immutable SkLayerRasterizer that contains a shapshot of the
@@ -58,7 +56,16 @@ public:
           *
           *  The caller is responsible for calling unref() on the returned object, if non NULL.
           */
-        SkLayerRasterizer* snapshotRasterizer() const;
+        sk_sp<SkLayerRasterizer> snapshot() const;
+    
+#ifdef SK_SUPPORT_LEGACY_MINOR_EFFECT_PTR
+        SkLayerRasterizer* detachRasterizer() {
+            return this->detach().release();
+        }
+        SkLayerRasterizer* snapshotRasterizer() const {
+            return this->snapshot().release();
+        }
+#endif
 
     private:
         SkDeque* fLayers;
diff --git a/public.bzl b/public.bzl
index 5729be868f..11a7ca3ab3 100644
--- a/public.bzl
+++ b/public.bzl
@@ -523,6 +523,7 @@ DEFINES_ALL = [
     # Chrome DEFINES.
     "SK_USE_FLOATBITS",
     "SK_USE_FREETYPE_EMBOLDEN",
+    "SK_SUPPORT_LEGACY_MINOR_EFFECT_PTR",
     "SK_SUPPORT_LEGACY_PATHEFFECT_PTR",
     # Turn on a few Google3-specific build fixes.
     "GOOGLE3",
diff --git a/samplecode/ClockFaceView.cpp b/samplecode/ClockFaceView.cpp
index f5b43fb82f..80debebcf9 100644
--- a/samplecode/ClockFaceView.cpp
+++ b/samplecode/ClockFaceView.cpp
@@ -163,7 +163,7 @@ static void apply_shader(SkPaint* paint, float scale)
 
     p.setAntiAlias(true);
     r7(&rastBuilder, p, scale);
-    paint->setRasterizer(rastBuilder.detachRasterizer())->unref();
+    paint->setRasterizer(rastBuilder.detach());
 
     paint->setColor(SK_ColorBLUE);
 }
diff --git a/samplecode/SampleAll.cpp b/samplecode/SampleAll.cpp
index 2bbe29f383..b8b0ee677d 100644
--- a/samplecode/SampleAll.cpp
+++ b/samplecode/SampleAll.cpp
@@ -152,7 +152,7 @@ static void r6(SkLayerRasterizer::Builder* rastBuilder, SkPaint& p) {
     p.setAntiAlias(false);
     SkLayerRasterizer::Builder rastBuilder2;
     r5(&rastBuilder2, p);
-    p.setRasterizer(rastBuilder2.detachRasterizer())->unref();
+    p.setRasterizer(rastBuilder2.detach());
     p.setXfermodeMode(SkXfermode::kClear_Mode);
     rastBuilder->addLayer(p);
 }
@@ -246,7 +246,7 @@ static void apply_shader(SkPaint* paint, int index) {
 
         p.setAntiAlias(true);
         proc(&rastBuilder, p);
-        paint->setRasterizer(rastBuilder.detachRasterizer())->unref();
+        paint->setRasterizer(rastBuilder.detach());
     }
 
 #if 1
diff --git a/samplecode/SampleFilterFuzz.cpp b/samplecode/SampleFilterFuzz.cpp
index fe2fb0b2ff..dd0fa4044e 100644
--- a/samplecode/SampleFilterFuzz.cpp
+++ b/samplecode/SampleFilterFuzz.cpp
@@ -536,8 +536,7 @@ static SkPaint make_paint() {
         paintForRasterizer = make_paint();
     }
     rasterizerBuilder.addLayer(paintForRasterizer);
-    SkAutoTUnref<SkRasterizer> rasterizer(rasterizerBuilder.detachRasterizer());
-    paint.setRasterizer(rasterizer);
+    paint.setRasterizer(rasterizerBuilder.detach());
     paint.setImageFilter(make_image_filter());
     SkAutoDataUnref data(make_3Dlut(nullptr, make_bool(), make_bool(), make_bool()));
     paint.setTextAlign(make_paint_align());
diff --git a/samplecode/SamplePathEffects.cpp b/samplecode/SamplePathEffects.cpp
index 10715f382a..1f9915d378 100644
--- a/samplecode/SamplePathEffects.cpp
+++ b/samplecode/SamplePathEffects.cpp
@@ -152,7 +152,7 @@ protected:
         paint.setARGB(0xFF, 0, 0, 0);
         paint.setPathEffect(make_warp_pe(fPhase));
         TestRastBuilder testRastBuilder;
-        paint.setRasterizer(testRastBuilder.detachRasterizer())->unref();
+        paint.setRasterizer(testRastBuilder.detach());
         canvas->drawPath(fPath, paint);
     }
 
diff --git a/samplecode/SampleSlides.cpp b/samplecode/SampleSlides.cpp
index ca0d9df13f..9b054adc2c 100644
--- a/samplecode/SampleSlides.cpp
+++ b/samplecode/SampleSlides.cpp
@@ -544,7 +544,7 @@ static void r6(SkLayerRasterizer::Builder* rastBuilder, SkPaint& p)
     p.setAntiAlias(false);
     SkLayerRasterizer::Builder rastBuilder2;
     r5(&rastBuilder2, p);
-    p.setRasterizer(rastBuilder2.detachRasterizer())->unref();
+    p.setRasterizer(rastBuilder2.detach());
     p.setXfermodeMode(SkXfermode::kClear_Mode);
     rastBuilder->addLayer(p);
 }
@@ -615,7 +615,7 @@ static void apply_shader(SkPaint* paint, int index) {
 
     p.setAntiAlias(true);
     proc(&rastBuilder, p);
-    paint->setRasterizer(rastBuilder.detachRasterizer())->unref();
+    paint->setRasterizer(rastBuilder.detach());
     paint->setColor(SK_ColorBLUE);
 }
 
diff --git a/samplecode/SampleTextOnPath.cpp b/samplecode/SampleTextOnPath.cpp
index ea2ae81dc0..7c71084dbb 100644
--- a/samplecode/SampleTextOnPath.cpp
+++ b/samplecode/SampleTextOnPath.cpp
@@ -35,10 +35,8 @@ static void textStrokePath(SkCanvas* canvas) {
 
     canvas->drawPath(path, paint);
 
-    paint.setLooper(SkBlurDrawLooper::Create(SK_ColorBLACK,
-                                             SkBlurMask::ConvertRadiusToSigma(0.002f),
-                                             0.0f,
-                                             0.0f))->unref();
+    paint.setLooper(SkBlurDrawLooper::Make(SK_ColorBLACK, SkBlurMask::ConvertRadiusToSigma(0.002f),
+                                           0.0f, 0.0f));
 
     const char* text = "DRAWING STROKED TEXT WITH A BLUR ON A PATH";
     size_t      len = strlen(text);
diff --git a/samplecode/SampleTiling.cpp b/samplecode/SampleTiling.cpp
index 62f055f61e..dbc7d09145 100644
--- a/samplecode/SampleTiling.cpp
+++ b/samplecode/SampleTiling.cpp
@@ -55,12 +55,12 @@ static const int gHeight = 32;
 
 class TilingView : public SampleView {
     sk_sp<SkPicture>     fTextPicture;
-    SkAutoTUnref<SkDrawLooper>  fLooper;
+    sk_sp<SkDrawLooper>  fLooper;
 public:
     TilingView()
-            : fLooper(SkBlurDrawLooper::Create(0x88000000,
-                                               SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(1)),
-                                               SkIntToScalar(2), SkIntToScalar(2))) {
+        : fLooper(SkBlurDrawLooper::Make(0x88000000,
+                                         SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(1)),
+                                         SkIntToScalar(2), SkIntToScalar(2))) {
         for (size_t i = 0; i < SK_ARRAY_COUNT(gColorTypes); i++) {
             makebm(&fTexture[i], gColorTypes[i], gWidth, gHeight);
         }
diff --git a/samplecode/SampleUnpremul.cpp b/samplecode/SampleUnpremul.cpp
index fb9735c017..919fb64e75 100644
--- a/samplecode/SampleUnpremul.cpp
+++ b/samplecode/SampleUnpremul.cpp
@@ -80,10 +80,9 @@ protected:
         SkPaint paint;
         paint.setAntiAlias(true);
         paint.setTextSize(SkIntToScalar(24));
-        SkAutoTUnref<SkDrawLooper> looper(
-            SkBlurDrawLooper::Create(SK_ColorBLUE,
-                                     SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(2)),
-                                     0, 0));
+        auto looper(
+            SkBlurDrawLooper::Make(SK_ColorBLUE, SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(2)),
+                                   0, 0));
         paint.setLooper(looper);
         SkScalar height = paint.getFontMetrics(nullptr);
         if (!fDecodeSucceeded) {
diff --git a/src/core/SkPaint.cpp b/src/core/SkPaint.cpp
index 331f7794bf..5baabd3f1d 100644
--- a/src/core/SkPaint.cpp
+++ b/src/core/SkPaint.cpp
@@ -370,7 +370,9 @@ void SkPaint::setLooper(sk_sp<SkDrawLooper> looper) { fLooper = std::move(looper
         return f;                                   \
     }
 SET_PTR(Typeface)
+#ifdef SK_SUPPORT_LEGACY_MINOR_EFFECT_PTR
 SET_PTR(Rasterizer)
+#endif
 SET_PTR(ImageFilter)
 SET_PTR(Shader)
 SET_PTR(ColorFilter)
@@ -381,10 +383,12 @@ SET_PTR(PathEffect)
 SET_PTR(MaskFilter)
 #undef SET_PTR
 
+#ifdef SK_SUPPORT_LEGACY_MINOR_EFFECT_PTR
 SkDrawLooper* SkPaint::setLooper(SkDrawLooper* looper) {
     fLooper.reset(SkSafeRef(looper));
     return looper;
 }
+#endif
 
 SkXfermode* SkPaint::setXfermodeMode(SkXfermode::Mode mode) {
     fXfermode.reset(SkXfermode::Create(mode));
@@ -1937,8 +1941,8 @@ void SkPaint::unflatten(SkReadBuffer& buffer) {
         SkSafeUnref(this->setXfermode(buffer.readXfermode()));
         SkSafeUnref(this->setMaskFilter(buffer.readMaskFilter()));
         SkSafeUnref(this->setColorFilter(buffer.readColorFilter()));
-        SkSafeUnref(this->setRasterizer(buffer.readRasterizer()));
-        SkSafeUnref(this->setLooper(buffer.readDrawLooper()));
+        this->setRasterizer(buffer.readRasterizer());
+        this->setLooper(buffer.readDrawLooper());
         SkSafeUnref(this->setImageFilter(buffer.readImageFilter()));
 
         if (buffer.isVersionLT(SkReadBuffer::kAnnotationsMovedToCanvas_Version)) {
diff --git a/src/core/SkReadBuffer.h b/src/core/SkReadBuffer.h
index c7ac8480ec..575375eded 100644
--- a/src/core/SkReadBuffer.h
+++ b/src/core/SkReadBuffer.h
@@ -131,13 +131,17 @@ public:
         return (T*) this->readFlattenable(T::GetFlattenableType());
     }
     SkColorFilter* readColorFilter() { return this->readFlattenable<SkColorFilter>(); }
-    SkDrawLooper*  readDrawLooper()  { return this->readFlattenable<SkDrawLooper>(); }
+    sk_sp<SkDrawLooper> readDrawLooper() {
+        return sk_sp<SkDrawLooper>(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>());
     }
-    SkRasterizer*  readRasterizer()  { return this->readFlattenable<SkRasterizer>(); }
+    sk_sp<SkRasterizer> readRasterizer() {
+        return sk_sp<SkRasterizer>(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/SkBlurDrawLooper.cpp b/src/effects/SkBlurDrawLooper.cpp
index 9f10ff5250..d8127eba4e 100644
--- a/src/effects/SkBlurDrawLooper.cpp
+++ b/src/effects/SkBlurDrawLooper.cpp
@@ -68,7 +68,7 @@ SkFlattenable* SkBlurDrawLooper::CreateProc(SkReadBuffer& buffer) {
     const SkScalar dx = buffer.readScalar();
     const SkScalar dy = buffer.readScalar();
     const uint32_t flags = buffer.read32();
-    return Create(color, sigma, dx, dy, flags);
+    return Make(color, sigma, dx, dy, flags).release();
 }
 
 void SkBlurDrawLooper::flatten(SkWriteBuffer& buffer) const {
diff --git a/src/effects/SkLayerDrawLooper.cpp b/src/effects/SkLayerDrawLooper.cpp
index 83f21e5b40..ae31482ae7 100644
--- a/src/effects/SkLayerDrawLooper.cpp
+++ b/src/effects/SkLayerDrawLooper.cpp
@@ -230,7 +230,7 @@ SkFlattenable* SkLayerDrawLooper::CreateProc(SkReadBuffer& buffer) {
         info.fPostTranslate = buffer.readBool();
         buffer.readPaint(builder.addLayerOnTop(info));
     }
-    return builder.detachLooper();
+    return builder.detach().release();
 }
 
 #ifndef SK_IGNORE_TO_STRING
@@ -344,7 +344,7 @@ SkPaint* SkLayerDrawLooper::Builder::addLayerOnTop(const LayerInfo& info) {
     return &rec->fPaint;
 }
 
-SkLayerDrawLooper* SkLayerDrawLooper::Builder::detachLooper() {
+sk_sp<SkDrawLooper> SkLayerDrawLooper::Builder::detach() {
     SkLayerDrawLooper* looper = new SkLayerDrawLooper;
     looper->fCount = fCount;
     looper->fRecs = fRecs;
@@ -353,5 +353,5 @@ SkLayerDrawLooper* SkLayerDrawLooper::Builder::detachLooper() {
     fRecs = nullptr;
     fTopRec = nullptr;
 
-    return looper;
+    return sk_sp<SkDrawLooper>(looper);
 }
diff --git a/src/effects/SkLayerRasterizer.cpp b/src/effects/SkLayerRasterizer.cpp
index 6c08afc6f5..351265c46e 100644
--- a/src/effects/SkLayerRasterizer.cpp
+++ b/src/effects/SkLayerRasterizer.cpp
@@ -196,7 +196,7 @@ void SkLayerRasterizer::Builder::addLayer(const SkPaint& paint, SkScalar dx,
     rec->fOffset.set(dx, dy);
 }
 
-SkLayerRasterizer* SkLayerRasterizer::Builder::detachRasterizer() {
+sk_sp<SkLayerRasterizer> SkLayerRasterizer::Builder::detach() {
     SkLayerRasterizer* rasterizer;
     if (0 == fLayers->count()) {
         rasterizer = nullptr;
@@ -205,10 +205,10 @@ SkLayerRasterizer* SkLayerRasterizer::Builder::detachRasterizer() {
         rasterizer = new SkLayerRasterizer(fLayers);
     }
     fLayers = nullptr;
-    return rasterizer;
+    return sk_sp<SkLayerRasterizer>(rasterizer);
 }
 
-SkLayerRasterizer* SkLayerRasterizer::Builder::snapshotRasterizer() const {
+sk_sp<SkLayerRasterizer> SkLayerRasterizer::Builder::snapshot() const {
     if (0 == fLayers->count()) {
         return nullptr;
     }
@@ -224,6 +224,5 @@ SkLayerRasterizer* SkLayerRasterizer::Builder::snapshotRasterizer() const {
     }
     SkASSERT(fLayers->count() == count);
     SkASSERT(layers->count() == count);
-    SkLayerRasterizer* rasterizer = new SkLayerRasterizer(layers);
-    return rasterizer;
+    return sk_sp<SkLayerRasterizer>(new SkLayerRasterizer(layers));
 }
diff --git a/tests/BlurTest.cpp b/tests/BlurTest.cpp
index 30f218aa92..39ef738288 100644
--- a/tests/BlurTest.cpp
+++ b/tests/BlurTest.cpp
@@ -418,12 +418,12 @@ static void test_blurDrawLooper(skiatest::Reporter* reporter, SkScalar sigma,
     const SkBlurQuality quality = blurMaskFilterFlags_as_quality(blurMaskFilterFlags);
     uint32_t flags = blurMaskFilterFlags_to_blurDrawLooperFlags(blurMaskFilterFlags);
 
-    SkAutoTUnref<SkDrawLooper> lp(SkBlurDrawLooper::Create(color, sigma, dx, dy, flags));
+    sk_sp<SkDrawLooper> lp(SkBlurDrawLooper::Make(color, sigma, dx, dy, flags));
 
     const bool expectSuccess = sigma > 0 &&
                                0 == (flags & SkBlurDrawLooper::kIgnoreTransform_BlurFlag);
 
-    if (nullptr == lp.get()) {
+    if (nullptr == lp) {
         REPORTER_ASSERT(reporter, sigma <= 0);
     } else {
         SkDrawLooper::BlurShadowRec rec;
@@ -440,8 +440,8 @@ static void test_blurDrawLooper(skiatest::Reporter* reporter, SkScalar sigma,
     }
 }
 
-static void test_delete_looper(skiatest::Reporter* reporter, SkDrawLooper* lp, SkScalar sigma,
-                               SkBlurStyle style, SkBlurQuality quality, bool expectSuccess) {
+static void test_looper(skiatest::Reporter* reporter, sk_sp<SkDrawLooper> lp, SkScalar sigma,
+                        SkBlurStyle style, SkBlurQuality quality, bool expectSuccess) {
     SkDrawLooper::BlurShadowRec rec;
     bool success = lp->asABlurShadow(&rec);
     REPORTER_ASSERT(reporter, success == expectSuccess);
@@ -453,7 +453,6 @@ static void test_delete_looper(skiatest::Reporter* reporter, SkDrawLooper* lp, S
         REPORTER_ASSERT(reporter, rec.fStyle == style);
         REPORTER_ASSERT(reporter, rec.fQuality == quality);
     }
-    lp->unref();
 }
 
 static void make_noop_layer(SkLayerDrawLooper::Builder* builder) {
@@ -481,23 +480,23 @@ static void test_layerDrawLooper(skiatest::Reporter* reporter, SkMaskFilter* mf,
 
     // 1 layer is too few
     make_noop_layer(&builder);
-    test_delete_looper(reporter, builder.detachLooper(), sigma, style, quality, false);
+    test_looper(reporter, builder.detach(), sigma, style, quality, false);
 
     // 2 layers is good, but need blur
     make_noop_layer(&builder);
     make_noop_layer(&builder);
-    test_delete_looper(reporter, builder.detachLooper(), sigma, style, quality, false);
+    test_looper(reporter, builder.detach(), sigma, style, quality, false);
 
     // 2 layers is just right
     make_noop_layer(&builder);
     make_blur_layer(&builder, mf);
-    test_delete_looper(reporter, builder.detachLooper(), sigma, style, quality, expectSuccess);
+    test_looper(reporter, builder.detach(), sigma, style, quality, expectSuccess);
 
     // 3 layers is too many
     make_noop_layer(&builder);
     make_blur_layer(&builder, mf);
     make_noop_layer(&builder);
-    test_delete_looper(reporter, builder.detachLooper(), sigma, style, quality, false);
+    test_looper(reporter, builder.detach(), sigma, style, quality, false);
 }
 
 DEF_TEST(BlurAsABlur, reporter) {
diff --git a/tests/LayerDrawLooperTest.cpp b/tests/LayerDrawLooperTest.cpp
index 391db7ce7f..8ba290fbdf 100644
--- a/tests/LayerDrawLooperTest.cpp
+++ b/tests/LayerDrawLooperTest.cpp
@@ -58,7 +58,7 @@ static void test_frontToBack(skiatest::Reporter* reporter) {
     FakeDevice device;
     SkCanvas canvas(&device);
     SkPaint paint;
-    SkAutoTUnref<SkLayerDrawLooper> looper(looperBuilder.detachLooper());
+    auto looper(looperBuilder.detach());
     SkSmallAllocator<1, 32> allocator;
     void* buffer = allocator.reserveT<SkDrawLooper::Context>(looper->contextSize());
     SkDrawLooper::Context* context = looper->createContext(&canvas, buffer);
@@ -98,7 +98,7 @@ static void test_backToFront(skiatest::Reporter* reporter) {
     FakeDevice device;
     SkCanvas canvas(&device);
     SkPaint paint;
-    SkAutoTUnref<SkLayerDrawLooper> looper(looperBuilder.detachLooper());
+    auto looper(looperBuilder.detach());
     SkSmallAllocator<1, 32> allocator;
     void* buffer = allocator.reserveT<SkDrawLooper::Context>(looper->contextSize());
     SkDrawLooper::Context* context = looper->createContext(&canvas, buffer);
@@ -138,7 +138,7 @@ static void test_mixed(skiatest::Reporter* reporter) {
     FakeDevice device;
     SkCanvas canvas(&device);
     SkPaint paint;
-    SkAutoTUnref<SkLayerDrawLooper> looper(looperBuilder.detachLooper());
+    sk_sp<SkDrawLooper> looper(looperBuilder.detach());
     SkSmallAllocator<1, 32> allocator;
     void* buffer = allocator.reserveT<SkDrawLooper::Context>(looper->contextSize());
     SkDrawLooper::Context* context = looper->createContext(&canvas, buffer);
diff --git a/tests/LayerRasterizerTest.cpp b/tests/LayerRasterizerTest.cpp
index a81cca4037..b71c305d59 100644
--- a/tests/LayerRasterizerTest.cpp
+++ b/tests/LayerRasterizerTest.cpp
@@ -49,7 +49,7 @@ SkFlattenable* DummyRasterizer::CreateProc(SkReadBuffer&) { return new DummyRast
 DEF_TEST(LayerRasterizer_destructor, reporter) {
     {
         SkPaint paint;
-        paint.setRasterizer(new DummyRasterizer)->unref();
+        paint.setRasterizer(sk_make_sp<DummyRasterizer>());
         REPORTER_ASSERT(reporter, DummyRasterizer::GetCount() == 1);
 
         SkLayerRasterizer::Builder builder;
@@ -81,7 +81,7 @@ static bool equals(const SkLayerRasterizer_Rec& rec1, const SkLayerRasterizer_Re
 
 DEF_TEST(LayerRasterizer_copy, reporter) {
     SkLayerRasterizer::Builder builder;
-    REPORTER_ASSERT(reporter, nullptr == builder.snapshotRasterizer());
+    REPORTER_ASSERT(reporter, nullptr == builder.snapshot());
     SkPaint paint;
     // Create a bunch of paints with different flags.
     for (uint32_t flags = 0x01; flags < SkPaint::kAllFlags; flags <<= 1) {
@@ -90,14 +90,14 @@ DEF_TEST(LayerRasterizer_copy, reporter) {
     }
 
     // Create a layer rasterizer with all the existing layers.
-    SkAutoTUnref<SkLayerRasterizer> firstCopy(builder.snapshotRasterizer());
+    sk_sp<SkLayerRasterizer> firstCopy(builder.snapshot());
 
     // Add one more layer.
     paint.setFlags(SkPaint::kAllFlags);
     builder.addLayer(paint);
 
-    SkAutoTUnref<SkLayerRasterizer> oneLarger(builder.snapshotRasterizer());
-    SkAutoTUnref<SkLayerRasterizer> detached(builder.detachRasterizer());
+    sk_sp<SkLayerRasterizer> oneLarger(builder.snapshot());
+    sk_sp<SkLayerRasterizer> detached(builder.detach());
 
     // Check the counts for consistency.
     const int largerCount = LayerRasterizerTester::CountLayers(*oneLarger.get());
@@ -140,5 +140,5 @@ DEF_TEST(LayerRasterizer_copy, reporter) {
 
 DEF_TEST(LayerRasterizer_detachEmpty, reporter) {
     SkLayerRasterizer::Builder builder;
-    REPORTER_ASSERT(reporter, nullptr == builder.detachRasterizer());
+    REPORTER_ASSERT(reporter, nullptr == builder.detach());
 }
diff --git a/tests/PaintTest.cpp b/tests/PaintTest.cpp
index 7affa9ee94..a58bd864ec 100644
--- a/tests/PaintTest.cpp
+++ b/tests/PaintTest.cpp
@@ -146,8 +146,7 @@ DEF_TEST(Paint_copy, reporter) {
     paint.setStrokeWidth(SkIntToScalar(2));
     // set a few pointers
     SkLayerDrawLooper::Builder looperBuilder;
-    SkLayerDrawLooper* looper = looperBuilder.detachLooper();
-    paint.setLooper(looper)->unref();
+    paint.setLooper(looperBuilder.detach());
     SkMaskFilter* mask = SkBlurMaskFilter::Create(kNormal_SkBlurStyle,
                                       SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(1)));
     paint.setMaskFilter(mask)->unref();
diff --git a/tests/QuickRejectTest.cpp b/tests/QuickRejectTest.cpp
index 7eb80f1712..582789aa75 100644
--- a/tests/QuickRejectTest.cpp
+++ b/tests/QuickRejectTest.cpp
@@ -82,7 +82,7 @@ static void test_drawBitmap(skiatest::Reporter* reporter) {
     // to the left. The test is to ensure that canvas' quickReject machinary
     // allows us through, even though sans-looper we would look like we should
     // be clipped out.
-    paint.setLooper(new TestLooper)->unref();
+    paint.setLooper(sk_make_sp<TestLooper>());
     canvas.drawBitmap(src, SkIntToScalar(-10), 0, &paint);
     REPORTER_ASSERT(reporter, 0xFFFFFFFF == *dst.getAddr32(5, 5));
 }
diff --git a/tools/android/SkAndroidSDKCanvas.cpp b/tools/android/SkAndroidSDKCanvas.cpp
index 1deb97cbc6..35b1581fda 100644
--- a/tools/android/SkAndroidSDKCanvas.cpp
+++ b/tools/android/SkAndroidSDKCanvas.cpp
@@ -8,6 +8,7 @@
 #include "SkAndroidSDKCanvas.h"
 
 #include "SkColorFilter.h"
+#include "SkDrawLooper.h"
 #include "SkPaint.h"
 #include "SkPathEffect.h"
 #include "SkShader.h"
diff --git a/tools/debugger/SkDrawCommand.cpp b/tools/debugger/SkDrawCommand.cpp
index 5941a5d0e3..5bacf02b1a 100644
--- a/tools/debugger/SkDrawCommand.cpp
+++ b/tools/debugger/SkDrawCommand.cpp
@@ -1184,10 +1184,9 @@ static void extract_json_paint_looper(Json::Value& jsonPaint, UrlDataManager& ur
                                       SkPaint* target) {
     if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_LOOPER)) {
         Json::Value jsonLooper = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_LOOPER];
-        SkDrawLooper* looper = (SkDrawLooper*) load_flattenable(jsonLooper, urlDataManager);
+        sk_sp<SkDrawLooper> looper((SkDrawLooper*) load_flattenable(jsonLooper, urlDataManager));
         if (looper != nullptr) {
-            target->setLooper(looper);
-            looper->unref();
+            target->setLooper(std::move(looper));
         }
     }
 }