Revert of Switch SkLocalMatrixImageFilter and SkPaintImageFilter over to sk_sp (patchset #6 id:100001 of https://codereview.chromium.org/1842793002/ )

Reason for revert:
This CL is causing the autoroll into Chromium & google3 to fail.

Original issue's description:
> Switch SkLocalMatrixImageFilter and SkPaintImageFilter over to sk_sp
>
> TBR=reed@google.com
>
> GOLD_TRYBOT_URL= https://gold.skia.org/search2?unt=true&query=source_type%3Dgm&master=false&issue=1842793002
>
> Committed: https://skia.googlesource.com/skia/+/a33cf07a2273315363c0b6fb5d3ce811742f5a85

TBR=fmalita@chromium.org,reed@google.com,robertphillips@google.com
# Skipping CQ checks because original CL landed less than 1 days ago.
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true

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

14 files changed, 142 insertions, 249 deletions

diff --git a/gm/imagefiltersclipped.cpp b/gm/imagefiltersclipped.cpp
index 5401ef537f..7c75bf3951 100644
--- a/gm/imagefiltersclipped.cpp
+++ b/gm/imagefiltersclipped.cpp
@@ -138,11 +138,11 @@ protected:
 
         SkPaint noisePaint;
         noisePaint.setShader(noise);
-        sk_sp<SkImageFilter> rectFilter(SkPaintImageFilter::Make(noisePaint));
+        SkAutoTUnref<SkImageFilter> rectFilter(SkPaintImageFilter::Create(noisePaint));
         canvas->translate(SK_ARRAY_COUNT(filters)*(r.width() + margin), 0);
         for (int xOffset = 0; xOffset < 80; xOffset += 16) {
             bounds.fLeft = SkIntToScalar(xOffset);
-            draw_clipped_filter(canvas, rectFilter.get(), 0, r, bounds);
+            draw_clipped_filter(canvas, rectFilter, 0, r, bounds);
             canvas->translate(0, r.height() + margin);
         }
     }
diff --git a/gm/imagefiltersscaled.cpp b/gm/imagefiltersscaled.cpp
index 9bfac68c12..b0c55dca73 100644
--- a/gm/imagefiltersscaled.cpp
+++ b/gm/imagefiltersscaled.cpp
@@ -86,7 +86,7 @@ protected:
             SkErodeImageFilter::Create(1, 1, checkerboard.get()),
             SkOffsetImageFilter::Create(SkIntToScalar(32), 0),
             SkImageFilter::CreateMatrixFilter(resizeMatrix, kNone_SkFilterQuality),
-            SkPaintImageFilter::Make(noisePaint).release(),
+            SkPaintImageFilter::Create(noisePaint),
             SkLightingImageFilter::CreatePointLitDiffuse(pointLocation, white, surfaceScale, kd),
             SkLightingImageFilter::CreateSpotLitDiffuse(spotLocation, spotTarget, spotExponent,
                                                         cutoffAngle, white, surfaceScale, kd),
diff --git a/gm/localmatriximagefilter.cpp b/gm/localmatriximagefilter.cpp
index 5414fe341c..d53380b858 100644
--- a/gm/localmatriximagefilter.cpp
+++ b/gm/localmatriximagefilter.cpp
@@ -49,7 +49,7 @@ protected:
         return SkISize::Make(640, 640);
     }
 
