SkImage now has makeShader to return sk_sp

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

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

17 files changed, 57 insertions, 52 deletions

diff --git a/bench/SkLinearBitmapPipelineBench.cpp b/bench/SkLinearBitmapPipelineBench.cpp
index 660245ebef..0c60eed302 100644
--- a/bench/SkLinearBitmapPipelineBench.cpp
+++ b/bench/SkLinearBitmapPipelineBench.cpp
@@ -176,13 +176,12 @@ struct SkBitmapFPOrigShader : public CommonBitmapFPBenchmark {
         SkImage* image = SkImage::NewRasterCopy(
             fInfo, fBitmap.get(), sizeof(SkPMColor) * fSrcSize.fWidth);
         fImage.reset(image);
-        SkShader* shader = fImage->newShader(fXTile, fYTile);
+        fPaint.setShader(fImage->makeShader(fXTile, fYTile));
         if (fUseBilerp) {
             fPaint.setFilterQuality(SkFilterQuality::kLow_SkFilterQuality);
         } else {
             fPaint.setFilterQuality(SkFilterQuality::kNone_SkFilterQuality);
         }
-        fPaint.setShader(shader)->unref();
     }
 
     void onPostDraw(SkCanvas*) override {
diff --git a/gm/SkLinearBitmapPipelineGM.cpp b/gm/SkLinearBitmapPipelineGM.cpp
index d3a143c5c1..e93d2ac4c3 100644
--- a/gm/SkLinearBitmapPipelineGM.cpp
+++ b/gm/SkLinearBitmapPipelineGM.cpp
@@ -61,13 +61,12 @@ static void draw_rect_orig(SkCanvas* canvas, const SkRect& r, SkColor c, const S
         info, pmsrc.addr32(), pmsrc.rowBytes())};
     SkPaint paint;
     int32_t storage[300];
-    SkShader* shader = image->newShader(SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
+    paint.setShader(image->makeShader(SkShader::kClamp_TileMode, SkShader::kClamp_TileMode));
     if (useBilerp) {
         paint.setFilterQuality(SkFilterQuality::kLow_SkFilterQuality);
     } else {
         paint.setFilterQuality(SkFilterQuality::kNone_SkFilterQuality);
     }
-    paint.setShader(shader)->unref();
     const SkShader::ContextRec rec(paint, *mat, nullptr,
                                    SkBlitter::PreferredShaderDest(pmsrc.info()));
     SkASSERT(paint.getShader()->contextSize(rec) <= sizeof(storage));
diff --git a/gm/colorfilterimagefilter.cpp b/gm/colorfilterimagefilter.cpp
index 4ab91f1afb..b0f67bff30 100644
--- a/gm/colorfilterimagefilter.cpp
+++ b/gm/colorfilterimagefilter.cpp
@@ -70,8 +70,7 @@ static sk_sp<SkShader> sh_make_image() {
     if (!image) {
         return nullptr;
     }
-    return sk_sp<SkShader>(image->newShader(SkShader::kRepeat_TileMode,
-                                            SkShader::kRepeat_TileMode));
+    return image->makeShader(SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode);
 }
 
 static void sk_gm_get_shaders(SkTDArray<SkShader*>* array) {
diff --git a/gm/image_shader.cpp b/gm/image_shader.cpp
index 084bb95a1a..7ea0202296 100644
--- a/gm/image_shader.cpp
+++ b/gm/image_shader.cpp
@@ -101,10 +101,9 @@ protected:
 
         const SkShader::TileMode tile = SkShader::kRepeat_TileMode;
         const SkMatrix localM = SkMatrix::MakeTrans(-50, -50);
-        SkAutoTUnref<SkShader> shader(image->newShader(tile, tile, &localM));
         SkPaint paint;
+        paint.setShader(image->makeShader(tile, tile, &localM));
         paint.setAntiAlias(true);
-        paint.setShader(shader);
         canvas->drawCircle(50, 50, 50, paint);
     }
 
diff --git a/gm/rectangletexture.cpp b/gm/rectangletexture.cpp
index 0889063a1f..20f2ead593 100644
--- a/gm/rectangletexture.cpp
+++ b/gm/rectangletexture.cpp
@@ -164,15 +164,15 @@ protected:
 
                     SkPaint clampPaint;
                     clampPaint.setFilterQuality(q);
-                    clampPaint.setShader(rectImg->newShader(SkShader::kClamp_TileMode,
-                                                            SkShader::kClamp_TileMode))->unref();
+                    clampPaint.setShader(rectImg->makeShader(SkShader::kClamp_TileMode,
+                                                             SkShader::kClamp_TileMode));
                     canvas->drawRect(SkRect::MakeWH(1.5f * kWidth, 1.5f * kHeight), clampPaint);
                     canvas->translate(kWidth * 1.5f + kPad, 0);
 
                     SkPaint repeatPaint;
                     repeatPaint.setFilterQuality(q);
-                    repeatPaint.setShader(rectImg->newShader(SkShader::kRepeat_TileMode,
-                                                             SkShader::kMirror_TileMode))->unref();
+                    repeatPaint.setShader(rectImg->makeShader(SkShader::kRepeat_TileMode,
+                                                              SkShader::kMirror_TileMode));
                     canvas->drawRect(SkRect::MakeWH(1.5f * kWidth, 1.5f * kHeight), repeatPaint);
                     canvas->translate(1.5f * kWidth + kPad, 0);
             }
