move setshader to sk_sp, re-using SK_SUPPORT_LEGACY_CREATESHADER_PTR

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

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

33 files changed, 128 insertions, 140 deletions

diff --git a/bench/PDFBench.cpp b/bench/PDFBench.cpp
index 289588a01b..076f175b72 100644
--- a/bench/PDFBench.cpp
+++ b/bench/PDFBench.cpp
@@ -186,7 +186,7 @@ struct PDFShaderBench : public Benchmark {
             SkPDFDocument doc(&nullStream, nullptr, 72, nullptr);
             sk_sp<SkPDFObject> shader(
                     SkPDFShader::GetPDFShader(
-                            &doc, 72, *fShader, SkMatrix::I(),
+                            &doc, 72, fShader.get(), SkMatrix::I(),
                             SkIRect::MakeWH(400,400), 72));
         }
     }
diff --git a/bench/PerlinNoiseBench.cpp b/bench/PerlinNoiseBench.cpp
index 7c4894d434..6c98374bc3 100644
--- a/bench/PerlinNoiseBench.cpp
+++ b/bench/PerlinNoiseBench.cpp
@@ -41,13 +41,13 @@ private:
     void test(int loops, SkCanvas* canvas, int x, int y, SkPerlinNoiseShader::Type type,
               float baseFrequencyX, float baseFrequencyY, int numOctaves, float seed,
               bool stitchTiles) {
-        SkShader* shader = (type == SkPerlinNoiseShader::kFractalNoise_Type) ?
-            SkPerlinNoiseShader::CreateFractalNoise(baseFrequencyX, baseFrequencyY, numOctaves,
-                                                    seed, stitchTiles ? &fSize : nullptr) :
-            SkPerlinNoiseShader::CreateTurbulence(baseFrequencyX, baseFrequencyY, numOctaves,
-                                                 seed, stitchTiles ? &fSize : nullptr);
+        sk_sp<SkShader> shader = (type == SkPerlinNoiseShader::kFractalNoise_Type) ?
+            SkPerlinNoiseShader::MakeFractalNoise(baseFrequencyX, baseFrequencyY, numOctaves,
+                                                  seed, stitchTiles ? &fSize : nullptr) :
+            SkPerlinNoiseShader::MakeTurbulence(baseFrequencyX, baseFrequencyY, numOctaves,
+                                                seed, stitchTiles ? &fSize : nullptr);
         SkPaint paint;
-        paint.setShader(shader)->unref();
+        paint.setShader(shader);
 
         for (int i = 0; i < loops; i++) {
             this->drawClippedRect(canvas, x, y, paint);
diff --git a/bench/ShaderMaskBench.cpp b/bench/ShaderMaskBench.cpp
index eb77cbfa20..90a5037f05 100644
--- a/bench/ShaderMaskBench.cpp
+++ b/bench/ShaderMaskBench.cpp
@@ -1,13 +1,12 @@
-
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
+
 #include "Benchmark.h"
 #include "SkCanvas.h"
-#include "SkColorShader.h"
 #include "SkPaint.h"
 #include "SkRandom.h"
 #include "SkString.h"
@@ -43,7 +42,7 @@ public:
 
         fPaint.setAntiAlias(kBW != fq);
         fPaint.setLCDRenderText(kLCD == fq);
-        fPaint.setShader(new SkColorShader(isOpaque ? 0xFFFFFFFF : 0x80808080))->unref();
+        fPaint.setShader(SkShader::MakeColorShader(isOpaque ? 0xFFFFFFFF : 0x80808080));
     }
 
 protected:
diff --git a/gm/dcshader.cpp b/gm/dcshader.cpp
index 4dedf74093..ed2b058e51 100644
--- a/gm/dcshader.cpp
+++ b/gm/dcshader.cpp
@@ -257,7 +257,7 @@ protected:
             for (int i = 0; i < fPrims.count(); ++i) {
                 for (int j = 0; j < devMats.count(); ++j) {
                     for (int k = 0; k < viewMats.count(); ++k) {
-                        paint.setShader(new DCShader(devMats[j]))->unref();
+                        paint.setShader(sk_make_sp<DCShader>(devMats[j]));
                         paint.setAntiAlias(SkToBool(aa));
                         canvas->save();
                         canvas->concat(viewMats[k]);
diff --git a/gm/discard.cpp b/gm/discard.cpp
index d75f0ab141..136458170e 100644
--- a/gm/discard.cpp
+++ b/gm/discard.cpp
@@ -7,7 +7,6 @@
 
 #include "gm.h"
 #include "SkCanvas.h"
-#include "SkColorShader.h"
 #include "SkPaint.h"
 #include "SkRandom.h"
 #include "SkSurface.h"
@@ -66,9 +65,8 @@ protected:
                       surface->getCanvas()->clear(color);
                       break;
                   case 2:
-                      SkColorShader shader(color);
                       SkPaint paint;
-                      paint.setShader(&shader);
+                      paint.setShader(SkShader::MakeColorShader(color));
                       surface->getCanvas()->drawPaint(paint);
                       break;
               }
diff --git a/gm/image.cpp b/gm/image.cpp
index 8cc3023edf..c86be079d9 100644
--- a/gm/image.cpp
+++ b/gm/image.cpp
@@ -76,8 +76,8 @@ static void test_surface(SkCanvas* canvas, SkSurface* surf, bool usePaint) {
 //    paint.setFilterBitmap(true);
 //    paint.setAlpha(0x80);
 
-    canvas->drawImage(imgR.get(), 0, 0, usePaint ? &paint : nullptr);
-    canvas->drawImage(imgG.get(), 0, 80, usePaint ? &paint : nullptr);
+    canvas->drawImage(imgR, 0, 0, usePaint ? &paint : nullptr);
+    canvas->drawImage(imgG, 0, 80, usePaint ? &paint : nullptr);
     surf->draw(canvas, 0, 160, usePaint ? &paint : nullptr);
 
     SkRect src1, src2, src3;
@@ -92,10 +92,10 @@ static void test_surface(SkCanvas* canvas, SkSurface* surf, bool usePaint) {
     dst3.set(0, 400, 65, 465);
     dst4.set(0, 480, 65, 545);
 
-    canvas->drawImageRect(imgR.get(), src1, dst1, usePaint ? &paint : nullptr);
-    canvas->drawImageRect(imgG.get(), src2, dst2, usePaint ? &paint : nullptr);
-    canvas->drawImageRect(imgR.get(), src3, dst3, usePaint ? &paint : nullptr);
-    canvas->drawImageRect(imgG.get(), dst4, usePaint ? &paint : nullptr);
+    canvas->drawImageRect(imgR, src1, dst1, usePaint ? &paint : nullptr);
+    canvas->drawImageRect(imgG, src2, dst2, usePaint ? &paint : nullptr);
+    canvas->drawImageRect(imgR, src3, dst3, usePaint ? &paint : nullptr);
+    canvas->drawImageRect(imgG, dst4, usePaint ? &paint : nullptr);
 }
 
 class ImageGM : public skiagm::GM {
diff --git a/gm/imagefiltersclipped.cpp b/gm/imagefiltersclipped.cpp
index 01b0a43fcb..7c75bf3951 100644
--- a/gm/imagefiltersclipped.cpp
+++ b/gm/imagefiltersclipped.cpp
@@ -90,7 +90,7 @@ protected:
 
         SkAutoTUnref<SkImageFilter> gradient(SkImageSource::Create(fGradientCircle.get()));
         SkAutoTUnref<SkImageFilter> checkerboard(SkImageSource::Create(fCheckerboard.get()));
-        SkAutoTUnref<SkShader> noise(SkPerlinNoiseShader::CreateFractalNoise(
+        sk_sp<SkShader> noise(SkPerlinNoiseShader::MakeFractalNoise(
             SkDoubleToScalar(0.1), SkDoubleToScalar(0.05), 1, 0));
         SkMatrix resizeMatrix;
         resizeMatrix.setScale(RESIZE_FACTOR_X, RESIZE_FACTOR_Y);
diff --git a/gm/imagefiltersscaled.cpp b/gm/imagefiltersscaled.cpp
index 9c0150001c..21d070456b 100644
--- a/gm/imagefiltersscaled.cpp
+++ b/gm/imagefiltersscaled.cpp
@@ -54,7 +54,7 @@ protected:
 
         SkAutoTUnref<SkImageFilter> gradient(SkImageSource::Create(fGradientCircle.get()));
         SkAutoTUnref<SkImageFilter> checkerboard(SkImageSource::Create(fCheckerboard.get()));
-        SkAutoTUnref<SkShader> noise(SkPerlinNoiseShader::CreateFractalNoise(
+        sk_sp<SkShader> noise(SkPerlinNoiseShader::MakeFractalNoise(
             SkDoubleToScalar(0.1), SkDoubleToScalar(0.05), 1, 0));
         SkPaint noisePaint;
         noisePaint.setShader(noise);
diff --git a/gm/lightingshader.cpp b/gm/lightingshader.cpp
index 9c45c9b783..6d25671ac2 100644
--- a/gm/lightingshader.cpp
+++ b/gm/lightingshader.cpp
@@ -98,14 +98,9 @@ protected:
         // TODO: correctly pull out the pure rotation
         SkVector invNormRotation = { ctm[SkMatrix::kMScaleX], ctm[SkMatrix::kMSkewY] };
 
-        SkAutoTUnref<SkShader> fShader(SkLightingShader::Create(
-                                                        fDiffuse,
-                                                        fNormalMaps[mapType],
-                                                        fLights,
-                                                        invNormRotation, &matrix, &matrix));
-
         SkPaint paint;
-        paint.setShader(fShader);
+        paint.setShader(SkLightingShader::Make(fDiffuse, fNormalMaps[mapType], fLights,
+                                               invNormRotation, &matrix, &matrix));
 
         canvas->drawRect(r, paint);
     }
diff --git a/gm/perlinnoise.cpp b/gm/perlinnoise.cpp
index 92f0f963c3..b3ece9dcb6 100644
--- a/gm/perlinnoise.cpp
+++ b/gm/perlinnoise.cpp
@@ -37,13 +37,13 @@ protected:
               float baseFrequencyX, float baseFrequencyY, int numOctaves, float seed,
               bool stitchTiles) {
         SkISize tileSize = SkISize::Make(fSize.width() / 2, fSize.height() / 2);
-        SkShader* shader = (type == SkPerlinNoiseShader::kFractalNoise_Type) ?
-            SkPerlinNoiseShader::CreateFractalNoise(baseFrequencyX, baseFrequencyY, numOctaves,
-                                                   seed, stitchTiles ? &tileSize : nullptr) :
-            SkPerlinNoiseShader::CreateTurbulence(baseFrequencyX, baseFrequencyY, numOctaves,
+        sk_sp<SkShader> shader = (type == SkPerlinNoiseShader::kFractalNoise_Type) ?
+            SkPerlinNoiseShader::MakeFractalNoise(baseFrequencyX, baseFrequencyY, numOctaves,
+                                                  seed, stitchTiles ? &tileSize : nullptr) :
+            SkPerlinNoiseShader::MakeTurbulence(baseFrequencyX, baseFrequencyY, numOctaves,
                                                 seed, stitchTiles ? &tileSize : nullptr);
         SkPaint paint;
-        paint.setShader(shader)->unref();
+        paint.setShader(std::move(shader));
         if (stitchTiles) {
             drawRect(canvas, x, y, paint, tileSize);
             x += tileSize.width();
@@ -110,12 +110,12 @@ protected:
     void install(SkPaint* paint, SkPerlinNoiseShader::Type type,
               float baseFrequencyX, float baseFrequencyY, int numOctaves, float seed,
               bool stitchTiles) {
-        SkShader* shader = (type == SkPerlinNoiseShader::kFractalNoise_Type) ?
-        SkPerlinNoiseShader::CreateFractalNoise(baseFrequencyX, baseFrequencyY, numOctaves,
-                                                seed, stitchTiles ? &fSize : nullptr) :
-        SkPerlinNoiseShader::CreateTurbulence(baseFrequencyX, baseFrequencyY, numOctaves,
-                                              seed, stitchTiles ? &fSize : nullptr);
-        paint->setShader(shader)->unref();
+        sk_sp<SkShader> shader = (type == SkPerlinNoiseShader::kFractalNoise_Type) ?
+            SkPerlinNoiseShader::MakeFractalNoise(baseFrequencyX, baseFrequencyY, numOctaves,
+                                                  seed, stitchTiles ? &fSize : nullptr) :
+            SkPerlinNoiseShader::MakeTurbulence(baseFrequencyX, baseFrequencyY, numOctaves,
+                                                seed, stitchTiles ? &fSize : nullptr);
+        paint->setShader(std::move(shader));
     }
 
     virtual void onDraw(SkCanvas* canvas) {
diff --git a/gm/pictureshader.cpp b/gm/pictureshader.cpp
index 0916744c69..d54144f938 100644
--- a/gm/pictureshader.cpp
+++ b/gm/pictureshader.cpp
@@ -194,9 +194,6 @@ DEF_SIMPLE_GM(tiled_picture_shader, canvas, 400, 400) {
     c->drawLine(20, 20, 80, 80, p);
 
     sk_sp<SkPicture> picture(recorder.finishRecordingAsPicture());
-    sk_sp<SkShader> shader(SkShader::MakePictureShader(picture, SkShader::kRepeat_TileMode,
-                                                       SkShader::kRepeat_TileMode,
-                                                       nullptr, nullptr));
 
     p.setColor(sk_tool_utils::color_to_565(0xFF8BC34A));  // green
     canvas->drawPaint(p);
@@ -204,7 +201,9 @@ DEF_SIMPLE_GM(tiled_picture_shader, canvas, 400, 400) {
     canvas->clipRect(SkRect::MakeXYWH(0, 0, 400, 350));
     p.setColor(sk_tool_utils::color_to_565(0xFFB6B6B6));  // gray
     canvas->drawPaint(p);
-    p.setShader(shader.get());
 
+    p.setShader(SkShader::MakePictureShader(std::move(picture), SkShader::kRepeat_TileMode,
+                                            SkShader::kRepeat_TileMode,
+                                            nullptr, nullptr));
     canvas->drawPaint(p);
 }
diff --git a/gm/samplerstress.cpp b/gm/samplerstress.cpp
index f317cf9103..10e3cacd03 100644
--- a/gm/samplerstress.cpp
+++ b/gm/samplerstress.cpp
@@ -95,7 +95,7 @@ protected:
         SkPaint paint;
         paint.setAntiAlias(true);
         paint.setTextSize(72);
-        paint.setShader(fShader.get());
+        paint.setShader(fShader);
         paint.setMaskFilter(fMaskFilter.get());
         sk_tool_utils::set_portable_typeface(&paint);
 
diff --git a/include/core/SkPaint.h b/include/core/SkPaint.h
index 21d7109cbb..cb9f810280 100644
--- a/include/core/SkPaint.h
+++ b/include/core/SkPaint.h
@@ -499,8 +499,10 @@ public:
      *  @param shader   May be NULL. The shader to be installed in the paint
      *  @return         shader
      */
-    SkShader* setShader(SkShader* shader);
     void setShader(sk_sp<SkShader>);
+#ifdef SK_SUPPORT_LEGACY_CREATESHADER_PTR
+    SkShader* setShader(SkShader* shader);
+#endif
 
     /** Get the paint's colorfilter. If there is a colorfilter, its reference
         count is not changed.
diff --git a/include/effects/SkPerlinNoiseShader.h b/include/effects/SkPerlinNoiseShader.h
index d9b0277f92..d652e5dcad 100644
--- a/include/effects/SkPerlinNoiseShader.h
+++ b/include/effects/SkPerlinNoiseShader.h
@@ -55,21 +55,30 @@ public:
      *  the frequencies so that the noise will be tileable for the given tile size. If tileSize
      *  is NULL or an empty size, the frequencies will be used as is without modification.
      */
+    static sk_sp<SkShader> MakeFractalNoise(SkScalar baseFrequencyX, SkScalar baseFrequencyY,
+                                            int numOctaves, SkScalar seed,
+                                            const SkISize* tileSize = nullptr);
+    static sk_sp<SkShader> MakeTurbulence(SkScalar baseFrequencyX, SkScalar baseFrequencyY,
+                                          int numOctaves, SkScalar seed,
+                                          const SkISize* tileSize = nullptr);
+
+#ifdef SK_SUPPORT_LEGACY_CREATESHADER_PTR
     static SkShader* CreateFractalNoise(SkScalar baseFrequencyX, SkScalar baseFrequencyY,
                                         int numOctaves, SkScalar seed,
-                                        const SkISize* tileSize = NULL);
+                                        const SkISize* tileSize = NULL) {
+        return MakeFractalNoise(baseFrequencyX, baseFrequencyY, numOctaves, seed, tileSize).release();
+    }
     static SkShader* CreateTurbulence(SkScalar baseFrequencyX, SkScalar baseFrequencyY,
-                                     int numOctaves, SkScalar seed,
-                                     const SkISize* tileSize = NULL);
-    /**
-     * Create alias for CreateTurbulunce until all Skia users changed
-     * its code to use the new naming
-     */
+                                      int numOctaves, SkScalar seed,
+                                      const SkISize* tileSize = NULL) {
+        return MakeTurbulence(baseFrequencyX, baseFrequencyY, numOctaves, seed, tileSize).release();
+    }
     static SkShader* CreateTubulence(SkScalar baseFrequencyX, SkScalar baseFrequencyY,
                                      int numOctaves, SkScalar seed,
                                      const SkISize* tileSize = NULL) {
         return CreateTurbulence(baseFrequencyX, baseFrequencyY, numOctaves, seed, tileSize);
     }
+#endif
 
     class PerlinNoiseShaderContext : public SkShader::Context {
     public:
diff --git a/samplecode/SampleCamera.cpp b/samplecode/SampleCamera.cpp
index ed6cc52829..85b854eced 100644
--- a/samplecode/SampleCamera.cpp
+++ b/samplecode/SampleCamera.cpp
@@ -20,7 +20,7 @@
 #include "SkRandom.h"
 
 class CameraView : public SampleView {
-    SkTDArray<SkShader*> fShaders;
+    SkTArray<sk_sp<SkShader>> fShaders;
     int     fShaderIndex;
     bool    fFrontFace;
 public:
@@ -39,11 +39,10 @@ public:
                 SkMatrix matrix;
                 matrix.setRectToRect(src, dst, SkMatrix::kFill_ScaleToFit);
 
-                SkShader* s = SkShader::MakeBitmapShader(bm,
+                fShaders.push_back(SkShader::MakeBitmapShader(bm,
                                                            SkShader::kClamp_TileMode,
                                                            SkShader::kClamp_TileMode,
-                                                           &matrix).release();
-                *fShaders.append() = s;
+                                                           &matrix));
             } else {
                 break;
             }
@@ -51,10 +50,6 @@ public:
         this->setBGColor(0xFFDDDDDD);
     }
 
-    virtual ~CameraView() {
-        fShaders.unrefAll();
-    }
-
 protected:
     // overrides from SkEventSink
     bool onQuery(SkEvent* evt) override {
diff --git a/samplecode/SampleEmboss.cpp b/samplecode/SampleEmboss.cpp
index 6e33e05e79..215a1e07d2 100644
--- a/samplecode/SampleEmboss.cpp
+++ b/samplecode/SampleEmboss.cpp
@@ -9,7 +9,6 @@
 #include "SkBlurMask.h"
 #include "SkView.h"
 #include "SkCanvas.h"
-#include "SkColorShader.h"
 #include "SkEmbossMaskFilter.h"
 #include "SkGradientShader.h"
 #include "SkGraphics.h"
@@ -53,7 +52,7 @@ protected:
         paint.setStrokeWidth(SkIntToScalar(10));
         paint.setMaskFilter(SkEmbossMaskFilter::Create(
             SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(4)), fLight))->unref();
-        paint.setShader(new SkColorShader(SK_ColorBLUE))->unref();
+        paint.setShader(SkShader::MakeColorShader(SK_ColorBLUE));
         paint.setDither(true);
 
         canvas->drawCircle(SkIntToScalar(50), SkIntToScalar(50),
diff --git a/samplecode/SampleFilterFuzz.cpp b/samplecode/SampleFilterFuzz.cpp
index 82934ea3cc..dd72d1237c 100644
--- a/samplecode/SampleFilterFuzz.cpp
+++ b/samplecode/SampleFilterFuzz.cpp
@@ -648,10 +648,10 @@ static SkImageFilter* make_image_filter(bool canBeNull) {
         break;
     case NOISE:
     {
-        SkAutoTUnref<SkShader> shader((R(2) == 1) ?
-            SkPerlinNoiseShader::CreateFractalNoise(
+        sk_sp<SkShader> shader((R(2) == 1) ?
+            SkPerlinNoiseShader::MakeFractalNoise(
                 make_scalar(true), make_scalar(true), R(10.0f), make_scalar()) :
-            SkPerlinNoiseShader::CreateTurbulence(
+            SkPerlinNoiseShader::MakeTurbulence(
                 make_scalar(true), make_scalar(true), R(10.0f), make_scalar()));
         SkPaint paint;
         paint.setShader(shader);
diff --git a/samplecode/SampleLighting.cpp b/samplecode/SampleLighting.cpp
index fa88e3ecd6..1da888f5bd 100755
--- a/samplecode/SampleLighting.cpp
+++ b/samplecode/SampleLighting.cpp
@@ -31,11 +31,10 @@ static const SkLightingShader::Lights* create_lights(SkScalar angle, SkScalar bl
 
 class LightingView : public SampleView {
 public:
-    SkAutoTUnref<SkShader> fShader;
-    SkBitmap               fDiffuseBitmap;
-    SkBitmap               fNormalBitmap;
-    SkScalar               fLightAngle;
-    SkScalar               fColorFactor;
+    SkBitmap        fDiffuseBitmap;
+    SkBitmap        fNormalBitmap;
+    SkScalar        fLightAngle;
+    SkScalar        fColorFactor;
 
     LightingView() {
         SkString diffusePath = GetResourcePath("brickwork-texture.jpg");
@@ -45,16 +44,8 @@ public:
 
         fLightAngle = 0.0f;
         fColorFactor = 0.0f;
-
-        SkAutoTUnref<const SkLightingShader::Lights> lights(create_lights(fLightAngle, 1.0f));
-
-        fShader.reset(SkLightingShader::Create(fDiffuseBitmap, fNormalBitmap,
-                                               lights, SkVector::Make(1.0f, 0.0f),
-                                               nullptr, nullptr));
     }
 
-    virtual ~LightingView() {}
-
 protected:
     // overrides from SkEventSink
     bool onQuery(SkEvent* evt) override {
@@ -74,13 +65,10 @@ protected:
 
         SkAutoTUnref<const SkLightingShader::Lights> lights(create_lights(fLightAngle,
                                                                           fColorFactor));
-
-        fShader.reset(SkLightingShader::Create(fDiffuseBitmap, fNormalBitmap,
+        SkPaint paint;
+        paint.setShader(SkLightingShader::Make(fDiffuseBitmap, fNormalBitmap,
                                                lights, SkVector::Make(1.0f, 0.0f),
                                                nullptr, nullptr));
-
-        SkPaint paint;
-        paint.setShader(fShader);
         paint.setColor(SK_ColorBLACK);
 
         SkRect r = SkRect::MakeWH((SkScalar)fDiffuseBitmap.width(), 
diff --git a/src/animator/SkDrawPaint.cpp b/src/animator/SkDrawPaint.cpp
index 5f6efd8cc9..fc1a413244 100644
--- a/src/animator/SkDrawPaint.cpp
+++ b/src/animator/SkDrawPaint.cpp
@@ -237,7 +237,7 @@ void SkDrawPaint::setupPaint(SkPaint* paint) const {
     if (shader == nullptr)
         paint->setShader(nullptr);
     else if (shader != (SkDrawShader*) -1)
-        SkSafeUnref(paint->setShader(shader->getShader()));
+        paint->setShader(sk_ref_sp(shader->getShader()));
     if (strikeThru != -1)
         paint->setStrikeThruText(SkToBool(strikeThru));
     if (strokeCap != -1)
diff --git a/src/c/sk_paint.cpp b/src/c/sk_paint.cpp
index dd0733f02e..b48e28fb6d 100644
--- a/src/c/sk_paint.cpp
+++ b/src/c/sk_paint.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "SkPaint.h"
+#include "SkShader.h"
 
 #include "sk_paint.h"
 #include "sk_types_priv.h"
@@ -63,7 +64,7 @@ void sk_paint_set_color(sk_paint_t* cpaint, sk_color_t c) {
 }
 
 void sk_paint_set_shader(sk_paint_t* cpaint, sk_shader_t* cshader) {
-    AsPaint(cpaint)->setShader(AsShader(cshader));
+    AsPaint(cpaint)->setShader(sk_ref_sp(AsShader(cshader)));
 }
 
 void sk_paint_set_maskfilter(sk_paint_t* cpaint, sk_maskfilter_t* cfilter) {
diff --git a/src/core/SkBlitter.cpp b/src/core/SkBlitter.cpp
index 15562168e9..d8e81d59b8 100644
--- a/src/core/SkBlitter.cpp
+++ b/src/core/SkBlitter.cpp
@@ -809,16 +809,16 @@ SkBlitter* SkBlitter::Choose(const SkPixmap& device,
     SkShader* shader = origPaint.getShader();
     SkColorFilter* cf = origPaint.getColorFilter();
     SkXfermode* mode = origPaint.getXfermode();
-    Sk3DShader* shader3D = nullptr;
+    sk_sp<Sk3DShader> shader3D;
 
     SkTCopyOnFirstWrite<SkPaint> paint(origPaint);
 
     if (origPaint.getMaskFilter() != nullptr &&
             origPaint.getMaskFilter()->getFormat() == SkMask::k3D_Format) {
-        shader3D = new Sk3DShader(sk_sp<SkShader>(SkSafeRef(shader)));
+        shader3D = sk_make_sp<Sk3DShader>(sk_ref_sp(shader));
         // we know we haven't initialized lazyPaint yet, so just do it
-        paint.writable()->setShader(shader3D)->unref();
-        shader = shader3D;
+        paint.writable()->setShader(shader3D);
+        shader = shader3D.get();
     }
 
     if (mode) {
@@ -843,7 +843,8 @@ SkBlitter* SkBlitter::Choose(const SkPixmap& device,
      */
     if (SkXfermode::IsMode(mode, SkXfermode::kClear_Mode)) {
         SkPaint* p = paint.writable();
-        shader = p->setShader(nullptr);
+        p->setShader(nullptr);
+        shader = nullptr;
         p->setColorFilter(nullptr);
         cf = nullptr;
         mode = p->setXfermodeMode(SkXfermode::kSrc_Mode);
@@ -853,9 +854,9 @@ SkBlitter* SkBlitter::Choose(const SkPixmap& device,
     if (nullptr == shader) {
         if (mode) {
             // xfermodes (and filters) require shaders for our current blitters
-            shader = new SkColorShader(paint->getColor());
-            paint.writable()->setShader(shader)->unref();
+            paint.writable()->setShader(SkShader::MakeColorShader(paint->getColor()));
             paint.writable()->setAlpha(0xFF);
+            shader = paint->getShader();
         } else if (cf) {
             // if no shader && no xfermode, we just apply the colorfilter to
             // our color and move on.
diff --git a/src/core/SkLightingShader.cpp b/src/core/SkLightingShader.cpp
index 02f75f3516..d8e88c9a0a 100644
--- a/src/core/SkLightingShader.cpp
+++ b/src/core/SkLightingShader.cpp
@@ -700,10 +700,10 @@ static bool bitmap_is_too_big(const SkBitmap& bm) {
     return bm.width() > kMaxSize || bm.height() > kMaxSize;
 }
 
-SkShader* SkLightingShader::Create(const SkBitmap& diffuse, const SkBitmap& normal,
-                                   const Lights* lights,
-                                   const SkVector& invNormRotation,
-                                   const SkMatrix* diffLocalM, const SkMatrix* normLocalM) {
+sk_sp<SkShader> SkLightingShader::Make(const SkBitmap& diffuse, const SkBitmap& normal,
+                                       const Lights* lights,
+                                       const SkVector& invNormRotation,
+                                       const SkMatrix* diffLocalM, const SkMatrix* normLocalM) {
     if (diffuse.isNull() || bitmap_is_too_big(diffuse) ||
         normal.isNull() || bitmap_is_too_big(normal) ||
         diffuse.width() != normal.width() ||
@@ -713,8 +713,8 @@ SkShader* SkLightingShader::Create(const SkBitmap& diffuse, const SkBitmap& norm
 
     SkASSERT(SkScalarNearlyEqual(invNormRotation.lengthSqd(), SK_Scalar1));
 
-    return new SkLightingShaderImpl(diffuse, normal, lights, invNormRotation, diffLocalM,
-                                    normLocalM);
+    return sk_make_sp<SkLightingShaderImpl>(diffuse, normal, lights, invNormRotation, diffLocalM,
+                                            normLocalM);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
diff --git a/src/core/SkLightingShader.h b/src/core/SkLightingShader.h
index e918f3b05f..30ce6559c5 100644
--- a/src/core/SkLightingShader.h
+++ b/src/core/SkLightingShader.h
@@ -1,4 +1,3 @@
-
 /*
  * Copyright 2015 Google Inc.
  *
@@ -6,7 +5,6 @@
  * found in the LICENSE file.
  */
 
-
 #ifndef SkLightingShader_DEFINED
 #define SkLightingShader_DEFINED
 
@@ -90,9 +88,9 @@ public:
         The +Z axis is thus encoded in RGB as (127, 127, 255) while the -Z axis is
         (127, 127, 0).
     */
-    static SkShader* Create(const SkBitmap& diffuse, const SkBitmap& normal,
-                            const Lights* lights, const SkVector& invNormRotation,
-                            const SkMatrix* diffLocalMatrix, const SkMatrix* normLocalMatrix);
+    static sk_sp<SkShader> Make(const SkBitmap& diffuse, const SkBitmap& normal,
+                                const Lights* lights, const SkVector& invNormRotation,
+                                const SkMatrix* diffLocalMatrix, const SkMatrix* normLocalMatrix);
 
     SK_DECLARE_FLATTENABLE_REGISTRAR_GROUP()
 };
diff --git a/src/core/SkPaint.cpp b/src/core/SkPaint.cpp
index 2ced3f6bef..6a54b9a6c3 100644
--- a/src/core/SkPaint.cpp
+++ b/src/core/SkPaint.cpp
@@ -374,7 +374,9 @@ SET_PTR(Typeface)
 SET_PTR(Rasterizer)
 #endif
 SET_PTR(ImageFilter)
+#ifdef SK_SUPPORT_LEGACY_CREATESHADER_PTR
 SET_PTR(Shader)
+#endif
 #ifdef SK_SUPPORT_LEGACY_COLORFILTER_PTR
 SET_PTR(ColorFilter)
 #endif
diff --git a/src/effects/SkLayerDrawLooper.cpp b/src/effects/SkLayerDrawLooper.cpp
index 8510767801..526fb4d7e3 100644
--- a/src/effects/SkLayerDrawLooper.cpp
+++ b/src/effects/SkLayerDrawLooper.cpp
@@ -99,7 +99,7 @@ void SkLayerDrawLooper::LayerDrawLooperContext::ApplyInfo(
         dst->setMaskFilter(src.getMaskFilter());
     }
     if (bits & kShader_Bit) {
-        dst->setShader(src.getShader());
+        dst->setShader(sk_ref_sp(src.getShader()));
     }
     if (bits & kColorFilter_Bit) {
         dst->setColorFilter(sk_ref_sp(src.getColorFilter()));
diff --git a/src/effects/SkPerlinNoiseShader.cpp b/src/effects/SkPerlinNoiseShader.cpp
index ef528751dd..72b7e0280d 100644
--- a/src/effects/SkPerlinNoiseShader.cpp
+++ b/src/effects/SkPerlinNoiseShader.cpp
@@ -249,18 +249,21 @@ public:
 #endif
 };
 
-SkShader* SkPerlinNoiseShader::CreateFractalNoise(SkScalar baseFrequencyX, SkScalar baseFrequencyY,
-                                                  int numOctaves, SkScalar seed,
-                                                  const SkISize* tileSize) {
-    return new SkPerlinNoiseShader(kFractalNoise_Type, baseFrequencyX, baseFrequencyY, numOctaves,
-                                   seed, tileSize);
+sk_sp<SkShader> SkPerlinNoiseShader::MakeFractalNoise(SkScalar baseFrequencyX,
+                                                      SkScalar baseFrequencyY,
+                                                      int numOctaves, SkScalar seed,
+                                                      const SkISize* tileSize) {
+    return sk_sp<SkShader>(new SkPerlinNoiseShader(kFractalNoise_Type, baseFrequencyX,
+                                                   baseFrequencyY, numOctaves,
+                                                   seed, tileSize));
 }
 
-SkShader* SkPerlinNoiseShader::CreateTurbulence(SkScalar baseFrequencyX, SkScalar baseFrequencyY,
-                                              int numOctaves, SkScalar seed,
-                                              const SkISize* tileSize) {
-    return new SkPerlinNoiseShader(kTurbulence_Type, baseFrequencyX, baseFrequencyY, numOctaves,
-                                   seed, tileSize);
+sk_sp<SkShader> SkPerlinNoiseShader::MakeTurbulence(SkScalar baseFrequencyX,
+                                                    SkScalar baseFrequencyY,
+                                                    int numOctaves, SkScalar seed,
+                                                    const SkISize* tileSize) {
+    return sk_sp<SkShader>(new SkPerlinNoiseShader(kTurbulence_Type, baseFrequencyX, baseFrequencyY,
+                                                   numOctaves, seed, tileSize));
 }
 
 SkPerlinNoiseShader::SkPerlinNoiseShader(SkPerlinNoiseShader::Type type,
@@ -295,9 +298,11 @@ SkFlattenable* SkPerlinNoiseShader::CreateProc(SkReadBuffer& buffer) {
 
     switch (type) {
         case kFractalNoise_Type:
-            return SkPerlinNoiseShader::CreateFractalNoise(freqX, freqY, octaves, seed, &tileSize);
+            return SkPerlinNoiseShader::MakeFractalNoise(freqX, freqY, octaves, seed,
+                                                         &tileSize).release();
         case kTurbulence_Type:
-            return SkPerlinNoiseShader::CreateTubulence(freqX, freqY, octaves, seed, &tileSize);
+            return SkPerlinNoiseShader::MakeTurbulence(freqX, freqY, octaves, seed,
+                                                       &tileSize).release();
         default:
             return nullptr;
     }
@@ -580,11 +585,11 @@ const GrFragmentProcessor* GrPerlinNoiseEffect::TestCreate(GrProcessorTestData*
     SkScalar baseFrequencyY = d->fRandom->nextRangeScalar(0.01f,
                                                           0.99f);
 
-    SkAutoTUnref<SkShader> shader(d->fRandom->nextBool() ?
-        SkPerlinNoiseShader::CreateFractalNoise(baseFrequencyX, baseFrequencyY, numOctaves, seed,
-                                                stitchTiles ? &tileSize : nullptr) :
-        SkPerlinNoiseShader::CreateTurbulence(baseFrequencyX, baseFrequencyY, numOctaves, seed,
-                                             stitchTiles ? &tileSize : nullptr));
+    sk_sp<SkShader> shader(d->fRandom->nextBool() ?
+        SkPerlinNoiseShader::MakeFractalNoise(baseFrequencyX, baseFrequencyY, numOctaves, seed,
+                                              stitchTiles ? &tileSize : nullptr) :
+        SkPerlinNoiseShader::MakeTurbulence(baseFrequencyX, baseFrequencyY, numOctaves, seed,
+                                            stitchTiles ? &tileSize : nullptr));
 
     return shader->asFragmentProcessor(d->fContext,
                                        GrTest::TestMatrix(d->fRandom), nullptr,
diff --git a/src/pdf/SkPDFDevice.cpp b/src/pdf/SkPDFDevice.cpp
index 0054143a9a..b6a5b519e8 100644
--- a/src/pdf/SkPDFDevice.cpp
+++ b/src/pdf/SkPDFDevice.cpp
@@ -1983,7 +1983,7 @@ void SkPDFDevice::populateGraphicStateEntryFromPaint(
 
     // PDF treats a shader as a color, so we only set one or the other.
     sk_sp<SkPDFObject> pdfShader;
-    const SkShader* shader = paint.getShader();
+    SkShader* shader = paint.getShader();
     SkColor color = paint.getColor();
     if (shader) {
         // PDF positions patterns relative to the initial transform, so
@@ -2005,7 +2005,7 @@ void SkPDFDevice::populateGraphicStateEntryFromPaint(
         SkScalar rasterScale =
                 SkIntToScalar(fRasterDpi) / DPI_FOR_RASTER_SCALE_ONE;
         pdfShader.reset(SkPDFShader::GetPDFShader(
-                fDocument, fRasterDpi, *shader, transform, bounds, rasterScale));
+                fDocument, fRasterDpi, shader, transform, bounds, rasterScale));
 
         if (pdfShader.get()) {
             // pdfShader has been canonicalized so we can directly compare
diff --git a/src/pdf/SkPDFShader.cpp b/src/pdf/SkPDFShader.cpp
index 7fb1f899f1..eaac84921c 100644
--- a/src/pdf/SkPDFShader.cpp
+++ b/src/pdf/SkPDFShader.cpp
@@ -434,7 +434,7 @@ public:
     uint32_t fPixelGeneration;
     SkShader::TileMode fImageTileModes[2];
 
-    State(const SkShader& shader, const SkMatrix& canvasTransform,
+    State(SkShader* shader, const SkMatrix& canvasTransform,
           const SkIRect& bbox, SkScalar rasterScale);
 
     bool operator==(const State& b) const;
@@ -515,7 +515,7 @@ static SkPDFObject* get_pdf_shader_by_state(
 // static
 SkPDFObject* SkPDFShader::GetPDFShader(SkPDFDocument* doc,
                                        SkScalar dpi,
-                                       const SkShader& shader,
+                                       SkShader* shader,
                                        const SkMatrix& matrix,
                                        const SkIRect& surfaceBBox,
                                        SkScalar rasterScale) {
@@ -1091,7 +1091,7 @@ bool SkPDFShader::State::operator==(const SkPDFShader::State& b) const {
     return true;
 }
 
-SkPDFShader::State::State(const SkShader& shader, const SkMatrix& canvasTransform,
+SkPDFShader::State::State(SkShader* shader, const SkMatrix& canvasTransform,
                           const SkIRect& bbox, SkScalar rasterScale)
         : fCanvasTransform(canvasTransform),
           fBBox(bbox),
@@ -1099,14 +1099,14 @@ SkPDFShader::State::State(const SkShader& shader, const SkMatrix& canvasTransfor
     fInfo.fColorCount = 0;
     fInfo.fColors = nullptr;
     fInfo.fColorOffsets = nullptr;
-    fShaderTransform = shader.getLocalMatrix();
+    fShaderTransform = shader->getLocalMatrix();
     fImageTileModes[0] = fImageTileModes[1] = SkShader::kClamp_TileMode;
 
-    fType = shader.asAGradient(&fInfo);
+    fType = shader->asAGradient(&fInfo);
 
     if (fType == SkShader::kNone_GradientType) {
         SkMatrix matrix;
-        if (shader.isABitmap(&fImage, &matrix, fImageTileModes)) {
+        if (shader->isABitmap(&fImage, &matrix, fImageTileModes)) {
             SkASSERT(matrix.isIdentity());
         } else {
             // Generic fallback for unsupported shaders:
@@ -1139,7 +1139,7 @@ SkPDFShader::State::State(const SkShader& shader, const SkMatrix& canvasTransfor
             fImage.eraseColor(SK_ColorTRANSPARENT);
 
             SkPaint p;
-            p.setShader(const_cast<SkShader*>(&shader));
+            p.setShader(sk_ref_sp(shader));
 
             SkCanvas canvas(fImage);
             canvas.scale(scale.width(), scale.height());
@@ -1152,7 +1152,7 @@ SkPDFShader::State::State(const SkShader& shader, const SkMatrix& canvasTransfor
         fPixelGeneration = fImage.getGenerationID();
     } else {
         AllocateGradientInfoStorage();
-        shader.asAGradient(&fInfo);
+        shader->asAGradient(&fInfo);
     }
 }
 
diff --git a/src/pdf/SkPDFShader.h b/src/pdf/SkPDFShader.h
index a646aef75c..999dc02070 100644
--- a/src/pdf/SkPDFShader.h
+++ b/src/pdf/SkPDFShader.h
@@ -45,7 +45,7 @@ public:
      */
     static SkPDFObject* GetPDFShader(SkPDFDocument* doc,
                                      SkScalar dpi,
-                                     const SkShader& shader,
+                                     SkShader* shader,
                                      const SkMatrix& matrix,
                                      const SkIRect& surfaceBBox,
                                      SkScalar rasterScale);
diff --git a/src/utils/SkLua.cpp b/src/utils/SkLua.cpp
index c25bbf4409..01bf507f17 100644
--- a/src/utils/SkLua.cpp
+++ b/src/utils/SkLua.cpp
@@ -1146,7 +1146,7 @@ static int lpaint_getShader(lua_State* L) {
 
 static int lpaint_setShader(lua_State* L) {
     SkPaint* paint = get_obj<SkPaint>(L, 1);
-    paint->setShader(get_ref<SkShader>(L, 2));
+    paint->setShader(sk_ref_sp(get_ref<SkShader>(L, 2)));
     return 0;
 }
 
diff --git a/tests/ImageFilterTest.cpp b/tests/ImageFilterTest.cpp
index 89f5061f53..4375aac8cd 100644
--- a/tests/ImageFilterTest.cpp
+++ b/tests/ImageFilterTest.cpp
@@ -135,8 +135,7 @@ public:
         recordingCanvas->drawRect(SkRect::Make(SkIRect::MakeXYWH(10, 10, 30, 20)), greenPaint);
         sk_sp<SkPicture> picture(recorder.finishRecordingAsPicture());
         SkAutoTUnref<SkImageFilter> pictureFilter(SkPictureImageFilter::Create(picture.get()));
-        SkAutoTUnref<SkShader> shader(SkPerlinNoiseShader::CreateTurbulence(
-            SK_Scalar1, SK_Scalar1, 1, 0));
+        sk_sp<SkShader> shader(SkPerlinNoiseShader::MakeTurbulence(SK_Scalar1, SK_Scalar1, 1, 0));
 
         SkPaint paint;
         paint.setShader(shader);
diff --git a/tools/VisualBench/VisualBenchmarkStream.cpp b/tools/VisualBench/VisualBenchmarkStream.cpp
index b15ac7e8f1..56780f8f99 100644
--- a/tools/VisualBench/VisualBenchmarkStream.cpp
+++ b/tools/VisualBench/VisualBenchmarkStream.cpp
@@ -56,8 +56,7 @@ private:
         paint.setStrokeWidth(2);
 
         SkPaint perlinPaint;
-        perlinPaint.setShader(SkPerlinNoiseShader::CreateTurbulence(0.1f, 0.1f, 1, 0,
-                                                                    nullptr))->unref();
+        perlinPaint.setShader(SkPerlinNoiseShader::MakeTurbulence(0.1f, 0.1f, 1, 0, nullptr));
         for (int i = 0; i < loops; i++) {
             canvas->drawPath(fPath, paint);
             canvas->drawRect(fPerlinRect, perlinPaint);
diff --git a/tools/debugger/SkDrawCommand.cpp b/tools/debugger/SkDrawCommand.cpp
index 5dc6079897..af1270c9e5 100644
--- a/tools/debugger/SkDrawCommand.cpp
+++ b/tools/debugger/SkDrawCommand.cpp
@@ -1125,8 +1125,7 @@ static void extract_json_paint_shader(Json::Value& jsonPaint, UrlDataManager& ur
         Json::Value jsonShader = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_SHADER];
         SkShader* shader = (SkShader*) load_flattenable(jsonShader, urlDataManager);
         if (shader != nullptr) {
-            target->setShader(shader);
-            shader->unref();
+            target->setShader(sk_ref_sp(shader));
         }
     }
 }