-    static void show_image(SkCanvas* canvas, SkImage* image, sk_sp<SkImageFilter> filter) {
+    static void show_image(SkCanvas* canvas, SkImage* image, SkImageFilter* filter) {
         SkPaint paint;
         paint.setStyle(SkPaint::kStroke_Style);
         SkRect r = SkRect::MakeIWH(image->width(), image->height()).makeOutset(SK_ScalarHalf,
@@ -81,14 +81,14 @@ protected:
 
         canvas->translate(40, 40);
         for (auto&& factory : factories) {
-            sk_sp<SkImageFilter> filter(factory());
+            SkAutoTUnref<SkImageFilter> filter(factory());
 
             canvas->save();
             show_image(canvas, image0.get(), filter);
             for (const auto& matrix : matrices) {
-                sk_sp<SkImageFilter> localFilter(filter->makeWithLocalMatrix(matrix));
+                SkAutoTUnref<SkImageFilter> localFilter(filter->newWithLocalMatrix(matrix));
                 canvas->translate(spacer, 0);
-                show_image(canvas, image0.get(), std::move(localFilter));
+                show_image(canvas, image0.get(), localFilter);
             }
             canvas->restore();
             canvas->translate(0, spacer);
diff --git a/include/core/SkImageFilter.h b/include/core/SkImageFilter.h
index f4273cb8da..ab72547fed 100644
--- a/include/core/SkImageFilter.h
+++ b/include/core/SkImageFilter.h
@@ -255,13 +255,7 @@ public:
      *  If this filter can be represented by another filter + a localMatrix, return that filter,
      *  else return null.
      */
-    sk_sp<SkImageFilter> makeWithLocalMatrix(const SkMatrix&) const;
-
-#ifdef SK_SUPPORT_LEGACY_IMAGEFILTER_PTR
-    SkImageFilter* newWithLocalMatrix(const SkMatrix& matrix) const {
-        this->makeWithLocalMatrix(matrix).release();
-    }
-#endif
+    SkImageFilter* newWithLocalMatrix(const SkMatrix& matrix) const;
 
     /**
      * Create an SkMatrixImageFilter, which transforms its input by the given matrix.
@@ -326,9 +320,7 @@ protected:
         void allocInputs(int count);
     };
 
-    SkImageFilter(int inputCount, SkImageFilter** inputs, const CropRect* cropRect = nullptr);
-
-    SkImageFilter(sk_sp<SkImageFilter>* inputs, int inputCount, const CropRect* cropRect);
+    SkImageFilter(int inputCount, SkImageFilter** inputs, const CropRect* cropRect = NULL);
 
     virtual ~SkImageFilter();
 
diff --git a/include/effects/SkPaintImageFilter.h b/include/effects/SkPaintImageFilter.h
index 2876c0431b..51d375f44d 100644
--- a/include/effects/SkPaintImageFilter.h
+++ b/include/effects/SkPaintImageFilter.h
@@ -22,21 +22,13 @@ public:
      *                not specified, the source primitive's bounds are used
      *                instead.
      */
-    static sk_sp<SkImageFilter> Make(const SkPaint& paint, const CropRect* cropRect = nullptr) {
-        return sk_sp<SkImageFilter>(new SkPaintImageFilter(paint, cropRect));
-    }
+    static SkImageFilter* Create(const SkPaint& paint, const CropRect* rect = NULL);
 
     bool canComputeFastBounds() const override;
 
     SK_TO_STRING_OVERRIDE()
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkPaintImageFilter)
 
-#ifdef SK_SUPPORT_LEGACY_IMAGEFILTER_PTR
-    static SkImageFilter* Create(const SkPaint& paint, const CropRect* rect = nullptr) {
-        return Make(paint, rect).release();
-    }
-#endif
-
 protected:
     void flatten(SkWriteBuffer&) const override;
     sk_sp<SkSpecialImage> onFilterImage(SkSpecialImage* source, const Context&,
diff --git a/samplecode/SampleFilterFuzz.cpp b/samplecode/SampleFilterFuzz.cpp
index 751ef9be39..d5fbc97a17 100644
--- a/samplecode/SampleFilterFuzz.cpp
+++ b/samplecode/SampleFilterFuzz.cpp
@@ -487,7 +487,7 @@ static SkMaskFilter* make_mask_filter() {
     return maskFilter;
 }
 
-static sk_sp<SkImageFilter> make_image_filter(bool canBeNull = true);
+static SkImageFilter* make_image_filter(bool canBeNull = true);
 
 static SkPaint make_paint() {
     SkPaint paint;
@@ -540,13 +540,11 @@ static SkPaint make_paint() {
     return paint;
 }
 
-static sk_sp<SkImageFilter> make_image_filter(bool canBeNull) {
-    sk_sp<SkImageFilter> filter;
+static SkImageFilter* make_image_filter(bool canBeNull) {
+    SkImageFilter* filter = 0;
 
     // Add a 1 in 3 chance to get a nullptr input
-    if (canBeNull && (R(3) == 1)) {
-        return filter;
-    }
+    if (canBeNull && (R(3) == 1)) { return filter; }
 
     enum { ALPHA_THRESHOLD, MERGE, COLOR, LUT3D, BLUR, MAGNIFIER,
            DOWN_SAMPLE, XFERMODE, OFFSET, MATRIX, MATRIX_CONVOLUTION, COMPOSE,
@@ -555,73 +553,49 @@ static sk_sp<SkImageFilter> make_image_filter(bool canBeNull) {
 
     switch (R(NUM_FILTERS)) {
     case ALPHA_THRESHOLD:
-        filter = sk_sp<SkImageFilter>(SkAlphaThresholdFilter::Create(make_region(),
-                                                                     make_scalar(),
-                                                                     make_scalar()));
+        filter = SkAlphaThresholdFilter::Create(make_region(), make_scalar(), make_scalar());
         break;
-    case MERGE: {
-        sk_sp<SkImageFilter> subFilter1(make_image_filter());
-        sk_sp<SkImageFilter> subFilter2(make_image_filter());
-        filter = sk_sp<SkImageFilter>(SkMergeImageFilter::Create(subFilter1.get(), 
-                                                                 subFilter2.get(),
-                                                                 make_xfermode()));
+    case MERGE:
+        filter = SkMergeImageFilter::Create(make_image_filter(), make_image_filter(), make_xfermode());
         break;
-    }
-    case COLOR: {
+    case COLOR:
+    {
         sk_sp<SkColorFilter> cf(make_color_filter());
-        sk_sp<SkImageFilter> subFilter(make_image_filter());
-        filter = cf ? sk_sp<SkImageFilter>(SkColorFilterImageFilter::Create(cf.get(),
-                                                                            subFilter.get()))
-                    : nullptr;
-        break;
+        filter = cf ? SkColorFilterImageFilter::Create(cf.get(), make_image_filter()) : 0;
     }
-    case LUT3D: {
+        break;
+    case LUT3D:
+    {
         int cubeDimension;
         sk_sp<SkData> lut3D(make_3Dlut(&cubeDimension, (R(2) == 1), (R(2) == 1), (R(2) == 1)));
         sk_sp<SkColorFilter> cf(SkColorCubeFilter::Make(lut3D, cubeDimension));
-        sk_sp<SkImageFilter> subFilter(make_image_filter());
-        filter = cf ? sk_sp<SkImageFilter>(SkColorFilterImageFilter::Create(cf.get(), 
-                                                                            subFilter.get()))
-                    : nullptr;
-        break;
+        filter = cf ? SkColorFilterImageFilter::Create(cf.get(), make_image_filter()) : 0;
     }
-    case BLUR: {
-        sk_sp<SkImageFilter> subFilter(make_image_filter());
-        filter = sk_sp<SkImageFilter>(SkBlurImageFilter::Create(make_scalar(true),
-                                                                make_scalar(true),
-                                                                subFilter.get()));
         break;
-    }
+    case BLUR:
+        filter = SkBlurImageFilter::Create(make_scalar(true), make_scalar(true), make_image_filter());
+        break;
     case MAGNIFIER:
-        filter = sk_sp<SkImageFilter>(SkMagnifierImageFilter::Create(make_rect(), 
-                                                                     make_scalar(true)));
+        filter = SkMagnifierImageFilter::Create(make_rect(), make_scalar(true));
         break;
     case DOWN_SAMPLE:
-        filter = sk_sp<SkImageFilter>(SkDownSampleImageFilter::Create(make_scalar()));
+        filter = SkDownSampleImageFilter::Create(make_scalar());
         break;
-    case XFERMODE: {
-        sk_sp<SkImageFilter> subFilter1(make_image_filter());
-        sk_sp<SkImageFilter> subFilter2(make_image_filter());
+    case XFERMODE:
         filter = SkXfermodeImageFilter::Make(SkXfermode::Make(make_xfermode()),
-                                             subFilter1.get(),
-                                             subFilter2.get(),
-                                             nullptr);
+                                             make_image_filter(), make_image_filter(),
+                                             nullptr).release();
         break;
-    }
-    case OFFSET: {
-        sk_sp<SkImageFilter> subFilter(make_image_filter());
-        filter = sk_sp<SkImageFilter>(SkOffsetImageFilter::Create(make_scalar(), make_scalar(),
-                                                                  subFilter.get()));
+    case OFFSET:
+        filter = SkOffsetImageFilter::Create(make_scalar(), make_scalar(), make_image_filter());
         break;
-    }
-    case MATRIX: {
-        sk_sp<SkImageFilter> subFilter(make_image_filter());
-        filter = sk_sp<SkImageFilter>(SkImageFilter::CreateMatrixFilter(make_matrix(),
-                                                                        (SkFilterQuality)R(4),
-                                                                        subFilter.get()));
+    case MATRIX:
+        filter = SkImageFilter::CreateMatrixFilter(make_matrix(),
+                                                   (SkFilterQuality)R(4),
+                                                   make_image_filter());
         break;
-    }
-    case MATRIX_CONVOLUTION: {
+    case MATRIX_CONVOLUTION:
+    {
         SkImageFilter::CropRect cropR(SkRect::MakeWH(SkIntToScalar(kBitmapSize),
                                                      SkIntToScalar(kBitmapSize)));
         SkISize size = SkISize::Make(R(10)+1, R(10)+1);
@@ -632,68 +606,47 @@ static sk_sp<SkImageFilter> make_image_filter(bool canBeNull) {
         }
         SkIPoint kernelOffset = SkIPoint::Make(R(SkIntToScalar(size.width())),
                                                R(SkIntToScalar(size.height())));
-        sk_sp<SkImageFilter> subFilter(make_image_filter());
-
-        filter = sk_sp<SkImageFilter>(SkMatrixConvolutionImageFilter::Create(
-                                                        size,
+        filter = SkMatrixConvolutionImageFilter::Create(size,
                                                         kernel.begin(),
                                                         make_scalar(),
                                                         make_scalar(),
                                                         kernelOffset,
                                                         (SkMatrixConvolutionImageFilter::TileMode)R(3),
                                                         R(2) == 1,
-                                                        subFilter.get(),
-                                                        &cropR));
-        break;
+                                                        make_image_filter(),
+                                                        &cropR);
     }
-    case COMPOSE: {
-        sk_sp<SkImageFilter> subFilter1(make_image_filter());
-        sk_sp<SkImageFilter> subFilter2(make_image_filter());
-        filter = sk_sp<SkImageFilter>(SkComposeImageFilter::Create(subFilter1.get(),
-                                                                   subFilter2.get()));
         break;
-    }
-    case DISTANT_LIGHT: {
-        sk_sp<SkImageFilter> subFilter(make_image_filter());
-
-        filter = (R(2) == 1)
-                 ? sk_sp<SkImageFilter>(SkLightingImageFilter::CreateDistantLitDiffuse(make_point(),
-                                                make_color(), make_scalar(), make_scalar(),
-                                                subFilter.get()))
-                 : sk_sp<SkImageFilter>(SkLightingImageFilter::CreateDistantLitSpecular(make_point(),
-                                                make_color(), make_scalar(),
-                                                make_scalar(), SkIntToScalar(R(10)),
-                                                subFilter.get()));
+    case COMPOSE:
+        filter = SkComposeImageFilter::Create(make_image_filter(), make_image_filter());
         break;
-    }
-    case POINT_LIGHT: {
-        sk_sp<SkImageFilter> subFilter(make_image_filter());
-
-        filter = (R(2) == 1)
-                 ? sk_sp<SkImageFilter>(SkLightingImageFilter::CreatePointLitDiffuse(make_point(),
-                                                make_color(), make_scalar(), make_scalar(),
-                                                subFilter.get()))
-                 : sk_sp<SkImageFilter>(SkLightingImageFilter::CreatePointLitSpecular(make_point(),
-                                                make_color(), make_scalar(), make_scalar(),
-                                                SkIntToScalar(R(10)),
-                                                subFilter.get()));
+    case DISTANT_LIGHT:
+        filter = (R(2) == 1) ?
+                 SkLightingImageFilter::CreateDistantLitDiffuse(make_point(),
+                 make_color(), make_scalar(), make_scalar(), make_image_filter()) :
+                 SkLightingImageFilter::CreateDistantLitSpecular(make_point(),
+                 make_color(), make_scalar(), make_scalar(), SkIntToScalar(R(10)),
+                 make_image_filter());
         break;
-    }
-    case SPOT_LIGHT: {
-        sk_sp<SkImageFilter> subFilter(make_image_filter());
-
-        filter = (R(2) == 1)
-                 ? sk_sp<SkImageFilter>(SkLightingImageFilter::CreateSpotLitDiffuse(SkPoint3::Make(0, 0, 0),
-                                                 make_point(), make_scalar(), make_scalar(),
-                                                 make_color(), make_scalar(), make_scalar(),
-                                                 subFilter.get()))
-                 : sk_sp<SkImageFilter>(SkLightingImageFilter::CreateSpotLitSpecular(SkPoint3::Make(0, 0, 0),
-                                                 make_point(), make_scalar(), make_scalar(),
-                                                 make_color(), make_scalar(), make_scalar(),
-                                                 SkIntToScalar(R(10)), subFilter.get()));
+    case POINT_LIGHT:
+        filter = (R(2) == 1) ?
+                 SkLightingImageFilter::CreatePointLitDiffuse(make_point(),
+                 make_color(), make_scalar(), make_scalar(), make_image_filter()) :
+                 SkLightingImageFilter::CreatePointLitSpecular(make_point(),
+                 make_color(), make_scalar(), make_scalar(), SkIntToScalar(R(10)),
+                 make_image_filter());
         break;
-    }
-    case NOISE: {
+    case SPOT_LIGHT:
+        filter = (R(2) == 1) ?
+                 SkLightingImageFilter::CreateSpotLitDiffuse(SkPoint3::Make(0, 0, 0),
+                 make_point(), make_scalar(), make_scalar(), make_color(),
+                 make_scalar(), make_scalar(), make_image_filter()) :
+                 SkLightingImageFilter::CreateSpotLitSpecular(SkPoint3::Make(0, 0, 0),
+                 make_point(), make_scalar(), make_scalar(), make_color(),
+                 make_scalar(), make_scalar(), SkIntToScalar(R(10)), make_image_filter());
+        break;
+    case NOISE:
+    {
         sk_sp<SkShader> shader((R(2) == 1) ?
             SkPerlinNoiseShader::MakeFractalNoise(
                 make_scalar(true), make_scalar(true), R(10.0f), make_scalar()) :
@@ -703,68 +656,43 @@ static sk_sp<SkImageFilter> make_image_filter(bool canBeNull) {
         paint.setShader(shader);
         SkImageFilter::CropRect cropR(SkRect::MakeWH(SkIntToScalar(kBitmapSize),
                                                      SkIntToScalar(kBitmapSize)));
-        filter = SkPaintImageFilter::Make(paint, &cropR);
-        break;
+        filter = SkPaintImageFilter::Create(paint, &cropR);
     }
-    case DROP_SHADOW: {
-        sk_sp<SkImageFilter> subFilter(make_image_filter());
-
-        filter = sk_sp<SkImageFilter>(SkDropShadowImageFilter::Create(make_scalar(),
-                                                                      make_scalar(),
-                                                                      make_scalar(true),
-                                                                      make_scalar(true),
-                                                                      make_color(),
-                                                                      make_shadow_mode(),
-                                                                      subFilter.get(),
-                                                                      nullptr));
         break;
-    }
-    case MORPHOLOGY: {
-        sk_sp<SkImageFilter> subFilter(make_image_filter());
-
+    case DROP_SHADOW:
+        filter = SkDropShadowImageFilter::Create(make_scalar(), make_scalar(), make_scalar(true),
+                    make_scalar(true), make_color(), make_shadow_mode(), make_image_filter(),
+                    nullptr);
+        break;
+    case MORPHOLOGY:
         if (R(2) == 1) {
-            filter = sk_sp<SkImageFilter>(SkDilateImageFilter::Create(R(static_cast<float>(kBitmapSize)),
-                                                R(static_cast<float>(kBitmapSize)),
-                                                subFilter.get()));
+            filter = SkDilateImageFilter::Create(R(static_cast<float>(kBitmapSize)),
+                R(static_cast<float>(kBitmapSize)), make_image_filter());
         } else {
-            filter = sk_sp<SkImageFilter>(SkErodeImageFilter::Create(R(static_cast<float>(kBitmapSize)),
-                                                R(static_cast<float>(kBitmapSize)),
-                                                subFilter.get()));
+            filter = SkErodeImageFilter::Create(R(static_cast<float>(kBitmapSize)),
+                R(static_cast<float>(kBitmapSize)), make_image_filter());
         }
         break;
-    }
-    case BITMAP: {
+    case BITMAP:
+    {
         sk_sp<SkImage> image(SkImage::MakeFromBitmap(make_bitmap()));
         if (R(2) == 1) {
-            filter = sk_sp<SkImageFilter>(SkImageSource::Create(image.get(),
-                                                                make_rect(),
-                                                                make_rect(),
-                                                                kHigh_SkFilterQuality));
+            filter = SkImageSource::Create(image.get(), make_rect(), make_rect(), kHigh_SkFilterQuality);
         } else {
-            filter = sk_sp<SkImageFilter>(SkImageSource::Create(image.get()));
+            filter = SkImageSource::Create(image.get());
         }
-        break;
     }
-    case DISPLACE: {
-        sk_sp<SkImageFilter> subFilter1(make_image_filter(false));
-        sk_sp<SkImageFilter> subFilter2(make_image_filter());
-
-        filter = sk_sp<SkImageFilter>(SkDisplacementMapEffect::Create(make_channel_selector_type(),
-                                                                      make_channel_selector_type(),
-                                                                      make_scalar(),
-                                                                      subFilter1.get(),
-                                                                      subFilter2.get()));
         break;
-    }
-    case TILE: {
-        sk_sp<SkImageFilter> subFilter(make_image_filter(false));
-
-        filter = sk_sp<SkImageFilter>(SkTileImageFilter::Create(make_rect(),
-                                                                make_rect(),
-                                                                subFilter.get()));
+    case DISPLACE:
+        filter = SkDisplacementMapEffect::Create(make_channel_selector_type(),
+                                                 make_channel_selector_type(), make_scalar(),
+                                                 make_image_filter(false), make_image_filter());
         break;
-    }
-    case PICTURE: {
+    case TILE:
+        filter = SkTileImageFilter::Create(make_rect(), make_rect(), make_image_filter(false));
+        break;
+    case PICTURE:
+    {
         SkRTreeFactory factory;
         SkPictureRecorder recorder;
         SkCanvas* recordingCanvas = recorder.beginRecording(SkIntToScalar(kBitmapSize),
@@ -772,13 +700,13 @@ static sk_sp<SkImageFilter> make_image_filter(bool canBeNull) {
                                                             &factory, 0);
         drawSomething(recordingCanvas);
         sk_sp<SkPicture> pict(recorder.finishRecordingAsPicture());
-        filter = SkPictureImageFilter::Make(pict, make_rect());
-        break;
+        filter = SkPictureImageFilter::Make(pict, make_rect()).release();
     }
-    case PAINT: {
-        SkImageFilter::CropRect cropR(make_rect());
-        filter = SkPaintImageFilter::Make(make_paint(), &cropR);
         break;
+    case PAINT:
+    {
+        SkImageFilter::CropRect cropR(make_rect());
+        filter = SkPaintImageFilter::Create(make_paint(), &cropR);
     }
     default:
         break;
@@ -787,8 +715,8 @@ static sk_sp<SkImageFilter> make_image_filter(bool canBeNull) {
 }
 
 static SkImageFilter* make_serialized_image_filter() {
-    sk_sp<SkImageFilter> filter(make_image_filter(false));
-    SkAutoTUnref<SkData> data(SkValidatingSerializeFlattenable(filter.get()));
+    SkAutoTUnref<SkImageFilter> filter(make_image_filter(false));
+    SkAutoTUnref<SkData> data(SkValidatingSerializeFlattenable(filter));
     const unsigned char* ptr = static_cast<const unsigned char*>(data->data());
     size_t len = data->size();
 #ifdef SK_ADD_RANDOM_BIT_FLIPS
diff --git a/src/core/SkCanvas.cpp b/src/core/SkCanvas.cpp
index 2f6477c41d..f1777441d6 100644
--- a/src/core/SkCanvas.cpp
+++ b/src/core/SkCanvas.cpp
@@ -1161,8 +1161,9 @@ static void draw_filter_into_device(SkBaseDevice* src, const SkImageFilter* filt
 
     SkCanvas c(dst);
 
+    SkAutoTUnref<SkImageFilter> localF(filter->newWithLocalMatrix(ctm));
     SkPaint p;
-    p.setImageFilter(filter->makeWithLocalMatrix(ctm));
+    p.setImageFilter(localF);
     const SkScalar x = SkIntToScalar(src->getOrigin().x());
     const SkScalar y = SkIntToScalar(src->getOrigin().y());
     c.drawBitmap(srcBM, x, y, &p);
diff --git a/src/core/SkImageFilter.cpp b/src/core/SkImageFilter.cpp
index e999d3aebb..06076c6891 100644
--- a/src/core/SkImageFilter.cpp
+++ b/src/core/SkImageFilter.cpp
@@ -158,22 +158,6 @@ bool SkImageFilter::Common::unflatten(SkReadBuffer& buffer, int expectedCount) {
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-SkImageFilter::SkImageFilter(sk_sp<SkImageFilter>* inputs,
-                             int inputCount,
-                             const CropRect* cropRect)
-    : fInputCount(inputCount),
-    fInputs(new SkImageFilter*[inputCount]),
-    fUsesSrcInput(false),
-    fCropRect(cropRect ? *cropRect : CropRect(SkRect(), 0x0)),
-    fUniqueID(next_image_filter_unique_id()) {
-    for (int i = 0; i < inputCount; ++i) {
-        if (nullptr == inputs[i] || inputs[i]->usesSrcInput()) {
-            fUsesSrcInput = true;
-        }
-        fInputs[i] = SkSafeRef(inputs[i].get());
-    }
-}
-
 SkImageFilter::SkImageFilter(int inputCount, SkImageFilter** inputs, const CropRect* cropRect)
   : fInputCount(inputCount),
     fInputs(new SkImageFilter*[inputCount]),
@@ -184,7 +168,8 @@ SkImageFilter::SkImageFilter(int inputCount, SkImageFilter** inputs, const CropR
         if (nullptr == inputs[i] || inputs[i]->usesSrcInput()) {
             fUsesSrcInput = true;
         }
-        fInputs[i] = SkSafeRef(inputs[i]);
+        fInputs[i] = inputs[i];
+        SkSafeRef(fInputs[i]);
     }
 }
 
@@ -571,12 +556,11 @@ SkImageFilter* SkImageFilter::CreateMatrixFilter(const SkMatrix& matrix,
     return SkMatrixImageFilter::Create(matrix, filterQuality, input);
 }
 
-sk_sp<SkImageFilter> SkImageFilter::makeWithLocalMatrix(const SkMatrix& matrix) const {
+SkImageFilter* SkImageFilter::newWithLocalMatrix(const SkMatrix& matrix) const {
     // SkLocalMatrixImageFilter takes SkImage* in its factory, but logically that parameter
     // is *always* treated as a const ptr. Hence the const-cast here.
     //
-    SkImageFilter* nonConstThis = const_cast<SkImageFilter*>(this);
-    return SkLocalMatrixImageFilter::Make(matrix, sk_ref_sp<SkImageFilter>(nonConstThis));
+    return SkLocalMatrixImageFilter::Create(matrix, const_cast<SkImageFilter*>(this));
 }
 
 sk_sp<SkSpecialImage> SkImageFilter::filterInput(int index,
diff --git a/src/core/SkLocalMatrixImageFilter.cpp b/src/core/SkLocalMatrixImageFilter.cpp
index d1b5715b7f..15f2f0ef00 100644
--- a/src/core/SkLocalMatrixImageFilter.cpp
+++ b/src/core/SkLocalMatrixImageFilter.cpp
@@ -10,9 +10,21 @@
 #include "SkSpecialImage.h"
 #include "SkString.h"
 
-SkLocalMatrixImageFilter::SkLocalMatrixImageFilter(const SkMatrix& localM,
-                                                   sk_sp<SkImageFilter> input)
-    : INHERITED(&input, 1, nullptr)
+SkImageFilter* SkLocalMatrixImageFilter::Create(const SkMatrix& localM, SkImageFilter* input) {
+    if (!input) {
+        return nullptr;
+    }
+    if (localM.getType() & (SkMatrix::kAffine_Mask | SkMatrix::kPerspective_Mask)) {
+        return nullptr;
+    }
+    if (localM.isIdentity()) {
+        return SkRef(input);
+    }
+    return new SkLocalMatrixImageFilter(localM, input);
+}
+
+SkLocalMatrixImageFilter::SkLocalMatrixImageFilter(const SkMatrix& localM, SkImageFilter* input)
+    : INHERITED(1, &input)
     , fLocalM(localM) {
 }
 
@@ -20,8 +32,7 @@ SkFlattenable* SkLocalMatrixImageFilter::CreateProc(SkReadBuffer& buffer) {
     SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
     SkMatrix lm;
     buffer.readMatrix(&lm);
-    return SkLocalMatrixImageFilter::Make(lm,
-                                          sk_ref_sp<SkImageFilter>(common.getInput(0))).release();
+    return SkLocalMatrixImageFilter::Create(lm, common.getInput(0));
 }
 
 void SkLocalMatrixImageFilter::flatten(SkWriteBuffer& buffer) const {
diff --git a/src/core/SkLocalMatrixImageFilter.h b/src/core/SkLocalMatrixImageFilter.h
index eb112b0f0d..412b391e18 100644
--- a/src/core/SkLocalMatrixImageFilter.h
+++ b/src/core/SkLocalMatrixImageFilter.h
@@ -16,28 +16,11 @@
  */
 class SkLocalMatrixImageFilter : public SkImageFilter {
 public:
-    static sk_sp<SkImageFilter> Make(const SkMatrix& localM, sk_sp<SkImageFilter> input) {
-        if (!input) {
-            return nullptr;
-        }
-        if (localM.getType() & (SkMatrix::kAffine_Mask | SkMatrix::kPerspective_Mask)) {
-            return nullptr;
-        }
-        if (localM.isIdentity()) {
-            return input;
-        }
-        return sk_sp<SkImageFilter>(new SkLocalMatrixImageFilter(localM, input));
-    }
+    static SkImageFilter* Create(const SkMatrix& localM, SkImageFilter* input);
 
     SK_TO_STRING_OVERRIDE()
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkLocalMatrixImageFilter)
 
-#ifdef SK_SUPPORT_LEGACY_IMAGEFILTER_PTR
-    static SkImageFilter* Create(const SkMatrix& localM, SkImageFilter* input) {
-        return Make(localM, sk_sp<SkImageFilter>(SkSafeRef(input))).release();
-    }
-#endif
-
 protected:
     void flatten(SkWriteBuffer&) const override;
     sk_sp<SkSpecialImage> onFilterImage(SkSpecialImage* source, const Context&,
@@ -45,7 +28,7 @@ protected:
     SkIRect onFilterBounds(const SkIRect& src, const SkMatrix&, MapDirection) const override;
 
 private:
-    SkLocalMatrixImageFilter(const SkMatrix& localM, sk_sp<SkImageFilter> input);
+    SkLocalMatrixImageFilter(const SkMatrix& localM, SkImageFilter* input);
 
     SkMatrix fLocalM;
 
diff --git a/src/effects/SkPaintImageFilter.cpp b/src/effects/SkPaintImageFilter.cpp
index cbd793a692..7056f26863 100644
--- a/src/effects/SkPaintImageFilter.cpp
+++ b/src/effects/SkPaintImageFilter.cpp
@@ -12,16 +12,20 @@
 #include "SkSpecialSurface.h"
 #include "SkWriteBuffer.h"
 
+SkImageFilter* SkPaintImageFilter::Create(const SkPaint& paint, const CropRect* cropRect) {
+    return new SkPaintImageFilter(paint, cropRect);
+}
+
 SkPaintImageFilter::SkPaintImageFilter(const SkPaint& paint, const CropRect* cropRect)
-    : INHERITED(nullptr, 0, cropRect)
-    , fPaint(paint) {
+  : INHERITED(0, nullptr, cropRect)
+  , fPaint(paint) {
 }
 
 SkFlattenable* SkPaintImageFilter::CreateProc(SkReadBuffer& buffer) {
     SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 0);
     SkPaint paint;
     buffer.readPaint(&paint);
-    return SkPaintImageFilter::Make(paint, &common.cropRect()).release();
+    return Create(paint, &common.cropRect());
 }
 
 void SkPaintImageFilter::flatten(SkWriteBuffer& buffer) const {
@@ -76,7 +80,6 @@ bool SkPaintImageFilter::canComputeFastBounds() const {
 #ifndef SK_IGNORE_TO_STRING
 void SkPaintImageFilter::toString(SkString* str) const {
     str->appendf("SkPaintImageFilter: (");
-    fPaint.toString(str);
     str->append(")");
 }
 #endif
diff --git a/src/effects/SkPictureImageFilter.cpp b/src/effects/SkPictureImageFilter.cpp
index 2005463bd4..f5e3d4680b 100644
--- a/src/effects/SkPictureImageFilter.cpp
+++ b/src/effects/SkPictureImageFilter.cpp
@@ -14,7 +14,7 @@
 #include "SkValidationUtils.h"
 
 SkPictureImageFilter::SkPictureImageFilter(sk_sp<SkPicture> picture)
-    : INHERITED(nullptr, 0, nullptr)
+    : INHERITED(0, 0, nullptr)
     , fPicture(std::move(picture))
     , fCropRect(fPicture ? fPicture->cullRect() : SkRect::MakeEmpty())
     , fPictureResolution(kDeviceSpace_PictureResolution)
@@ -24,7 +24,7 @@ SkPictureImageFilter::SkPictureImageFilter(sk_sp<SkPicture> picture)
 SkPictureImageFilter::SkPictureImageFilter(sk_sp<SkPicture> picture, const SkRect& cropRect,
                                            PictureResolution pictureResolution,
                                            SkFilterQuality filterQuality)
-    : INHERITED(nullptr, 0, nullptr)
+    : INHERITED(0, 0, nullptr)
     , fPicture(std::move(picture))
     , fCropRect(cropRect)
     , fPictureResolution(pictureResolution)
diff --git a/tests/ImageFilterTest.cpp b/tests/ImageFilterTest.cpp
index cd900e3df1..9d2039687d 100644
--- a/tests/ImageFilterTest.cpp
+++ b/tests/ImageFilterTest.cpp
@@ -138,17 +138,17 @@ public:
 
         SkPaint paint;
         paint.setShader(shader);
-        sk_sp<SkImageFilter> paintFilter(SkPaintImageFilter::Make(paint));
+        SkAutoTUnref<SkImageFilter> paintFilter(SkPaintImageFilter::Create(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));
+        SkAutoTUnref<SkImageFilter> paintFilterLeft(SkPaintImageFilter::Create(
+            greenColorShaderPaint, &leftSideCropRect));
         SkImageFilter::CropRect rightSideCropRect(SkRect::MakeXYWH(32, 0, 32, 64));
-        sk_sp<SkImageFilter> paintFilterRight(SkPaintImageFilter::Make(greenColorShaderPaint,
-                                                                       &rightSideCropRect));
+        SkAutoTUnref<SkImageFilter> paintFilterRight(SkPaintImageFilter::Create(
+            greenColorShaderPaint, &rightSideCropRect));
 
         this->addFilter("color filter",
             SkColorFilterImageFilter::Create(cf.get(), input, cropRect));
@@ -172,8 +172,7 @@ public:
         this->addFilter("merge", SkMergeImageFilter::Create(input, input, SkXfermode::kSrcOver_Mode,
                   cropRect));
         this->addFilter("merge with disjoint inputs", SkMergeImageFilter::Create(
-                  paintFilterLeft.get(), paintFilterRight.get(),
-                  SkXfermode::kSrcOver_Mode, cropRect));
+                  paintFilterLeft, paintFilterRight, SkXfermode::kSrcOver_Mode, cropRect));
         this->addFilter("offset",
                         SkOffsetImageFilter::Create(SK_Scalar1, SK_Scalar1, input, cropRect));
         this->addFilter("dilate", SkDilateImageFilter::Create(3, 2, input, cropRect));
diff --git a/tests/PaintImageFilterTest.cpp b/tests/PaintImageFilterTest.cpp
index 03653368ab..f1c0c2eb97 100644
--- a/tests/PaintImageFilterTest.cpp
+++ b/tests/PaintImageFilterTest.cpp
@@ -38,7 +38,7 @@ static void test_unscaled(skiatest::Reporter* reporter) {
     {
         SkPaint paint;
         SkImageFilter::CropRect cr(r);
-        paint.setImageFilter(SkPaintImageFilter::Make(gradientPaint, &cr));
+        paint.setImageFilter(SkPaintImageFilter::Create(gradientPaint, &cr))->unref();
         canvasFilter.drawRect(r, paint);
     }
 
@@ -84,7 +84,7 @@ static void test_scaled(skiatest::Reporter* reporter) {
     {
         SkPaint paint;
         SkImageFilter::CropRect cr(r);
-        paint.setImageFilter(SkPaintImageFilter::Make(gradientPaint, &cr));
+        paint.setImageFilter(SkPaintImageFilter::Create(gradientPaint, &cr))->unref();
         canvasFilter.scale(SkIntToScalar(2), SkIntToScalar(2));
         canvasFilter.drawRect(r, paint);
     }