use Make instead of Create to return a shared shader

Partially updated call sites. Undefine the flag in SkSHader.h to convert the remaining sites.

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

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

29 files changed, 154 insertions, 226 deletions

diff --git a/samplecode/PerlinPatch.cpp b/samplecode/PerlinPatch.cpp
index de4d451648..ad2d6bede0 100644
--- a/samplecode/PerlinPatch.cpp
+++ b/samplecode/PerlinPatch.cpp
@@ -60,9 +60,9 @@ const SkScalar TexWidth = 100.0f;
 const SkScalar TexHeight = 100.0f;
 
 class PerlinPatchView : public SampleView {
-    SkShader* fShader0;    
-    SkShader* fShader1;    
-    SkShader* fShaderCompose;    
+    sk_sp<SkShader> fShader0;
+    sk_sp<SkShader> fShader1;
+    sk_sp<SkShader> fShaderCompose;
     SkScalar fXFreq;
     SkScalar fYFreq;
     SkScalar fSeed;
@@ -98,7 +98,7 @@ public:
         };
         const SkPoint points[2] = { SkPoint::Make(0.0f, 0.0f),
                                     SkPoint::Make(100.0f, 100.0f) };
-        fShader0 = SkGradientShader::CreateLinear(points,
+        fShader0 = SkGradientShader::MakeLinear(points,
                                                   colors,
                                                   NULL,
                                                   3,
@@ -107,9 +107,6 @@ public:
                                                   NULL);
     }
 
