Update TileImageFilter to sk_sp

TBR=reed@google.com

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

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

9 files changed, 38 insertions, 40 deletions

diff --git a/bench/TileImageFilterBench.cpp b/bench/TileImageFilterBench.cpp
index 350b0ac214..b9b38edd35 100644
--- a/bench/TileImageFilterBench.cpp
+++ b/bench/TileImageFilterBench.cpp
@@ -37,11 +37,9 @@ protected:
 
     void onDraw(int loops, SkCanvas* canvas) override {
         SkPaint paint;
-        SkAutoTUnref<SkImageFilter> tile(SkTileImageFilter::Create(
-            SkRect::MakeWH(50, 50),
-            SkRect::MakeWH(WIDTH, HEIGHT),
-            nullptr));
-        paint.setImageFilter(tile);
+        paint.setImageFilter(SkTileImageFilter::Make(SkRect::MakeWH(50, 50),
+                                                     SkRect::MakeWH(WIDTH, HEIGHT),
+                                                     nullptr));
 
         for (int i = 0; i < loops; i++) {
             if (fTileSize > 0) {
diff --git a/fuzz/FilterFuzz.cpp b/fuzz/FilterFuzz.cpp
index 484bbf7624..cad32466fc 100644
--- a/fuzz/FilterFuzz.cpp
+++ b/fuzz/FilterFuzz.cpp
@@ -713,14 +713,9 @@ static sk_sp<SkImageFilter> make_image_filter(bool canBeNull) {
                                                make_image_filter(false),
                                                make_image_filter());
         break;
-    case TILE: {
-        sk_sp<SkImageFilter> subFilter(make_image_filter(false));
-
-        filter = sk_sp<SkImageFilter>(SkTileImageFilter::Create(make_rect(),
-                                                                make_rect(),
-                                                                subFilter.get()));
+    case TILE:
+        filter = SkTileImageFilter::Make(make_rect(), make_rect(), make_image_filter(false));
         break;
-    }
     case PICTURE: {
         SkRTreeFactory factory;
         SkPictureRecorder recorder;
diff --git a/gm/bigtileimagefilter.cpp b/gm/bigtileimagefilter.cpp
index 5c12f94ea0..b74f62ce61 100644
--- a/gm/bigtileimagefilter.cpp
+++ b/gm/bigtileimagefilter.cpp
@@ -57,10 +57,10 @@ protected:
             const SkRect bound = SkRect::MakeIWH(kWidth, kHeight);
             sk_sp<SkImageFilter> imageSource(SkImageSource::Make(fRedImage));
 
-            sk_sp<SkImageFilter> tif(SkTileImageFilter::Create(
+            sk_sp<SkImageFilter> tif(SkTileImageFilter::Make(
                                                     SkRect::MakeIWH(kBitmapSize, kBitmapSize),
                                                     SkRect::MakeIWH(kWidth, kHeight),
-                                                    imageSource.get()));
+                                                    std::move(imageSource)));
 
             p.setImageFilter(std::move(tif));
 
@@ -73,7 +73,7 @@ protected:
 
             const SkRect bound2 = SkRect::MakeIWH(kBitmapSize, kBitmapSize);
 
-            sk_sp<SkImageFilter> tif(SkTileImageFilter::Create(
+            sk_sp<SkImageFilter> tif(SkTileImageFilter::Make(
                                                         SkRect::MakeIWH(kBitmapSize, kBitmapSize),
                                                         SkRect::MakeIWH(kBitmapSize, kBitmapSize),
                                                         nullptr));
diff --git a/gm/filterfastbounds.cpp b/gm/filterfastbounds.cpp
index 43a1b1e6f7..408a4e8709 100644
--- a/gm/filterfastbounds.cpp
+++ b/gm/filterfastbounds.cpp
@@ -113,7 +113,7 @@ static void create_paints(SkTArray<SkPaint>* paints, sk_sp<SkImageFilter> source
     {
         SkRect src = SkRect::MakeXYWH(20, 20, 10, 10);
         SkRect dst = SkRect::MakeXYWH(30, 30, 30, 30);
-        sk_sp<SkImageFilter> tileIF(SkTileImageFilter::Create(src, dst, nullptr));
+        sk_sp<SkImageFilter> tileIF(SkTileImageFilter::Make(src, dst, nullptr));
 
         add_paint(paints, std::move(tileIF));
     }
diff --git a/gm/tileimagefilter.cpp b/gm/tileimagefilter.cpp
index fa5bb68bd5..58542b7598 100644
--- a/gm/tileimagefilter.cpp
+++ b/gm/tileimagefilter.cpp
@@ -66,7 +66,9 @@ protected:
                                               SkIntToScalar(image->width() - i * 12),
                                               SkIntToScalar(image->height()) - i * 12);
             sk_sp<SkImageFilter> tileInput(SkImageSource::Make(image));
-            sk_sp<SkImageFilter> filter(SkTileImageFilter::Create(srcRect, dstRect, tileInput.get()));
+            sk_sp<SkImageFilter> filter(SkTileImageFilter::Make(srcRect,
+                                                                dstRect,
+                                                                std::move(tileInput)));
             canvas->save();
             canvas->translate(SkIntToScalar(x), SkIntToScalar(y));
             SkPaint paint;
@@ -91,7 +93,7 @@ protected:
                                         SkIntToScalar(fBitmap->height()));
         SkRect dstRect = SkRect::MakeWH(SkIntToScalar(fBitmap->width() * 2),
                                         SkIntToScalar(fBitmap->height() * 2));
-        sk_sp<SkImageFilter> tile(SkTileImageFilter::Create(srcRect, dstRect, nullptr));
+        sk_sp<SkImageFilter> tile(SkTileImageFilter::Make(srcRect, dstRect, nullptr));
         sk_sp<SkColorFilter> cf(SkColorFilter::MakeMatrixFilterRowMajor255(matrix));
 
         SkPaint paint;
@@ -116,7 +118,7 @@ protected:
         sk_sp<SkImageFilter> green(SkColorFilterImageFilter::Make(std::move(greenCF),
                                                                   nullptr,
                                                                   &cropRect));
-        tile.reset(SkTileImageFilter::Create(srcRect, dstRect, green.get()));
+        tile = SkTileImageFilter::Make(srcRect, dstRect, std::move(green));
         paint.setColor(SK_ColorRED);
         paint.setImageFilter(std::move(tile));
         canvas->drawRect(dstRect, paint);
diff --git a/include/effects/SkTileImageFilter.h b/include/effects/SkTileImageFilter.h
index 1fccac68b4..ae951e318b 100644
--- a/include/effects/SkTileImageFilter.h
+++ b/include/effects/SkTileImageFilter.h
@@ -17,7 +17,9 @@ public:
         @param dst  Defines the pixels where tiles are drawn
         @param input    Input from which the subregion defined by srcRect will be tiled
     */
-    static SkImageFilter* Create(const SkRect& src, const SkRect& dst, SkImageFilter* input);
+    static sk_sp<SkImageFilter> Make(const SkRect& src,
+                                     const SkRect& dst,
+                                     sk_sp<SkImageFilter> input);
 
     SkIRect onFilterBounds(const SkIRect& src, const SkMatrix&, MapDirection) const override;
     SkIRect onFilterNodeBounds(const SkIRect&, const SkMatrix&, MapDirection) const override;
@@ -26,6 +28,12 @@ public:
     SK_TO_STRING_OVERRIDE()
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkTileImageFilter)
 
+#ifdef SK_SUPPORT_LEGACY_IMAGEFILTER_PTR
+    static SkImageFilter* Create(const SkRect& src, const SkRect& dst, SkImageFilter* input) {
+        return Make(src, dst, sk_ref_sp<SkImageFilter>(input)).release();
+    }
+#endif
+
 protected:
     void flatten(SkWriteBuffer& buffer) const override;
 
@@ -33,8 +41,8 @@ protected:
                                         SkIPoint* offset) const override;
 
 private:
-    SkTileImageFilter(const SkRect& srcRect, const SkRect& dstRect, SkImageFilter* input)
-        : INHERITED(1, &input, NULL), fSrcRect(srcRect), fDstRect(dstRect) {}
+    SkTileImageFilter(const SkRect& srcRect, const SkRect& dstRect, sk_sp<SkImageFilter> input)
+        : INHERITED(&input, 1, nullptr), fSrcRect(srcRect), fDstRect(dstRect) {}
 
     SkRect fSrcRect;
     SkRect fDstRect;
diff --git a/samplecode/SampleFilterFuzz.cpp b/samplecode/SampleFilterFuzz.cpp
index 12b6a8af99..6a4f1f822f 100644
--- a/samplecode/SampleFilterFuzz.cpp
+++ b/samplecode/SampleFilterFuzz.cpp
@@ -716,14 +716,9 @@ static sk_sp<SkImageFilter> make_image_filter(bool canBeNull) {
                                                make_image_filter(false),
                                                make_image_filter());
         break;
-    case TILE: {
-        sk_sp<SkImageFilter> subFilter(make_image_filter(false));
-
-        filter = sk_sp<SkImageFilter>(SkTileImageFilter::Create(make_rect(),
-                                                                make_rect(),
-                                                                subFilter.get()));
+    case TILE:
+        filter = SkTileImageFilter::Make(make_rect(), make_rect(), make_image_filter(false));
         break;
-    }
     case PICTURE: {
         SkRTreeFactory factory;
         SkPictureRecorder recorder;
diff --git a/src/effects/SkTileImageFilter.cpp b/src/effects/SkTileImageFilter.cpp
index 9711eedfd5..c098bc2955 100644
--- a/src/effects/SkTileImageFilter.cpp
+++ b/src/effects/SkTileImageFilter.cpp
@@ -20,23 +20,23 @@
 #include "SkValidationUtils.h"
 #include "SkWriteBuffer.h"
 
-SkImageFilter* SkTileImageFilter::Create(const SkRect& srcRect, const SkRect& dstRect,
-                                         SkImageFilter* input) {
+sk_sp<SkImageFilter> SkTileImageFilter::Make(const SkRect& srcRect, const SkRect& dstRect,
+                                             sk_sp<SkImageFilter> input) {
     if (!SkIsValidRect(srcRect) || !SkIsValidRect(dstRect)) {
         return nullptr;
     }
     if (srcRect.width() == dstRect.width() && srcRect.height() == dstRect.height()) {
         SkRect ir = dstRect;
         if (!ir.intersect(srcRect)) {
-            return SkSafeRef(input);
+            return input;
         }
         CropRect cropRect(ir);
         return SkOffsetImageFilter::Make(dstRect.x() - srcRect.x(),
                                          dstRect.y() - srcRect.y(),
-                                         sk_ref_sp<SkImageFilter>(input),
-                                         &cropRect).release();
+                                         std::move(input),
+                                         &cropRect);
     }
-    return new SkTileImageFilter(srcRect, dstRect, input);
+    return sk_sp<SkImageFilter>(new SkTileImageFilter(srcRect, dstRect, std::move(input)));
 }
 
 sk_sp<SkSpecialImage> SkTileImageFilter::onFilterImage(SkSpecialImage* source,
@@ -143,7 +143,7 @@ sk_sp<SkFlattenable> SkTileImageFilter::CreateProc(SkReadBuffer& buffer) {
     SkRect src, dst;
     buffer.readRect(&src);
     buffer.readRect(&dst);
-    return sk_sp<SkFlattenable>(Create(src, dst, common.getInput(0).get()));
+    return Make(src, dst, common.getInput(0));
 }
 
 void SkTileImageFilter::flatten(SkWriteBuffer& buffer) const {
diff --git a/tests/ImageFilterTest.cpp b/tests/ImageFilterTest.cpp
index 172f84fa77..e92fef50d1 100644
--- a/tests/ImageFilterTest.cpp
+++ b/tests/ImageFilterTest.cpp
@@ -222,10 +222,10 @@ public:
                                                   cropRect));
         this->addFilter("dilate", SkDilateImageFilter::Make(3, 2, input, cropRect));
         this->addFilter("erode", SkErodeImageFilter::Make(2, 3, input, cropRect));
-        this->addFilter("tile", sk_sp<SkImageFilter>(SkTileImageFilter::Create(
-            SkRect::MakeXYWH(0, 0, 50, 50),
-            cropRect ? cropRect->rect() : SkRect::MakeXYWH(0, 0, 100, 100),
-            input.get())));
+        this->addFilter("tile", SkTileImageFilter::Make(
+                                    SkRect::MakeXYWH(0, 0, 50, 50),
+                                    cropRect ? cropRect->rect() : SkRect::MakeXYWH(0, 0, 100, 100),
+                                    input));
 
         if (!cropRect) {
             SkMatrix matrix;