diff --git a/include/core/SkImage.h b/include/core/SkImage.h
index c920c54016..832ff9dea1 100644
--- a/include/core/SkImage.h
+++ b/include/core/SkImage.h
@@ -163,9 +163,13 @@ public:
     bool readYUV8Planes(const SkISize[3], void* const planes[3], const size_t rowBytes[3],
                         SkYUVColorSpace) const;
 
-    virtual SkShader* newShader(SkShader::TileMode,
-                                SkShader::TileMode,
-                                const SkMatrix* localMatrix = NULL) const;
+#ifdef SK_SUPPORT_LEGACY_CREATESHADER_PTR
+    SkShader* newShader(SkShader::TileMode, SkShader::TileMode,
+                        const SkMatrix* localMatrix = nullptr) const;
+#endif
+
+    sk_sp<SkShader> makeShader(SkShader::TileMode, SkShader::TileMode,
+                               const SkMatrix* localMatrix = nullptr) const;
 
     /**
      *  If the image has direct access to its pixels (i.e. they are in local RAM)
diff --git a/samplecode/SampleFilterQuality.cpp b/samplecode/SampleFilterQuality.cpp
index c37fcae457..27c092fc47 100644
--- a/samplecode/SampleFilterQuality.cpp
+++ b/samplecode/SampleFilterQuality.cpp
@@ -27,7 +27,7 @@ static SkSurface* make_surface(SkCanvas* canvas, const SkImageInfo& info) {
     return surface;
 }
 
-static SkShader* make_shader(const SkRect& bounds) {
+static sk_sp<SkShader> make_shader(const SkRect& bounds) {
 #if 0
     const SkPoint pts[] = {
         { bounds.left(), bounds.top() },
@@ -45,7 +45,7 @@ static SkShader* make_shader(const SkRect& bounds) {
     if (nullptr == image) {
         return nullptr;
     }
-    return image->newShader(SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
+    return image->makeShader(SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
 #endif
 }
 
@@ -67,7 +67,7 @@ static SkImage* make_image() {
     path.moveTo(0, 0); path.lineTo(N, 0); path.lineTo(0, N); path.close();
 
     SkPaint paint;
-    SkSafeUnref(paint.setShader(make_shader(SkRect::MakeWH(N, N))));
+    paint.setShader(make_shader(SkRect::MakeWH(N, N)));
     
     canvas->drawPath(path, paint);
     return surface->newImageSnapshot();
diff --git a/src/core/SkDevice.cpp b/src/core/SkDevice.cpp
index fa4a4b8fd1..aff15515d4 100644
--- a/src/core/SkDevice.cpp
+++ b/src/core/SkDevice.cpp
@@ -198,13 +198,13 @@ void SkBaseDevice::drawAtlas(const SkDraw& draw, const SkImage* atlas, const SkR
         localM.preTranslate(-tex[i].left(), -tex[i].top());
 
         SkPaint pnt(paint);
-        SkAutoTUnref<SkShader> shader(atlas->newShader(SkShader::kClamp_TileMode,
-                                                       SkShader::kClamp_TileMode,
-                                                       &localM));
+        sk_sp<SkShader> shader = atlas->makeShader(SkShader::kClamp_TileMode,
+                                                   SkShader::kClamp_TileMode,
+                                                   &localM);
         if (!shader) {
             break;
         }
-        pnt.setShader(shader);
+        pnt.setShader(std::move(shader));
 
         if (colors) {
             SkAutoTUnref<SkColorFilter> cf(SkColorFilter::CreateModeFilter(colors[i], mode));
diff --git a/src/core/SkPictureShader.cpp b/src/core/SkPictureShader.cpp
index a6644aacba..c2a0b74e23 100644
--- a/src/core/SkPictureShader.cpp
+++ b/src/core/SkPictureShader.cpp
@@ -231,7 +231,7 @@ sk_sp<SkShader> SkPictureShader::refBitmapShader(const SkMatrix& viewMatrix, con
 
         SkMatrix shaderMatrix = this->getLocalMatrix();
         shaderMatrix.preScale(1 / tileScale.width(), 1 / tileScale.height());
-        tileShader.reset(tileImage->newShader(fTmx, fTmy, &shaderMatrix));
+        tileShader = tileImage->makeShader(fTmx, fTmy, &shaderMatrix);
 
         const SkImageInfo tileInfo = SkImageInfo::MakeN32Premul(tileSize);
         SkResourceCache::Add(new BitmapShaderRec(key, tileShader.get(),
diff --git a/src/gpu/SkGpuDevice.cpp b/src/gpu/SkGpuDevice.cpp
index a7bf82e6f0..7a6d967538 100644
--- a/src/gpu/SkGpuDevice.cpp
+++ b/src/gpu/SkGpuDevice.cpp
@@ -1678,7 +1678,7 @@ void SkGpuDevice::drawAtlas(const SkDraw& draw, const SkImage* atlas, const SkRS
     GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "drawText", fContext);
 
     SkPaint p(paint);
-    p.setShader(atlas->newShader(SkShader::kClamp_TileMode, SkShader::kClamp_TileMode))->unref();
+    p.setShader(atlas->makeShader(SkShader::kClamp_TileMode, SkShader::kClamp_TileMode));
 
     GrPaint grPaint;
     if (colors) {
diff --git a/src/image/SkImage.cpp b/src/image/SkImage.cpp
index 5e7cb07226..a41ac83d19 100644
--- a/src/image/SkImage.cpp
+++ b/src/image/SkImage.cpp
@@ -103,11 +103,17 @@ void SkImage::preroll(GrContext* ctx) const {
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-SkShader* SkImage::newShader(SkShader::TileMode tileX,
-                             SkShader::TileMode tileY,
+sk_sp<SkShader> SkImage::makeShader(SkShader::TileMode tileX, SkShader::TileMode tileY,
+                                    const SkMatrix* localMatrix) const {
+    return SkImageShader::Make(this, tileX, tileY, localMatrix);
+}
+
+#ifdef SK_SUPPORT_LEGACY_CREATESHADER_PTR
+SkShader* SkImage::newShader(SkShader::TileMode tileX, SkShader::TileMode tileY,
                              const SkMatrix* localMatrix) const {
-    return SkImageShader::Create(this, tileX, tileY, localMatrix);
+    return this->makeShader(tileX, tileY, localMatrix).release();
 }
+#endif
 
 SkData* SkImage::encode(SkImageEncoder::Type type, int quality) const {
     SkBitmap bm;
diff --git a/src/image/SkImageShader.cpp b/src/image/SkImageShader.cpp
index b1bb3ab8f8..00c038ab88 100644
--- a/src/image/SkImageShader.cpp
+++ b/src/image/SkImageShader.cpp
@@ -28,7 +28,7 @@ SkFlattenable* SkImageShader::CreateProc(SkReadBuffer& buffer) {
     if (!img) {
         return nullptr;
     }
-    return new SkImageShader(img, tx, ty, &matrix);
+    return SkImageShader::Make(img, tx, ty, &matrix).release();
 }
 
 void SkImageShader::flatten(SkWriteBuffer& buffer) const {
@@ -51,12 +51,12 @@ SkShader::Context* SkImageShader::onCreateContext(const ContextRec& rec, void* s
                                            SkBitmapProvider(fImage), rec, storage);
 }
 
-SkShader* SkImageShader::Create(const SkImage* image, TileMode tx, TileMode ty,
-                                const SkMatrix* localMatrix) {
+sk_sp<SkShader> SkImageShader::Make(const SkImage* image, TileMode tx, TileMode ty,
+                                    const SkMatrix* localMatrix) {
     if (!image) {
         return nullptr;
     }
-    return new SkImageShader(image, tx, ty, localMatrix);
+    return sk_sp<SkShader>(new SkImageShader(image, tx, ty, localMatrix));
 }
 
 #ifndef SK_IGNORE_TO_STRING
diff --git a/src/image/SkImageShader.h b/src/image/SkImageShader.h
index 07b938d202..f466e618a0 100644
--- a/src/image/SkImageShader.h
+++ b/src/image/SkImageShader.h
@@ -13,7 +13,8 @@
 
 class SkImageShader : public SkShader {
 public:
-    static SkShader* Create(const SkImage*, TileMode tx, TileMode ty, const SkMatrix* localMatrix);
+    static sk_sp<SkShader> Make(const SkImage*, TileMode tx, TileMode ty,
+                                const SkMatrix* localMatrix);
 
     bool isOpaque() const override;
 
diff --git a/src/utils/SkLua.cpp b/src/utils/SkLua.cpp
index b84ba0f518..95ca5adc07 100644
--- a/src/utils/SkLua.cpp
+++ b/src/utils/SkLua.cpp
@@ -1711,8 +1711,7 @@ static int limage_height(lua_State* L) {
 static int limage_newShader(lua_State* L) {
     SkShader::TileMode tmode = SkShader::kClamp_TileMode;
     const SkMatrix* localM = nullptr;
-    SkAutoTUnref<SkShader> shader(get_ref<SkImage>(L, 1)->newShader(tmode, tmode, localM));
-    push_ref(L, shader.get());
+    push_ref(L, get_ref<SkImage>(L, 1)->makeShader(tmode, tmode, localM));
     return 1;
 }
 
diff --git a/tests/FlattenableFactoryToName.cpp b/tests/FlattenableFactoryToName.cpp
index f8cb4fa2f9..c8f4a62e82 100644
--- a/tests/FlattenableFactoryToName.cpp
+++ b/tests/FlattenableFactoryToName.cpp
@@ -36,7 +36,6 @@ DEF_TEST(FlattenableFactoryToName, r) {
     bm.allocN32Pixels(8, 8);
     bm.eraseColor(SK_ColorCYAN);
     SkAutoTUnref<SkImage> image(SkImage::NewFromBitmap(bm));
-    SkAutoTUnref<SkShader> shader(image->newShader(SkShader::kClamp_TileMode,
-                                                   SkShader::kClamp_TileMode));
-    test_flattenable(r, shader, "SkImage::newShader()");
+    auto shader = image->makeShader(SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
+    test_flattenable(r, shader.get(), "SkImage::newShader()");
 }
diff --git a/tests/ImageNewShaderTest.cpp b/tests/ImageNewShaderTest.cpp
index 7b7d80e477..0822dbd054 100644
--- a/tests/ImageNewShaderTest.cpp
+++ b/tests/ImageNewShaderTest.cpp
@@ -45,9 +45,9 @@ void runShaderTest(skiatest::Reporter* reporter, SkSurface* sourceSurface, SkSur
     paintSource(sourceSurface);
 
     SkAutoTUnref<SkImage> sourceImage(sourceSurface->newImageSnapshot());
-    SkAutoTUnref<SkShader> sourceShader(sourceImage->newShader(
+    sk_sp<SkShader> sourceShader = sourceImage->makeShader(
             SkShader::kRepeat_TileMode,
-            SkShader::kRepeat_TileMode));
+            SkShader::kRepeat_TileMode);
 
     SkPaint paint;
     paint.setShader(sourceShader);
@@ -73,10 +73,10 @@ void runShaderTest(skiatest::Reporter* reporter, SkSurface* sourceSurface, SkSur
     SkMatrix matrix;
     matrix.setTranslate(SkIntToScalar(-1), SkIntToScalar(0));
 
-    SkAutoTUnref<SkShader> sourceShaderTranslated(sourceImage->newShader(
+    sk_sp<SkShader> sourceShaderTranslated = sourceImage->makeShader(
             SkShader::kRepeat_TileMode,
             SkShader::kRepeat_TileMode,
-            &matrix));
+            &matrix);
 
     destinationCanvas->clear(SK_ColorTRANSPARENT);
 
diff --git a/tests/SkColor4fTest.cpp b/tests/SkColor4fTest.cpp
index ec40000dbb..62eed211df 100644
--- a/tests/SkColor4fTest.cpp
+++ b/tests/SkColor4fTest.cpp
@@ -98,9 +98,9 @@ static SkColorFilter* make_compose_cf() {
     return SkColorFilter::CreateComposeFilter(cf0, cf1);
 }
 
-static SkShader* make_color_sh() { return SkShader::CreateColorShader(0xFFBB8855); }
+static sk_sp<SkShader> make_color_sh() { return SkShader::MakeColorShader(0xFFBB8855); }
 
-static SkShader* make_image_sh() {
+static sk_sp<SkShader> make_image_sh() {
     const SkImageInfo info = SkImageInfo::MakeN32Premul(2, 2);
     const SkPMColor pixels[] {
         SkPackARGB32(0xFF, 0xBB, 0x88, 0x55),
@@ -109,10 +109,10 @@ static SkShader* make_image_sh() {
         SkPackARGB32(0xFF, 0xBB, 0x88, 0x55),
     };
     SkAutoTUnref<SkImage> image(SkImage::NewRasterCopy(info, pixels, sizeof(SkPMColor) * 2));
-    return image->newShader(SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
+    return image->makeShader(SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
 }
 
-static SkShader* make_grad_sh() {
+static sk_sp<SkShader> make_grad_sh() {
 #if 0
     const SkPoint pts[] {{ 0, 0 }, { 100, 100 }};
     const SkColor colors[] { SK_ColorRED, SK_ColorBLUE };
@@ -123,10 +123,10 @@ static SkShader* make_grad_sh() {
 #endif
 }
 
-static SkShader* make_cf_sh() {
+static sk_sp<SkShader> make_cf_sh() {
     SkAutoTUnref<SkColorFilter> filter(make_mx_cf());
-    SkAutoTUnref<SkShader> shader(make_color_sh());
-    return shader->newWithColorFilter(filter);
+    sk_sp<SkShader> shader(make_color_sh());
+    return sk_sp<SkShader>(shader->newWithColorFilter(filter));
 }
 
 static bool compare_spans(const SkPM4f span4f[], const SkPMColor span4b[], int count,
@@ -143,9 +143,9 @@ static bool compare_spans(const SkPM4f span4f[], const SkPMColor span4b[], int c
 
 DEF_TEST(Color4f_shader, reporter) {
     struct {
-        SkShader* (*fFact)();
-        bool      fSupports4f;
-        float     fTolerance;
+        sk_sp<SkShader> (*fFact)();
+        bool            fSupports4f;
+        float           fTolerance;
     } recs[] = {
         { make_color_sh, true,  1.0f/255   },
         // PMColor 4f gradients are interpolated in 255-multiplied values, so we need a
@@ -158,7 +158,7 @@ DEF_TEST(Color4f_shader, reporter) {
     SkPaint paint;
     for (const auto& rec : recs) {
         uint32_t storage[300];
-        paint.setShader(rec.fFact())->unref();
+        paint.setShader(rec.fFact());
         // Encourage 4f context selection. At some point we may need
         // to instantiate two separate contexts for optimal 4b/4f selection.
         const SkShader::ContextRec contextRec(paint, SkMatrix::I(), nullptr,