-    virtual ~PerlinPatchView() {
-        SkSafeUnref(fShader0);
-    }
 protected:
     // overrides from SkEventSink
     bool onQuery(SkEvent* evt)  override {
@@ -145,16 +142,14 @@ protected:
         SkAutoTUnref<SkXfermode> xfer(SkXfermode::Create(SkXfermode::kSrc_Mode));
 
         SkScalar scaleFreq = 2.0;
-        fShader1 = SkPerlinNoiseShader2::CreateImprovedNoise(fXFreq/scaleFreq, fYFreq/scaleFreq, 4,
+        fShader1 = SkPerlinNoiseShader2::MakeImprovedNoise(fXFreq/scaleFreq, fYFreq/scaleFreq, 4,
                                                              fSeed);
-        fShaderCompose = SkShader::CreateComposeShader(fShader0, fShader1, nullptr);
+        fShaderCompose = SkShader::MakeComposeShader(fShader0, fShader1, nullptr);
 
         paint.setShader(fShaderCompose);
         canvas->drawPatch(fPts, nullptr, texCoords, xfer, paint);
 
         draw_control_points(canvas, fPts);
-        SkSafeUnref(fShader1);
-        SkSafeUnref(fShaderCompose);
     }
 
     class PtClick : public Click {
diff --git a/samplecode/Sample2PtRadial.cpp b/samplecode/Sample2PtRadial.cpp
index 07efd0a41c..c32025e9cb 100644
--- a/samplecode/Sample2PtRadial.cpp
+++ b/samplecode/Sample2PtRadial.cpp
@@ -33,12 +33,10 @@ protected:
         SkScalar r0 = 100;
         SkPoint c1 = { 100, 100 };
         SkScalar r1 = 100;
-        SkShader* s = SkGradientShader::CreateTwoPointConical(c0, r0, c1, r1, colors,
-                                                             nullptr, 2,
-                                                             SkShader::kClamp_TileMode);
-
         SkPaint paint;
-        paint.setShader(s)->unref();
+        paint.setShader(SkGradientShader::MakeTwoPointConical(c0, r0, c1, r1, colors,
+                                                             nullptr, 2,
+                                                             SkShader::kClamp_TileMode));
         canvas->drawPaint(paint);
     }
 
diff --git a/samplecode/SampleAARectModes.cpp b/samplecode/SampleAARectModes.cpp
index ae28925a42..43392235c9 100644
--- a/samplecode/SampleAARectModes.cpp
+++ b/samplecode/SampleAARectModes.cpp
@@ -61,7 +61,7 @@ static SkScalar drawCell(SkCanvas* canvas, SkXfermode* mode,
     return H;
 }
 
-static SkShader* make_bg_shader() {
+static sk_sp<SkShader> make_bg_shader() {
     SkBitmap bm;
     bm.allocN32Pixels(2, 2);
     *bm.getAddr32(0, 0) = *bm.getAddr32(1, 1) = 0xFFFFFFFF;
@@ -71,17 +71,17 @@ static SkShader* make_bg_shader() {
     SkMatrix m;
     m.setScale(SkIntToScalar(6), SkIntToScalar(6));
 
-    return SkShader::CreateBitmapShader(bm,
-                                        SkShader::kRepeat_TileMode,
-                                        SkShader::kRepeat_TileMode,
-                                        &m);
+    return SkShader::MakeBitmapShader(bm,
+                                      SkShader::kRepeat_TileMode,
+                                      SkShader::kRepeat_TileMode,
+                                      &m);
 }
 
 class AARectsModesView : public SampleView {
     SkPaint fBGPaint;
 public:
     AARectsModesView () {
-        fBGPaint.setShader(make_bg_shader())->unref();
+        fBGPaint.setShader(make_bg_shader());
     }
 
 protected:
diff --git a/samplecode/SampleAARects.cpp b/samplecode/SampleAARects.cpp
index f552df6f15..d0c1115a1e 100644
--- a/samplecode/SampleAARects.cpp
+++ b/samplecode/SampleAARects.cpp
@@ -62,10 +62,8 @@ protected:
         SkPaint bluePaint;
         bluePaint.setARGB(0xff, 0x0, 0x0, 0xff);
         SkPaint bmpPaint;
-        SkShader* bmpShader = SkShader::CreateBitmapShader(fBitmap, SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode);
-        bmpPaint.setShader(bmpShader);
-        bmpShader->unref();
-
+        bmpPaint.setShader(SkShader::MakeBitmapShader(fBitmap, SkShader::kRepeat_TileMode,
+                                                      SkShader::kRepeat_TileMode));
         bluePaint.setStrokeWidth(3);
         bmpPaint.setStrokeWidth(3);
 
diff --git a/samplecode/SampleAll.cpp b/samplecode/SampleAll.cpp
index addca35fdc..48ac24da1c 100644
--- a/samplecode/SampleAll.cpp
+++ b/samplecode/SampleAll.cpp
@@ -361,7 +361,7 @@ protected:
         SkScalar* linearPos = nullptr;
         int linearCount = 2;
         SkShader::TileMode linearMode = SkShader::kMirror_TileMode;
-        SkShader* linear = SkGradientShader::CreateLinear(linearPoints,
+        auto linear = SkGradientShader::MakeLinear(linearPoints,
             linearColors, linearPos, linearCount, linearMode);
 
         SkPoint radialCenter = { SkIntToScalar(25), SkIntToScalar(25) };
@@ -370,7 +370,7 @@ protected:
         SkScalar radialPos[] = { 0, SkIntToScalar(3) / 5, SkIntToScalar(1)};
         int radialCount = 3;
         SkShader::TileMode radialMode = SkShader::kRepeat_TileMode;
-        SkShader* radial = SkGradientShader::CreateRadial(radialCenter,
+        auto radial = SkGradientShader::MakeRadial(radialCenter,
             radialRadius, radialColors, radialPos, radialCount,
             radialMode);
 
@@ -396,8 +396,8 @@ protected:
         paint.setStyle(SkPaint::kFill_Style);
         SkRect clip = {0, 0, SkIntToScalar(320), SkIntToScalar(120)};
         canvas->clipRect(clip);
-        paint.setShader(SkShader::CreateBitmapShader(fTx,
-            SkShader::kMirror_TileMode, SkShader::kRepeat_TileMode))->unref();
+        paint.setShader(SkShader::MakeBitmapShader(fTx,
+            SkShader::kMirror_TileMode, SkShader::kRepeat_TileMode));
         canvas->drawPaint(paint);
         canvas->save();
 
@@ -415,7 +415,7 @@ protected:
         paint.setStyle(SkPaint::kFill_Style);
         canvas->translate(SkIntToScalar(50), 0);
         paint.setColor(SK_ColorYELLOW);
-        paint.setShader(linear)->unref();
+        paint.setShader(linear);
         paint.setPathEffect(pathEffectTest())->unref();
         canvas->drawRect(rect, paint);
         paint.setPathEffect(nullptr);
@@ -434,7 +434,7 @@ protected:
         paint.setColor(SK_ColorRED);
         paint.setStyle(SkPaint::kStroke_Style);
         paint.setStrokeWidth(SkIntToScalar(5));
-        paint.setShader(radial)->unref();
+        paint.setShader(radial);
         paint.setMaskFilter(nullptr);
         canvas->drawPath(path, paint);
 
@@ -445,7 +445,7 @@ protected:
         canvas->drawBitmap(fBug, left, top, &paint);
 
         canvas->translate(-SkIntToScalar(30), SkIntToScalar(30));
-        paint.setShader(shaderTest())->unref(); // test compose shader
+        paint.setShader(shaderTest()); // test compose shader
         canvas->drawRect(rect2, paint);
         paint.setShader(nullptr);
 
@@ -500,21 +500,17 @@ protected:
         return result;
     }
 
-    SkShader* shaderTest() {
+    sk_sp<SkShader> shaderTest() {
         SkPoint pts[] = { { 0, 0, }, { SkIntToScalar(100), 0 } };
         SkColor colors[] = { SK_ColorRED, SK_ColorBLUE };
-        SkShader* shaderA = SkGradientShader::CreateLinear(pts, colors, nullptr,
+        auto shaderA = SkGradientShader::MakeLinear(pts, colors, nullptr,
             2, SkShader::kClamp_TileMode);
         pts[1].set(0, SkIntToScalar(100));
         SkColor colors2[] = {SK_ColorBLACK,  SkColorSetARGB(0x80, 0, 0, 0)};
-        SkShader* shaderB = SkGradientShader::CreateLinear(pts, colors2, nullptr,
+        auto shaderB = SkGradientShader::MakeLinear(pts, colors2, nullptr,
             2, SkShader::kClamp_TileMode);
-        SkXfermode* mode = SkXfermode::Create(SkXfermode::kDstIn_Mode);
-        SkShader* result = SkShader::CreateComposeShader(shaderA, shaderB, mode);
-        shaderA->unref();
-        shaderB->unref();
-        mode->unref();
-        return result;
+        SkAutoTUnref<SkXfermode> mode(SkXfermode::Create(SkXfermode::kDstIn_Mode));
+        return SkShader::MakeComposeShader(shaderA, shaderB, mode);
     }
 
     virtual void startTest() {
diff --git a/samplecode/SampleBigGradient.cpp b/samplecode/SampleBigGradient.cpp
index 0fa7969c7a..8ae099051b 100644
--- a/samplecode/SampleBigGradient.cpp
+++ b/samplecode/SampleBigGradient.cpp
@@ -1,20 +1,19 @@
-
 /*
  * 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 "SampleCode.h"
 #include "SkView.h"
 #include "SkCanvas.h"
 #include "SkGradientShader.h"
 
-static SkShader* make_grad(SkScalar w, SkScalar h) {
+static sk_sp<SkShader> make_grad(SkScalar w, SkScalar h) {
     SkColor colors[] = { 0xFF000000, 0xFF333333 };
     SkPoint pts[] = { { 0, 0 }, { w, h } };
-    return SkGradientShader::CreateLinear(pts, colors, nullptr, 2,
-                                          SkShader::kClamp_TileMode);
+    return SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode);
 }
 
 class BigGradientView : public SampleView {
@@ -22,8 +21,7 @@ public:
     BigGradientView() {}
 
 protected:
-    // overrides from SkEventSink
-    virtual bool onQuery(SkEvent* evt) {
+    bool onQuery(SkEvent* evt) override {
         if (SampleCode::TitleQ(*evt)) {
             SampleCode::TitleR(evt, "BigGradient");
             return true;
@@ -31,11 +29,11 @@ protected:
         return this->INHERITED::onQuery(evt);
     }
 
-    virtual void onDrawContent(SkCanvas* canvas) {
+    void onDrawContent(SkCanvas* canvas) override {
         SkRect r;
         r.set(0, 0, this->width(), this->height());
         SkPaint p;
-        p.setShader(make_grad(this->width(), this->height()))->unref();
+        p.setShader(make_grad(this->width(), this->height()));
         canvas->drawRect(r, p);
     }
 
diff --git a/samplecode/SampleBitmapRect.cpp b/samplecode/SampleBitmapRect.cpp
index d7eed02ef9..490c6a45c3 100644
--- a/samplecode/SampleBitmapRect.cpp
+++ b/samplecode/SampleBitmapRect.cpp
@@ -37,8 +37,8 @@ static void make_bitmap(SkBitmap* bitmap) {
     paint.setAntiAlias(true);
     const SkPoint pts[] = { { 0, 0 }, { SCALAR_SIZE, SCALAR_SIZE } };
     const SkColor colors[] = { SK_ColorWHITE, SK_ColorBLUE };
-    paint.setShader(SkGradientShader::CreateLinear(pts, colors, nullptr, 2,
-                                                   SkShader::kClamp_TileMode))->unref();
+    paint.setShader(SkGradientShader::MakeLinear(pts, colors, nullptr, 2,
+                                                   SkShader::kClamp_TileMode));
     canvas.drawCircle(SCALAR_SIZE/2, SCALAR_SIZE/2, SCALAR_SIZE/2, paint);
 }
 
diff --git a/samplecode/SampleCamera.cpp b/samplecode/SampleCamera.cpp
index 991013a850..b860917f3f 100644
--- a/samplecode/SampleCamera.cpp
+++ b/samplecode/SampleCamera.cpp
@@ -39,10 +39,10 @@ public:
                 SkMatrix matrix;
                 matrix.setRectToRect(src, dst, SkMatrix::kFill_ScaleToFit);
 
-                SkShader* s = SkShader::CreateBitmapShader(bm,
+                SkShader* s = SkShader::MakeBitmapShader(bm,
                                                            SkShader::kClamp_TileMode,
                                                            SkShader::kClamp_TileMode,
-                                                           &matrix);
+                                                           &matrix).release();
                 *fShaders.append() = s;
             } else {
                 break;
diff --git a/samplecode/SampleColorFilter.cpp b/samplecode/SampleColorFilter.cpp
index af1cd935a2..4ee8949410 100644
--- a/samplecode/SampleColorFilter.cpp
+++ b/samplecode/SampleColorFilter.cpp
@@ -111,7 +111,7 @@ static SkBitmap createBitmap(int n) {
 
 class ColorFilterView : public SampleView {
     SkBitmap fBitmap;
-    SkShader* fShader;
+    sk_sp<SkShader> fShader;
     enum {
         N = 64
     };
@@ -126,10 +126,6 @@ public:
         }
     }
 
-    virtual ~ColorFilterView() {
-        fShader->unref();
-    }
-
 protected:
     // overrides from SkEventSink
     virtual bool onQuery(SkEvent* evt) {
diff --git a/samplecode/SampleDegenerateTwoPtRadials.cpp b/samplecode/SampleDegenerateTwoPtRadials.cpp
index 32b45374e6..f171202249 100644
--- a/samplecode/SampleDegenerateTwoPtRadials.cpp
+++ b/samplecode/SampleDegenerateTwoPtRadials.cpp
@@ -27,12 +27,10 @@ static void draw_gradient2(SkCanvas* canvas, const SkRect& rect, SkScalar delta)
     SkPoint c1 = { l + 3 * w / 5, t + h / 2 };
     SkScalar r0 = w / 5;
     SkScalar r1 = 2 * w / 5;
-    SkShader* s = SkGradientShader::CreateTwoPointConical(c0, r0, c1, r1, colors,
-                                                         pos, SK_ARRAY_COUNT(pos),
-                                                         SkShader::kClamp_TileMode);
     SkPaint paint;
-    paint.setShader(s)->unref();
-
+    paint.setShader(SkGradientShader::MakeTwoPointConical(c0, r0, c1, r1, colors,
+                                                          pos, SK_ARRAY_COUNT(pos),
+                                                          SkShader::kClamp_TileMode));
     canvas->drawRect(rect, paint);
 }
 
diff --git a/samplecode/SampleDither.cpp b/samplecode/SampleDither.cpp
index 8c14fb5110..a599418723 100644
--- a/samplecode/SampleDither.cpp
+++ b/samplecode/SampleDither.cpp
@@ -34,9 +34,8 @@ static void draw_sweep(SkCanvas* c, int width, int height, SkScalar angle) {
 
     //    SkColor colors[] = { SK_ColorRED, SK_ColorBLUE, SK_ColorGREEN, SK_ColorCYAN };
     SkColor colors[] = { 0x4c737373, 0x4c737373, 0xffffd300 };
-    SkShader* s = SkGradientShader::CreateSweep(r.centerX(), r.centerY(),
-                                                colors, nullptr, SK_ARRAY_COUNT(colors));
-    p.setShader(s)->unref();
+    p.setShader(SkGradientShader::MakeSweep(r.centerX(), r.centerY(),
+                                            colors, nullptr, SK_ARRAY_COUNT(colors)));
 
     SkAutoCanvasRestore acr(c, true);
 
diff --git a/samplecode/SampleDitherBitmap.cpp b/samplecode/SampleDitherBitmap.cpp
index df72dd4ffe..34241c5e02 100644
--- a/samplecode/SampleDitherBitmap.cpp
+++ b/samplecode/SampleDitherBitmap.cpp
@@ -26,11 +26,8 @@ static void draw_gradient(SkCanvas* canvas) {
     SkRect r = { 0, 0, SkIntToScalar(256), SkIntToScalar(32) };
     SkPoint pts[] = { { r.fLeft, r.fTop }, { r.fRight, r.fTop } };
     SkColor colors[] = { 0xFF000000, 0xFFFF0000 };
-    SkShader* s = SkGradientShader::CreateLinear(pts, colors, nullptr, 2,
-                                                 SkShader::kClamp_TileMode);
-
     SkPaint p;
-    p.setShader(s)->unref();
+    p.setShader(SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode));
     draw_rect(canvas, r, p);
 
     canvas->translate(0, SkIntToScalar(40));
diff --git a/samplecode/SampleEffects.cpp b/samplecode/SampleEffects.cpp
index b58d5573ad..12ea4e2392 100644
--- a/samplecode/SampleEffects.cpp
+++ b/samplecode/SampleEffects.cpp
@@ -40,8 +40,8 @@ static void paint_proc2(SkPaint* paint) {
 static void paint_proc3(SkPaint* paint) {
     SkColor colors[] = { SK_ColorRED, COLOR, SK_ColorBLUE };
     SkPoint pts[] = { { 3, 0 }, { 7, 5 } };
-    paint->setShader(SkGradientShader::CreateLinear(pts, colors, nullptr, SK_ARRAY_COUNT(colors),
-                                        SkShader::kMirror_TileMode))->unref();
+    paint->setShader(SkGradientShader::MakeLinear(pts, colors, nullptr, SK_ARRAY_COUNT(colors),
+                                                  SkShader::kMirror_TileMode));
 }
 
 static void paint_proc5(SkPaint* paint) {
diff --git a/samplecode/SampleFatBits.cpp b/samplecode/SampleFatBits.cpp
index f3a2f6c54a..4b15e370e4 100644
--- a/samplecode/SampleFatBits.cpp
+++ b/samplecode/SampleFatBits.cpp
@@ -88,8 +88,7 @@ public:
         fBounds.set(0, 0, SkIntToScalar(width * zoom), SkIntToScalar(height * zoom));
         fMatrix.setScale(SkIntToScalar(zoom), SkIntToScalar(zoom));
         fInverse.setScale(SK_Scalar1 / zoom, SK_Scalar1 / zoom);
-        fShader.reset(sk_tool_utils::create_checkerboard_shader(
-                              0xFFCCCCCC, 0xFFFFFFFF, zoom));
+        fShader = sk_tool_utils::create_checkerboard_shader(0xFFCCCCCC, 0xFFFFFFFF, zoom);
 
         SkImageInfo info = SkImageInfo::MakeN32Premul(width, height);
         fMinSurface.reset(SkSurface::NewRaster(info));
@@ -111,7 +110,7 @@ private:
     int fW, fH, fZoom;
     SkMatrix fMatrix, fInverse;
     SkRect   fBounds, fClipRect;
-    SkAutoTUnref<SkShader> fShader;
+    sk_sp<SkShader> fShader;
     SkAutoTUnref<SkSurface> fMinSurface;
     SkAutoTUnref<SkSurface> fMaxSurface;
 
diff --git a/samplecode/SampleGradients.cpp b/samplecode/SampleGradients.cpp
index 2d6f7d4bb1..5e9450e84d 100644
--- a/samplecode/SampleGradients.cpp
+++ b/samplecode/SampleGradients.cpp
@@ -10,10 +10,10 @@
 #include "SkCanvas.h"
 #include "SkGradientShader.h"
 
-static SkShader* setgrad(const SkRect& r, SkColor c0, SkColor c1) {
+static sk_sp<SkShader> setgrad(const SkRect& r, SkColor c0, SkColor c1) {
     SkColor colors[] = { c0, c1 };
     SkPoint pts[] = { { r.fLeft, r.fTop }, { r.fRight, r.fTop } };
-    return SkGradientShader::CreateLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode);
+    return SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode);
 }
 
 static void test_alphagradients(SkCanvas* canvas) {
@@ -23,17 +23,17 @@ static void test_alphagradients(SkCanvas* canvas) {
     SkPaint p, p2;
     p2.setStyle(SkPaint::kStroke_Style);
 
-    p.setShader(setgrad(r, 0xFF00FF00, 0x0000FF00))->unref();
+    p.setShader(setgrad(r, 0xFF00FF00, 0x0000FF00));
     canvas->drawRect(r, p);
     canvas->drawRect(r, p2);
 
     r.offset(0, r.height() + SkIntToScalar(4));
-    p.setShader(setgrad(r, 0xFF00FF00, 0x00000000))->unref();
+    p.setShader(setgrad(r, 0xFF00FF00, 0x00000000));
     canvas->drawRect(r, p);
     canvas->drawRect(r, p2);
 
     r.offset(0, r.height() + SkIntToScalar(4));
-    p.setShader(setgrad(r, 0xFF00FF00, 0x00FF0000))->unref();
+    p.setShader(setgrad(r, 0xFF00FF00, 0x00FF0000));
     canvas->drawRect(r, p);
     canvas->drawRect(r, p2);
 }
@@ -63,49 +63,49 @@ static const GradData gGradData[] = {
     { 5, gColors, gPos2 }
 };
 
-static SkShader* MakeLinear(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
-    return SkGradientShader::CreateLinear(pts, data.fColors, data.fPos, data.fCount, tm);
+static sk_sp<SkShader> MakeLinear(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
+    return SkGradientShader::MakeLinear(pts, data.fColors, data.fPos, data.fCount, tm);
 }
 
-static SkShader* MakeRadial(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
+static sk_sp<SkShader> MakeRadial(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
     SkPoint center;
     center.set(SkScalarAve(pts[0].fX, pts[1].fX),
                SkScalarAve(pts[0].fY, pts[1].fY));
-    return SkGradientShader::CreateRadial(center, center.fX, data.fColors,
-                                          data.fPos, data.fCount, tm);
+    return SkGradientShader::MakeRadial(center, center.fX, data.fColors,
+                                        data.fPos, data.fCount, tm);
 }
 
-static SkShader* MakeSweep(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
+static sk_sp<SkShader> MakeSweep(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
     SkPoint center;
     center.set(SkScalarAve(pts[0].fX, pts[1].fX),
                SkScalarAve(pts[0].fY, pts[1].fY));
-    return SkGradientShader::CreateSweep(center.fX, center.fY, data.fColors, data.fPos, data.fCount);
+    return SkGradientShader::MakeSweep(center.fX, center.fY, data.fColors, data.fPos, data.fCount);
 }
 
-static SkShader* Make2Conical(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
+static sk_sp<SkShader> Make2Conical(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
     SkPoint center0, center1;
     center0.set(SkScalarAve(pts[0].fX, pts[1].fX),
                 SkScalarAve(pts[0].fY, pts[1].fY));
     center1.set(SkScalarInterp(pts[0].fX, pts[1].fX, SkIntToScalar(3)/5),
                 SkScalarInterp(pts[0].fY, pts[1].fY, SkIntToScalar(1)/4));
-    return SkGradientShader::CreateTwoPointConical(
+    return SkGradientShader::MakeTwoPointConical(
                             center1, (pts[1].fX - pts[0].fX) / 7,
                             center0, (pts[1].fX - pts[0].fX) / 2,
                             data.fColors, data.fPos, data.fCount, tm);
 }
 
-static SkShader* Make2ConicalConcentric(const SkPoint pts[2], const GradData& data,
+static sk_sp<SkShader> Make2ConicalConcentric(const SkPoint pts[2], const GradData& data,
                                        SkShader::TileMode tm) {
     SkPoint center;
     center.set(SkScalarAve(pts[0].fX, pts[1].fX),
                SkScalarAve(pts[0].fY, pts[1].fY));
-    return SkGradientShader::CreateTwoPointConical(
+    return SkGradientShader::MakeTwoPointConical(
                             center, (pts[1].fX - pts[0].fX) / 7,
                             center, (pts[1].fX - pts[0].fX) / 2,
                             data.fColors, data.fPos, data.fCount, tm);
 }
 
-typedef SkShader* (*GradMaker)(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm);
+typedef sk_sp<SkShader> (*GradMaker)(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm);
 
 static const GradMaker gGradMakers[] = {
     MakeLinear, MakeRadial, MakeSweep, Make2Conical, Make2ConicalConcentric
@@ -120,8 +120,7 @@ public:
     }
 
 protected:
-    // overrides from SkEventSink
-    virtual bool onQuery(SkEvent* evt) {
+    bool onQuery(SkEvent* evt) override {
         if (SampleCode::TitleQ(*evt)) {
             SampleCode::TitleR(evt, "Gradients");
             return true;
@@ -129,7 +128,7 @@ protected:
         return this->INHERITED::onQuery(evt);
     }
 
-    virtual void onDrawContent(SkCanvas* canvas) {
+    void onDrawContent(SkCanvas* canvas) override {
         SkPoint pts[2] = {
             { 0, 0 },
             { SkIntToScalar(100), SkIntToScalar(100) }
@@ -146,9 +145,7 @@ protected:
             for (size_t i = 0; i < SK_ARRAY_COUNT(gGradData); i++) {
                 canvas->save();
                 for (size_t j = 0; j < SK_ARRAY_COUNT(gGradMakers); j++) {
-                    SkShader* shader;
-                    shader = gGradMakers[j](pts, gGradData[i], (SkShader::TileMode)tm);
-                    paint.setShader(shader)->unref();
+                    paint.setShader(gGradMakers[j](pts, gGradData[i], (SkShader::TileMode)tm));
                     canvas->drawRect(r, paint);
                     canvas->translate(0, SkIntToScalar(120));
                 }
diff --git a/samplecode/SampleHairModes.cpp b/samplecode/SampleHairModes.cpp
index ae41aa9c9d..085581cfc9 100644
--- a/samplecode/SampleHairModes.cpp
+++ b/samplecode/SampleHairModes.cpp
@@ -60,7 +60,7 @@ static SkScalar drawCell(SkCanvas* canvas, SkXfermode* mode, SkAlpha a0, SkAlpha
     return H;
 }
 
-static SkShader* make_bg_shader() {
+static sk_sp<SkShader> make_bg_shader() {
     SkBitmap bm;
     bm.allocN32Pixels(2, 2);
     *bm.getAddr32(0, 0) = *bm.getAddr32(1, 1) = 0xFFFFFFFF;
@@ -69,17 +69,15 @@ static SkShader* make_bg_shader() {
     SkMatrix m;
     m.setScale(SkIntToScalar(6), SkIntToScalar(6));
 
-    return SkShader::CreateBitmapShader(bm,
-                                        SkShader::kRepeat_TileMode,
-                                        SkShader::kRepeat_TileMode,
-                                        &m);
+    return SkShader::MakeBitmapShader(bm, SkShader::kRepeat_TileMode,
+                                      SkShader::kRepeat_TileMode, &m);
 }
 
 class HairModesView : public SampleView {
     SkPaint fBGPaint;
 public:
     HairModesView() {
-        fBGPaint.setShader(make_bg_shader())->unref();
+        fBGPaint.setShader(make_bg_shader());
     }
 
 protected:
diff --git a/samplecode/SampleLayers.cpp b/samplecode/SampleLayers.cpp
index f8ebd7c94f..beb7e4ae1a 100644
--- a/samplecode/SampleLayers.cpp
+++ b/samplecode/SampleLayers.cpp
@@ -1,10 +1,10 @@
-
 /*
  * 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 "SampleCode.h"
 #include "SkView.h"
 #include "SkCanvas.h"
@@ -30,10 +30,8 @@
 static void make_paint(SkPaint* paint, const SkMatrix& localMatrix) {
     SkColor colors[] = { 0, SK_ColorWHITE };
     SkPoint pts[] = { { 0, 0 }, { 0, SK_Scalar1*20 } };
-    SkShader* s = SkGradientShader::CreateLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode,
-                                                 0, &localMatrix);
-
-    paint->setShader(s)->unref();
+    paint->setShader(SkGradientShader::MakeLinear(pts, colors, nullptr, 2,
+                                                  SkShader::kClamp_TileMode, 0, &localMatrix));
     paint->setXfermodeMode(SkXfermode::kDstIn_Mode);
 }
 
diff --git a/samplecode/SamplePatch.cpp b/samplecode/SamplePatch.cpp
index 5347b0182a..c9ecb70990 100644
--- a/samplecode/SamplePatch.cpp
+++ b/samplecode/SamplePatch.cpp
@@ -28,21 +28,21 @@
 
 #include "SkGeometry.h" // private include :(
 
-static SkShader* make_shader0(SkIPoint* size) {
+static sk_sp<SkShader> make_shader0(SkIPoint* size) {
     SkBitmap    bm;
 
 //    SkImageDecoder::DecodeFile("/skimages/progressivejpg.jpg", &bm);
     SkImageDecoder::DecodeFile("/skimages/logo.png", &bm);
     size->set(bm.width(), bm.height());
-    return SkShader::CreateBitmapShader(bm, SkShader::kClamp_TileMode,
-                                        SkShader::kClamp_TileMode);
+    return SkShader::MakeBitmapShader(bm, SkShader::kClamp_TileMode,
+                                       SkShader::kClamp_TileMode);
 }
 
-static SkShader* make_shader1(const SkIPoint& size) {
+static sk_sp<SkShader> make_shader1(const SkIPoint& size) {
     SkPoint pts[] = { { 0, 0, },
                       { SkIntToScalar(size.fX), SkIntToScalar(size.fY) } };
     SkColor colors[] = { SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorRED };
-    return SkGradientShader::CreateLinear(pts, colors, nullptr,
+    return SkGradientShader::MakeLinear(pts, colors, nullptr,
                     SK_ARRAY_COUNT(colors), SkShader::kMirror_TileMode);
 }
 
@@ -211,8 +211,8 @@ const SkScalar DY = 0;
 
 class PatchView : public SampleView {
     SkScalar    fAngle;
-    SkShader*   fShader0;
-    SkShader*   fShader1;
+    sk_sp<SkShader> fShader0;
+    sk_sp<SkShader> fShader1;
     SkIPoint    fSize0, fSize1;
     SkPoint     fPts[12];
 
@@ -243,11 +243,6 @@ public:
         this->setBGColor(SK_ColorGRAY);
     }
 
-    virtual ~PatchView() {
-        SkSafeUnref(fShader0);
-        SkSafeUnref(fShader1);
-    }
-
 protected:
     // overrides from SkEventSink
     bool onQuery(SkEvent* evt)  override {
diff --git a/samplecode/SampleQuadStroker.cpp b/samplecode/SampleQuadStroker.cpp
index eae683f82e..48f29f7f50 100644
--- a/samplecode/SampleQuadStroker.cpp
+++ b/samplecode/SampleQuadStroker.cpp
@@ -109,7 +109,7 @@ class QuadStrokerView : public SampleView {
     SkRect fWidthControl;
     SkRect fBounds;
     SkMatrix fMatrix, fInverse;
-    SkAutoTUnref<SkShader> fShader;
+    sk_sp<SkShader> fShader;
     SkAutoTUnref<SkSurface> fMinSurface;
     SkAutoTUnref<SkSurface> fMaxSurface;
     StrokeTypeButton fCubicButton;
@@ -264,8 +264,7 @@ protected:
         fBounds.set(0, 0, SkIntToScalar(width * zoom), SkIntToScalar(height * zoom));
         fMatrix.setScale(SkIntToScalar(zoom), SkIntToScalar(zoom));
         fInverse.setScale(SK_Scalar1 / zoom, SK_Scalar1 / zoom);
-        fShader.reset(sk_tool_utils::create_checkerboard_shader(
-                              0xFFCCCCCC, 0xFFFFFFFF, zoom));
+        fShader = sk_tool_utils::create_checkerboard_shader(0xFFCCCCCC, 0xFFFFFFFF, zoom);
 
         SkImageInfo info = SkImageInfo::MakeN32Premul(width, height);
         fMinSurface.reset(SkSurface::NewRaster(info));
diff --git a/samplecode/SampleRegion.cpp b/samplecode/SampleRegion.cpp
index eb3e134af9..639203b8bc 100644
--- a/samplecode/SampleRegion.cpp
+++ b/samplecode/SampleRegion.cpp
@@ -4,6 +4,7 @@
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
+
 #include "SampleCode.h"
 #include "SkView.h"
 #include "SkCanvas.h"
@@ -78,10 +79,8 @@ static void drawFadingText(SkCanvas* canvas,
     // of our pts[] array.
     const SkScalar pos[] = { 0, 0.9f, SK_Scalar1 };
 
-    SkShader* s = SkGradientShader::CreateLinear(pts, colors, pos, 3,
-                                                 SkShader::kClamp_TileMode);
     SkPaint p;
-    p.setShader(s)->unref();
+    p.setShader(SkGradientShader::MakeLinear(pts, colors, pos, 3, SkShader::kClamp_TileMode));
     p.setXfermodeMode(SkXfermode::kDstIn_Mode);
     canvas->drawRect(bounds, p);
 
@@ -105,10 +104,9 @@ static void test_text(SkCanvas* canvas) {
     const SkPoint pts[] = { { x, y }, { x + paint.measureText(str, len), y } };
     const SkColor colors[] = { SK_ColorBLACK, SK_ColorBLACK, 0 };
     const SkScalar pos[] = { 0, 0.9f, 1 };
-    SkShader* s = SkGradientShader::CreateLinear(pts, colors, pos,
+    paint.setShader(SkGradientShader::MakeLinear(pts, colors, pos,
                                                  SK_ARRAY_COUNT(colors),
-                                                 SkShader::kClamp_TileMode);
-    paint.setShader(s)->unref();
+                                                 SkShader::kClamp_TileMode));
     canvas->drawText(str, len, x, y, paint);
 
     y += 20;
diff --git a/samplecode/SampleRepeatTile.cpp b/samplecode/SampleRepeatTile.cpp
index 9287439613..598a088373 100644
--- a/samplecode/SampleRepeatTile.cpp
+++ b/samplecode/SampleRepeatTile.cpp
@@ -37,8 +37,7 @@ static void make_paint(SkPaint* paint, SkShader::TileMode tm) {
     SkBitmap bm;
     make_bitmap(&bm);
 
-    SkShader* shader = SkShader::CreateBitmapShader(bm, tm, tm);
-    paint->setShader(shader)->unref();
+    paint->setShader(SkShader::MakeBitmapShader(bm, tm, tm));
 }
 
 class RepeatTileView : public SampleView {
diff --git a/samplecode/SampleShaderText.cpp b/samplecode/SampleShaderText.cpp
index f13fd4edc7..cf0cb0fe75 100644
--- a/samplecode/SampleShaderText.cpp
+++ b/samplecode/SampleShaderText.cpp
@@ -23,18 +23,18 @@ static void makebm(SkBitmap* bm, int w, int h) {
     SkPaint     paint;
 
     paint.setDither(true);
-    paint.setShader(SkGradientShader::CreateLinear(pts, colors, pos,
-                                    SK_ARRAY_COUNT(colors), SkShader::kClamp_TileMode))->unref();
+    paint.setShader(SkGradientShader::MakeLinear(pts, colors, pos,
+                                    SK_ARRAY_COUNT(colors), SkShader::kClamp_TileMode));
     canvas.drawPaint(paint);
 }
 
-static SkShader* MakeBitmapShader(SkShader::TileMode tx, SkShader::TileMode ty,
-                           int w, int h) {
+static sk_sp<SkShader> MakeBitmapShader(SkShader::TileMode tx, SkShader::TileMode ty,
+                                        int w, int h) {
     static SkBitmap bmp;
     if (bmp.isNull()) {
         makebm(&bmp, w/2, h/4);
     }
-    return SkShader::CreateBitmapShader(bmp, tx, ty);
+    return SkShader::MakeBitmapShader(bmp, tx, ty);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -54,38 +54,38 @@ static const GradData gGradData[] = {
     { 5, gColors, nullptr },
 };
 
-static SkShader* MakeLinear(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
-    return SkGradientShader::CreateLinear(pts, data.fColors, data.fPos, data.fCount, tm);
+static sk_sp<SkShader> MakeLinear(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
+    return SkGradientShader::MakeLinear(pts, data.fColors, data.fPos, data.fCount, tm);
 }
 
-static SkShader* MakeRadial(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
+static sk_sp<SkShader> MakeRadial(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
     SkPoint center;
     center.set(SkScalarAve(pts[0].fX, pts[1].fX),
                SkScalarAve(pts[0].fY, pts[1].fY));
-    return SkGradientShader::CreateRadial(center, center.fX, data.fColors,
-                                          data.fPos, data.fCount, tm);
+    return SkGradientShader::MakeRadial(center, center.fX, data.fColors,
+                                        data.fPos, data.fCount, tm);
 }
 
-static SkShader* MakeSweep(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
+static sk_sp<SkShader> MakeSweep(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
     SkPoint center;
     center.set(SkScalarAve(pts[0].fX, pts[1].fX),
                SkScalarAve(pts[0].fY, pts[1].fY));
-    return SkGradientShader::CreateSweep(center.fX, center.fY, data.fColors, data.fPos, data.fCount);
+    return SkGradientShader::MakeSweep(center.fX, center.fY, data.fColors, data.fPos, data.fCount);
 }
 
-static SkShader* Make2Conical(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
+static sk_sp<SkShader> Make2Conical(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
     SkPoint center0, center1;
     center0.set(SkScalarAve(pts[0].fX, pts[1].fX),
                 SkScalarAve(pts[0].fY, pts[1].fY));
     center1.set(SkScalarInterp(pts[0].fX, pts[1].fX, SkIntToScalar(3)/5),
                 SkScalarInterp(pts[0].fY, pts[1].fY, SkIntToScalar(1)/4));
-    return SkGradientShader::CreateTwoPointConical(
+    return SkGradientShader::MakeTwoPointConical(
                             center1, (pts[1].fX - pts[0].fX) / 7,
                             center0, (pts[1].fX - pts[0].fX) / 2,
                             data.fColors, data.fPos, data.fCount, tm);
 }
 
-typedef SkShader* (*GradMaker)(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm);
+typedef sk_sp<SkShader> (*GradMaker)(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm);
 
 static const GradMaker gGradMakers[] = {
     MakeLinear, MakeRadial, MakeSweep, Make2Conical
@@ -133,7 +133,7 @@ protected:
                                      SK_ARRAY_COUNT(gGradMakers);
         static const int bmpCount = SK_ARRAY_COUNT(tileModes) *
                                     SK_ARRAY_COUNT(tileModes);
-        SkShader* shaders[gradCount + bmpCount];
+        sk_sp<SkShader> shaders[gradCount + bmpCount];
 
         int shdIdx = 0;
         for (size_t d = 0; d < SK_ARRAY_COUNT(gGradData); ++d) {
@@ -175,7 +175,7 @@ protected:
             size_t i = 2*s;
             canvas->translate(SkIntToScalar((i / testsPerCol) * colWidth),
                               SkIntToScalar((i % testsPerCol) * rowHeight));
-            paint.setShader(shaders[s])->unref();
+            paint.setShader(shaders[s]);
             canvas->drawText(text, textLen, 0, textBase, paint);
             canvas->restore();
             canvas->save();
diff --git a/samplecode/SampleShaders.cpp b/samplecode/SampleShaders.cpp
index 2c0a6ab749..71ddc2ec69 100644
--- a/samplecode/SampleShaders.cpp
+++ b/samplecode/SampleShaders.cpp
@@ -1,10 +1,10 @@
-
 /*
  * 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 "SampleCode.h"
 #include "SkView.h"
 #include "SkCanvas.h"
@@ -21,8 +21,7 @@
 #include "SkTime.h"
 #include "SkTypeface.h"
 
-static SkShader* make_bitmapfade(const SkBitmap& bm)
-{
+static sk_sp<SkShader> make_bitmapfade(const SkBitmap& bm) {
     SkPoint pts[2];
     SkColor colors[2];
 
@@ -30,25 +29,20 @@ static SkShader* make_bitmapfade(const SkBitmap& bm)
     pts[1].set(0, SkIntToScalar(bm.height()));
     colors[0] = SK_ColorBLACK;
     colors[1] = SkColorSetARGB(0, 0, 0, 0);
-    SkShader* shaderA = SkGradientShader::CreateLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode);
+    auto shaderA = SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode);
 
-    SkShader* shaderB = SkShader::CreateBitmapShader(bm,
+    auto shaderB = SkShader::MakeBitmapShader(bm,
                         SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
 
-    SkXfermode* mode = SkXfermode::Create(SkXfermode::kDstIn_Mode);
+    SkAutoTUnref<SkXfermode> mode(SkXfermode::Create(SkXfermode::kDstIn_Mode));
 
-    SkShader* shader = SkShader::CreateComposeShader(shaderB, shaderA, mode);
-    shaderA->unref();
-    shaderB->unref();
-    mode->unref();
-
-    return shader;
+    return SkShader::MakeComposeShader(std::move(shaderB), std::move(shaderA), mode);
 }
 
 class ShaderView : public SampleView {
 public:
-    SkShader*   fShader;
-    SkBitmap    fBitmap;
+    sk_sp<SkShader> fShader;
+    SkBitmap        fBitmap;
 
     ShaderView() {
         SkImageDecoder::DecodeFile("/skimages/logo.gif", &fBitmap);
@@ -60,23 +54,17 @@ public:
         pts[1].set(SkIntToScalar(100), 0);
         colors[0] = SK_ColorRED;
         colors[1] = SK_ColorBLUE;
-        SkShader* shaderA = SkGradientShader::CreateLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode);
+        auto shaderA = SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode);
 
         pts[0].set(0, 0);
         pts[1].set(0, SkIntToScalar(100));
         colors[0] = SK_ColorBLACK;
         colors[1] = SkColorSetARGB(0x80, 0, 0, 0);
-        SkShader* shaderB = SkGradientShader::CreateLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode);
+        auto shaderB = SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode);
 
-        SkXfermode* mode = SkXfermode::Create(SkXfermode::kDstIn_Mode);
+        SkAutoTUnref<SkXfermode> mode(SkXfermode::Create(SkXfermode::kDstIn_Mode));
 
-        fShader = SkShader::CreateComposeShader(shaderA, shaderB, mode);
-        shaderA->unref();
-        shaderB->unref();
-        mode->unref();
-    }
-    virtual ~ShaderView() {
-        SkSafeUnref(fShader);
+        fShader = SkShader::MakeComposeShader(std::move(shaderA), std::move(shaderB), mode);
     }
 
 protected:
@@ -112,7 +100,7 @@ protected:
 
         paint.setShader(nullptr);
         canvas->drawRect(r, paint);
-        paint.setShader(make_bitmapfade(fBitmap))->unref();
+        paint.setShader(make_bitmapfade(fBitmap));
         canvas->drawRect(r, paint);
     }
 
diff --git a/samplecode/SampleSlides.cpp b/samplecode/SampleSlides.cpp
index 8b853365fe..c3cc2bbd6f 100644
--- a/samplecode/SampleSlides.cpp
+++ b/samplecode/SampleSlides.cpp
@@ -178,38 +178,37 @@ static const GradData gGradData[] = {
 { 5, gColors, gPos2 }
 };
 
-static SkShader* MakeLinear(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
-    return SkGradientShader::CreateLinear(pts, data.fColors, data.fPos, data.fCount, tm);
+static sk_sp<SkShader> MakeLinear(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
+    return SkGradientShader::MakeLinear(pts, data.fColors, data.fPos, data.fCount, tm);
 }
 
-static SkShader* MakeRadial(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
+static sk_sp<SkShader> MakeRadial(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
     SkPoint center;
     center.set(SkScalarAve(pts[0].fX, pts[1].fX),
                SkScalarAve(pts[0].fY, pts[1].fY));
-    return SkGradientShader::CreateRadial(center, center.fX, data.fColors,
+    return SkGradientShader::MakeRadial(center, center.fX, data.fColors,
                                           data.fPos, data.fCount, tm);
 }
 
-static SkShader* MakeSweep(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
+static sk_sp<SkShader> MakeSweep(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
     SkPoint center;
     center.set(SkScalarAve(pts[0].fX, pts[1].fX),
                SkScalarAve(pts[0].fY, pts[1].fY));
-    return SkGradientShader::CreateSweep(center.fX, center.fY, data.fColors, data.fPos, data.fCount);
+    return SkGradientShader::MakeSweep(center.fX, center.fY, data.fColors, data.fPos, data.fCount);
 }
 
-static SkShader* Make2Conical(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
+static sk_sp<SkShader> Make2Conical(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
     SkPoint center0, center1;
     center0.set(SkScalarAve(pts[0].fX, pts[1].fX),
                 SkScalarAve(pts[0].fY, pts[1].fY));
     center1.set(SkScalarInterp(pts[0].fX, pts[1].fX, SkIntToScalar(3)/5),
                 SkScalarInterp(pts[0].fY, pts[1].fY, SkIntToScalar(1)/4));
-    return SkGradientShader::CreateTwoPointConical(
-                                                  center1, (pts[1].fX - pts[0].fX) / 7,
+    return SkGradientShader::MakeTwoPointConical(center1, (pts[1].fX - pts[0].fX) / 7,
                                                   center0, (pts[1].fX - pts[0].fX) / 2,
                                                   data.fColors, data.fPos, data.fCount, tm);
 }
 
-typedef SkShader* (*GradMaker)(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm);
+typedef sk_sp<SkShader> (*GradMaker)(const SkPoint pts[2], const GradData&, SkShader::TileMode);
 static const GradMaker gGradMakers[] = {
     MakeLinear, MakeRadial, MakeSweep, Make2Conical
 };
@@ -229,10 +228,8 @@ static void gradient_slide(SkCanvas* canvas) {
     for (size_t i = 0; i < SK_ARRAY_COUNT(gGradData); i++) {
         canvas->save();
         for (size_t j = 0; j < SK_ARRAY_COUNT(gGradMakers); j++) {
-            SkShader* shader = gGradMakers[j](pts, gGradData[i], tm);
-            paint.setShader(shader);
+            paint.setShader(gGradMakers[j](pts, gGradData[i], tm));
             canvas->drawRect(r, paint);
-            shader->unref();
             canvas->translate(0, SkIntToScalar(120));
         }
         canvas->restore();
@@ -314,20 +311,20 @@ static void textonpath_slide(SkCanvas* canvas) {
 #include "SkRandom.h"
 #include "SkStream.h"
 
-static SkShader* make_shader0(SkIPoint* size) {
+static sk_sp<SkShader> make_shader0(SkIPoint* size) {
     SkBitmap    bm;
 
     SkImageDecoder::DecodeFile("/skimages/logo.gif", &bm);
     size->set(bm.width(), bm.height());
-    return SkShader::CreateBitmapShader(bm, SkShader::kClamp_TileMode,
+    return SkShader::MakeBitmapShader(bm, SkShader::kClamp_TileMode,
                                         SkShader::kClamp_TileMode);
 }
 
-static SkShader* make_shader1(const SkIPoint& size) {
+static sk_sp<SkShader> make_shader1(const SkIPoint& size) {
     SkPoint pts[] = { { 0, 0 },
                       { SkIntToScalar(size.fX), SkIntToScalar(size.fY) } };
     SkColor colors[] = { SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorRED };
-    return SkGradientShader::CreateLinear(pts, colors, nullptr,
+    return SkGradientShader::MakeLinear(pts, colors, nullptr,
                                           SK_ARRAY_COUNT(colors), SkShader::kMirror_TileMode);
 }
 
@@ -426,11 +423,8 @@ static void mesh_slide(SkCanvas* canvas) {
     Rec fRecs[3];
     SkIPoint    size;
 
-    SkShader* fShader0 = make_shader0(&size);
-    SkShader* fShader1 = make_shader1(size);
-
-    SkAutoUnref aur0(fShader0);
-    SkAutoUnref aur1(fShader1);
+    auto fShader0 = make_shader0(&size);
+    auto fShader1 = make_shader1(size);
 
     make_strip(&fRecs[0], size.fX, size.fY);
     make_fan(&fRecs[1], size.fX, size.fY);
diff --git a/samplecode/SampleTiling.cpp b/samplecode/SampleTiling.cpp
index ed244eb3d2..125155e8d0 100644
--- a/samplecode/SampleTiling.cpp
+++ b/samplecode/SampleTiling.cpp
@@ -35,15 +35,14 @@ static void makebm(SkBitmap* bm, SkColorType ct, int w, int h) {
     SkPaint     paint;
 
     paint.setDither(true);
-    paint.setShader(SkGradientShader::CreateLinear(pts, colors, pos,
-                SK_ARRAY_COUNT(colors), SkShader::kClamp_TileMode))->unref();
+    paint.setShader(SkGradientShader::MakeLinear(pts, colors, pos,
+                SK_ARRAY_COUNT(colors), SkShader::kClamp_TileMode));
     canvas.drawPaint(paint);
 }
 
 static void setup(SkPaint* paint, const SkBitmap& bm, bool filter,
                   SkShader::TileMode tmx, SkShader::TileMode tmy) {
-    SkShader* shader = SkShader::CreateBitmapShader(bm, tmx, tmy);
-    paint->setShader(shader)->unref();
+    paint->setShader(SkShader::MakeBitmapShader(bm, tmx, tmy));
     paint->setFilterQuality(filter ? kLow_SkFilterQuality : kNone_SkFilterQuality);
 }
 
diff --git a/samplecode/SampleTinyBitmap.cpp b/samplecode/SampleTinyBitmap.cpp
index 8b1bdf0d18..4fb508b898 100644
--- a/samplecode/SampleTinyBitmap.cpp
+++ b/samplecode/SampleTinyBitmap.cpp
@@ -1,10 +1,10 @@
-
 /*
  * 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 "SampleCode.h"
 #include "SkColorPriv.h"
 #include "SkShader.h"
@@ -47,8 +47,7 @@ public:
     }
 
 protected:
-    // overrides from SkEventSink
-    virtual bool onQuery(SkEvent* evt) {
+    bool onQuery(SkEvent* evt) override {
         if (SampleCode::TitleQ(*evt)) {
             SampleCode::TitleR(evt, "TinyBitmap");
             return true;
@@ -61,11 +60,10 @@ protected:
         bm->setAlphaType(isOpaque ? kOpaque_SkAlphaType : kPremul_SkAlphaType);
     }
 
-    virtual void onDrawContent(SkCanvas* canvas) {
-        SkShader* s = SkShader::CreateBitmapShader(fBM, SkShader::kRepeat_TileMode,
-                                                   SkShader::kMirror_TileMode);
+    void onDrawContent(SkCanvas* canvas) override {
         SkPaint paint;
-        paint.setShader(s)->unref();
+        paint.setShader(SkShader::MakeBitmapShader(fBM, SkShader::kRepeat_TileMode,
+                                                   SkShader::kMirror_TileMode));
         canvas->drawPaint(paint);
     }
 
diff --git a/samplecode/SampleVertices.cpp b/samplecode/SampleVertices.cpp
index 2f2dc024d0..a8dcd22bb3 100644
--- a/samplecode/SampleVertices.cpp
+++ b/samplecode/SampleVertices.cpp
@@ -25,7 +25,7 @@
 #include "SkOSFile.h"
 #include "SkStream.h"
 
-static SkShader* make_shader0(SkIPoint* size) {
+static sk_sp<SkShader> make_shader0(SkIPoint* size) {
     SkBitmap    bm;
     size->set(2, 2);
     SkPMColor color0 = SkPreMultiplyARGB(0x80, 0x80, 0xff, 0x80);
@@ -38,21 +38,20 @@ static SkShader* make_shader0(SkIPoint* size) {
     pixels[1] = pixels[3] = color1;
     bm.unlockPixels();
 
-    return SkShader::CreateBitmapShader(bm, SkShader::kRepeat_TileMode,
-                                            SkShader::kRepeat_TileMode);
+    return SkShader::MakeBitmapShader(bm, SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode);
 }
 
-static SkShader* make_shader1(const SkIPoint& size) {
+static sk_sp<SkShader> make_shader1(const SkIPoint& size) {
     SkPoint pts[] = { { 0, 0 },
                       { SkIntToScalar(size.fX), SkIntToScalar(size.fY) } };
     SkColor colors[] = { SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorRED };
-    return SkGradientShader::CreateLinear(pts, colors, nullptr,
+    return SkGradientShader::MakeLinear(pts, colors, nullptr,
                     SK_ARRAY_COUNT(colors), SkShader::kMirror_TileMode);
 }
 
 class VerticesView : public SampleView {
-    SkShader*   fShader0;
-    SkShader*   fShader1;
+    sk_sp<SkShader> fShader0;
+    sk_sp<SkShader> fShader1;
 
 public:
     VerticesView() {
@@ -70,11 +69,6 @@ public:
         this->setBGColor(SK_ColorGRAY);
     }
 
-    virtual ~VerticesView() {
-        SkSafeUnref(fShader0);
-        SkSafeUnref(fShader1);
-    }
-
 protected:
     // overrides from SkEventSink
     bool onQuery(SkEvent* evt) override {
diff --git a/samplecode/SampleXfer.cpp b/samplecode/SampleXfer.cpp
index 221ba5815e..58546e19cd 100644
--- a/samplecode/SampleXfer.cpp
+++ b/samplecode/SampleXfer.cpp
@@ -127,10 +127,9 @@ class CircDrawable : public ModeDrawable {
 public:
     CircDrawable(SkScalar size, SkColor c) {
         const SkColor colors[] = { 0, c };
-        SkAutoTUnref<SkShader> shader(SkGradientShader::CreateRadial(SkPoint::Make(size/2, size/2), size/2,
+        fPaint.setShader(SkGradientShader::MakeRadial(SkPoint::Make(size/2, size/2), size/2,
                                                                      colors, nullptr, 2,
                                                                      SkShader::kClamp_TileMode));
-        fPaint.setShader(shader);
         fBounds = SkRect::MakeWH(size, size);
     }
 
diff --git a/samplecode/SampleXfermodesBlur.cpp b/samplecode/SampleXfermodesBlur.cpp
index f995c6aa7e..63c90fea15 100644
--- a/samplecode/SampleXfermodesBlur.cpp
+++ b/samplecode/SampleXfermodesBlur.cpp
@@ -150,10 +150,8 @@ protected:
         const SkScalar h = SkIntToScalar(H);
         SkMatrix m;
         m.setScale(SkIntToScalar(6), SkIntToScalar(6));
-        SkShader* s = SkShader::CreateBitmapShader(fBG,
-                                                   SkShader::kRepeat_TileMode,
-                                                   SkShader::kRepeat_TileMode,
-                                                   &m);
+        auto s = SkShader::MakeBitmapShader(fBG, SkShader::kRepeat_TileMode,
+                                            SkShader::kRepeat_TileMode, &m);
 
         SkPaint labelP;
         labelP.setAntiAlias(true);