Revert of more shader-->sp conversions

gm/gradients.cpp

 /*
  * 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 "gm.h"
 #include "SkGradientShader.h"
 #include "SkLinearGradient.h"
@@ skipping 22 matching lines @@
 
 static const GradData gGradData[] = {
     { 2, gColors, nullptr },
     { 2, gColors, gPos0 },
     { 2, gColors, gPos1 },
     { 5, gColors, nullptr },
     { 5, gColors, gPos2 },
     { 4, gColorClamp, gPosClamp }
 };
 
-static sk_sp<SkShader> MakeLinear(const SkPoint pts[2], const GradData& data,
-                                  SkShader::TileMode tm, const SkMatrix& localMatrix) {
-    return SkGradientShader::MakeLinear(pts, data.fColors, data.fPos, data.fCount, tm, 0,
-                                        &localMatrix);
+static SkShader* MakeLinear(const SkPoint pts[2], const GradData& data,
+                            SkShader::TileMode tm, const SkMatrix& localMatrix) {
+    return SkGradientShader::CreateLinear(pts, data.fColors, data.fPos,
+                                          data.fCount, tm, 0, &localMatrix);
 }
 
-static sk_sp<SkShader> MakeRadial(const SkPoint pts[2], const GradData& data,
-                                  SkShader::TileMode tm, const SkMatrix& localMatrix) {
+static SkShader* MakeRadial(const SkPoint pts[2], const GradData& data,
+                            SkShader::TileMode tm, const SkMatrix& localMatrix) {
     SkPoint center;
     center.set(SkScalarAve(pts[0].fX, pts[1].fX),
                SkScalarAve(pts[0].fY, pts[1].fY));
-    return SkGradientShader::MakeRadial(center, center.fX, data.fColors, data.fPos, data.fCount,
-                                        tm, 0, &localMatrix);
+    return SkGradientShader::CreateRadial(center, center.fX, data.fColors,
+                                          data.fPos, data.fCount, tm, 0, &localMatrix);
 }
 
-static sk_sp<SkShader> MakeSweep(const SkPoint pts[2], const GradData& data,
-                                 SkShader::TileMode, const SkMatrix& localMatrix) {
+static SkShader* MakeSweep(const SkPoint pts[2], const GradData& data,
+                           SkShader::TileMode, const SkMatrix& localMatrix) {
     SkPoint center;
     center.set(SkScalarAve(pts[0].fX, pts[1].fX),
                SkScalarAve(pts[0].fY, pts[1].fY));
-    return SkGradientShader::MakeSweep(center.fX, center.fY, data.fColors, data.fPos, data.fCount,
-                                       0, &localMatrix);
+    return SkGradientShader::CreateSweep(center.fX, center.fY, data.fColors,
+                                         data.fPos, data.fCount, 0, &localMatrix);
 }
 
-static sk_sp<SkShader> Make2Radial(const SkPoint pts[2], const GradData& data,
-                                   SkShader::TileMode tm, const SkMatrix& localMatrix) {
+static SkShader* Make2Radial(const SkPoint pts[2], const GradData& data,
+                             SkShader::TileMode tm, const SkMatrix& localMatrix) {
     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::MakeTwoPointConical(center1, (pts[1].fX - pts[0].fX) / 7,
-                                                 center0, (pts[1].fX - pts[0].fX) / 2,
-                                                 data.fColors, data.fPos, data.fCount, tm,
-                                                 0, &localMatrix);
+    return SkGradientShader::CreateTwoPointConical(
+                                                   center1, (pts[1].fX - pts[0].fX) / 7,
+                                                   center0, (pts[1].fX - pts[0].fX) / 2,
+                                                   data.fColors, data.fPos, data.fCount, tm,
+                                                   0, &localMatrix);
 }
 
-static sk_sp<SkShader> Make2Conical(const SkPoint pts[2], const GradData& data,
+static SkShader* Make2Conical(const SkPoint pts[2], const GradData& data,
                              SkShader::TileMode tm, const SkMatrix& localMatrix) {
     SkPoint center0, center1;
     SkScalar radius0 = (pts[1].fX - pts[0].fX) / 10;
     SkScalar radius1 = (pts[1].fX - pts[0].fX) / 3;
     center0.set(pts[0].fX + radius0, pts[0].fY + radius0);
     center1.set(pts[1].fX - radius1, pts[1].fY - radius1);
-    return SkGradientShader::MakeTwoPointConical(center1, radius1, center0, radius0,
-                                                 data.fColors, data.fPos,
-                                                 data.fCount, tm, 0, &localMatrix);
+    return SkGradientShader::CreateTwoPointConical(center1, radius1,
+                                                   center0, radius0,
+                                                   data.fColors, data.fPos,
+                                                   data.fCount, tm, 0, &localMatrix);
 }
 
-typedef sk_sp<SkShader> (*GradMaker)(const SkPoint pts[2], const GradData& data,
-                                     SkShader::TileMode tm, const SkMatrix& localMatrix);
+typedef SkShader* (*GradMaker)(const SkPoint pts[2], const GradData& data,
+                               SkShader::TileMode tm, const SkMatrix& localMatrix);
 static const GradMaker gGradMakers[] = {
     MakeLinear, MakeRadial, MakeSweep, Make2Radial, Make2Conical
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class GradientsGM : public GM {
 public:
     GradientsGM(bool dither) : fDither(dither) {
         this->setBGColor(sk_tool_utils::color_to_565(0xFFDDDDDD));
@@ skipping 23 matching lines @@
         for (size_t i = 0; i < SK_ARRAY_COUNT(gGradData); i++) {
             canvas->save();
             for (size_t j = 0; j < SK_ARRAY_COUNT(gGradMakers); j++) {
                 SkMatrix scale = SkMatrix::I();
 
                 if (i == 5) { // if the clamp case
                     scale.setScale(0.5f, 0.5f);
                     scale.postTranslate(25.f, 25.f);
                 }
 
-                paint.setShader(gGradMakers[j](pts, gGradData[i], tm, scale));
+                SkShader* shader = gGradMakers[j](pts, gGradData[i], tm, scale);
+
+                paint.setShader(shader);
                 canvas->drawRect(r, paint);
+                shader->unref();
                 canvas->translate(0, SkIntToScalar(120));
             }
             canvas->restore();
             canvas->translate(SkIntToScalar(120), 0);
         }
     }
 
 protected:
     bool fDither;
 
@@ skipping 35 matching lines @@
         canvas->translate(SkIntToScalar(20), SkIntToScalar(20));
         for (size_t i = 0; i < SK_ARRAY_COUNT(gGradData); i++) {
             canvas->save();
             for (size_t j = 0; j < SK_ARRAY_COUNT(gGradMakers); j++) {
                 // apply an increasing y perspective as we move to the right
                 SkMatrix perspective;
                 perspective.setIdentity();
                 perspective.setPerspY(SkIntToScalar(i+1) / 500);
                 perspective.setSkewX(SkIntToScalar(i+1) / 10);
 
-                paint.setShader(gGradMakers[j](pts, gGradData[i], tm, perspective));
+                SkShader* shader = gGradMakers[j](pts, gGradData[i], tm, perspective);
+
+                paint.setShader(shader);
                 canvas->drawRect(r, paint);
+                shader->unref();
                 canvas->translate(0, SkIntToScalar(120));
             }
             canvas->restore();
             canvas->translate(SkIntToScalar(120), 0);
         }
     }
 
 private:
     bool fDither;
 
@@ skipping 66 matching lines @@
         this->drawBG(canvas);
 
         SkColor colors[] = { SK_ColorRED, SK_ColorGREEN, SK_ColorGREEN, SK_ColorRED };
         SkScalar pos[] = { 0, 0.01f, 0.99f, SK_Scalar1 };
         SkPoint c0;
         c0.iset(-80, 25);
         SkScalar r0 = SkIntToScalar(70);
         SkPoint c1;
         c1.iset(0, 25);
         SkScalar r1 = SkIntToScalar(150);
+        SkShader* s = SkGradientShader::CreateTwoPointConical(c0, r0, c1, r1, colors,
+                                                              pos, SK_ARRAY_COUNT(pos),
+                                                              SkShader::kClamp_TileMode);
         SkPaint paint;
-        paint.setShader(SkGradientShader::MakeTwoPointConical(c0, r0, c1, r1, colors,
-                                                              pos, SK_ARRAY_COUNT(pos),
-                                                              SkShader::kClamp_TileMode));
         paint.setDither(fDither);
+        paint.setShader(s)->unref();
         canvas->drawPaint(paint);
     }
 
 private:
     bool fDither;
 
     typedef GM INHERITED;
 };
 DEF_GM( return new GradientsDegenrate2PointGM(true); )
 DEF_GM( return new GradientsDegenrate2PointGM(false); )
@@ skipping 16 matching lines @@
 */
 
 // should draw only green
 DEF_SIMPLE_GM(small_color_stop, canvas, 100, 150) {
     SkColor colors[] = { SK_ColorGREEN, SK_ColorRED, SK_ColorYELLOW };
     SkScalar pos[] = { 0, 0.003f, SK_Scalar1 };  // 0.004f makes this work
     SkPoint c0 = { 200, 25 };
     SkScalar r0 = 20;
     SkPoint c1 = { 200, 25 };
     SkScalar r1 = 10;
-
+    SkShader* s = SkGradientShader::CreateTwoPointConical(c0, r0, c1, r1, colors,
+                                                          pos, SK_ARRAY_COUNT(pos),
+                                                          SkShader::kClamp_TileMode);
     SkPaint paint;
     paint.setColor(SK_ColorYELLOW);
     canvas->drawRect(SkRect::MakeWH(100, 150), paint);
-    paint.setShader(SkGradientShader::MakeTwoPointConical(c0, r0, c1, r1, colors, pos,
-                                                          SK_ARRAY_COUNT(pos),
-                                                          SkShader::kClamp_TileMode));
+    paint.setShader(s)->unref();
     canvas->drawRect(SkRect::MakeWH(100, 150), paint);
 }
 
 
 /// Tests correctness of *optimized* codepaths in gradients.
 
 class ClampedGradientsGM : public GM {
 public:
     ClampedGradientsGM(bool dither) : fDither(dither) {}
 
@@ skipping 12 matching lines @@
         this->drawBG(canvas);
 
         SkRect r = { 0, 0, SkIntToScalar(100), SkIntToScalar(300) };
         SkPaint paint;
         paint.setDither(fDither);
         paint.setAntiAlias(true);
 
         SkPoint center;
         center.iset(0, 300);
         canvas->translate(SkIntToScalar(20), SkIntToScalar(20));
-        paint.setShader(SkGradientShader::MakeRadial(
+        SkShader* shader = SkGradientShader::CreateRadial(
             SkPoint(center),
             SkIntToScalar(200), gColors, nullptr, 5,
-            SkShader::kClamp_TileMode));
+            SkShader::kClamp_TileMode);
+        paint.setShader(shader);
         canvas->drawRect(r, paint);
+        shader->unref();
     }
 
 private:
     bool fDither;
 
     typedef GM INHERITED;
 };
 DEF_GM( return new ClampedGradientsGM(true); )
 DEF_GM( return new ClampedGradientsGM(false); )
 
@@ skipping 18 matching lines @@
 
         SkPaint paint;
         paint.setDither(true);
         SkPoint center;
         center.set(SkIntToScalar(dim.width())/2, SkIntToScalar(dim.height())/2);
         SkScalar radius = SkIntToScalar(dim.width())/2;
         const SkColor colors[] = { 0x7f7f7f7f, 0x7f7f7f7f, 0xb2000000 };
         const SkScalar pos[] = { 0.0f,
                              0.35f,
                              1.0f };
-        paint.setShader(SkGradientShader::MakeRadial(center, radius, colors, pos,
-                                                     SK_ARRAY_COUNT(pos),
-                                                     SkShader::kClamp_TileMode));
+        SkShader* shader =
+            SkGradientShader::CreateRadial(center, radius, colors,
+                                           pos, SK_ARRAY_COUNT(pos),
+                                           SkShader::kClamp_TileMode);
+        paint.setShader(shader)->unref();
         SkRect r = {
             0, 0, SkIntToScalar(dim.width()), SkIntToScalar(dim.height())
         };
         canvas->drawRect(r, paint);
     }
 private:
     typedef GM INHERITED;
 };
 DEF_GM( return new RadialGradientGM; )
 
@@ skipping 26 matching lines @@
 
         const SkScalar cx = 200, cy = 200, radius = 150;
         SkPoint center;
         center.set(cx, cy);
 
         // We can either interpolate endpoints and premultiply each point (default, more precision),
         // or premultiply the endpoints first, avoiding the need to premultiply each point (cheap).
         const uint32_t flags[] = { 0, SkGradientShader::kInterpolateColorsInPremul_Flag };
 
         for (size_t i = 0; i < SK_ARRAY_COUNT(flags); i++) {
-            paint1.setShader(SkGradientShader::MakeSweep(cx, cy, sweep_colors,
-                                                         nullptr, SK_ARRAY_COUNT(sweep_colors),
-                                                         flags[i], nullptr));
-            paint2.setShader(SkGradientShader::MakeRadial(center, radius, colors1,
-                                                          nullptr, SK_ARRAY_COUNT(colors1),
-                                                          SkShader::kClamp_TileMode,
-                                                          flags[i], nullptr));
-            paint3.setShader(SkGradientShader::MakeRadial(center, radius, colors2,
-                                                          nullptr, SK_ARRAY_COUNT(colors2),
-                                                          SkShader::kClamp_TileMode,
-                                                          flags[i], nullptr));
+            SkAutoTUnref<SkShader> sweep(
+                    SkGradientShader::CreateSweep(cx, cy, sweep_colors,
+                                                  nullptr, SK_ARRAY_COUNT(sweep_colors),
+                                                  flags[i], nullptr));
+            SkAutoTUnref<SkShader> radial1(
+                    SkGradientShader::CreateRadial(center, radius, colors1,
+                                                   nullptr, SK_ARRAY_COUNT(colors1),
+                                                   SkShader::kClamp_TileMode,
+                                                   flags[i], nullptr));
+            SkAutoTUnref<SkShader> radial2(
+                    SkGradientShader::CreateRadial(center, radius, colors2,
+                                                   nullptr, SK_ARRAY_COUNT(colors2),
+                                                   SkShader::kClamp_TileMode,
+                                                   flags[i], nullptr));
+            paint1.setShader(sweep);
             paint1.setDither(fDither);
+            paint2.setShader(radial1);
             paint2.setDither(fDither);
+            paint3.setShader(radial2);
             paint3.setDither(fDither);
 
             canvas->drawCircle(cx, cy, radius, paint1);
             canvas->drawCircle(cx, cy, radius, paint3);
             canvas->drawCircle(cx, cy, radius, paint2);
 
             canvas->translate(400, 0);
         }
     }
 
@@ skipping 16 matching lines @@
     }
 
     SkISize onISize() override { return SkISize::Make(500, 500); }
 
     bool runAsBench() const override { return true; }
 
     void onOnceBeforeDraw() override {
         const SkPoint center = { 0, 0 };
         const SkScalar kRadius = 3000;
         const SkColor gColors[] = { 0xFFFFFFFF, 0xFF000000 };
-        fShader = SkGradientShader::MakeRadial(center, kRadius, gColors, nullptr, 2,
-                                               SkShader::kClamp_TileMode);
+        fShader.reset(SkGradientShader::CreateRadial(center, kRadius, gColors, nullptr, 2,
+                                                     SkShader::kClamp_TileMode));
     }
 
     void onDraw(SkCanvas* canvas) override {
         SkPaint paint;
         paint.setShader(fShader);
         paint.setDither(fDither);
         canvas->drawRect(SkRect::MakeWH(500, 500), paint);
     }
     
 private:
-    sk_sp<SkShader> fShader;
+    SkAutoTUnref<SkShader> fShader;
     bool fDither;
 
     typedef GM INHERITED;
 };
 DEF_GM( return new RadialGradient3GM(true); )
 DEF_GM( return new RadialGradient3GM(false); )
 
 class RadialGradient4GM : public GM {
 public:
     RadialGradient4GM(bool dither) : fDither(dither) { }
 
 protected:
     SkString onShortName() override {
         return SkString(fDither ? "radial_gradient4" : "radial_gradient4_nodither");
     }
 
     SkISize onISize() override { return SkISize::Make(500, 500); }
 
     void onOnceBeforeDraw() override {
         const SkPoint center = { 250, 250 };
         const SkScalar kRadius = 250;
         const SkColor colors[] = { SK_ColorRED, SK_ColorRED, SK_ColorWHITE, SK_ColorWHITE,
                 SK_ColorRED };
         const SkScalar pos[] = { 0, .4f, .4f, .8f, .8f, 1 };
-        fShader = SkGradientShader::MakeRadial(center, kRadius, colors, pos,
-                                               SK_ARRAY_COUNT(gColors), SkShader::kClamp_TileMode);
+        fShader.reset(SkGradientShader::CreateRadial(center, kRadius, colors, pos, 
+                SK_ARRAY_COUNT(gColors), SkShader::kClamp_TileMode));
     }
 
     void onDraw(SkCanvas* canvas) override {
         SkPaint paint;
         paint.setAntiAlias(true);
         paint.setDither(fDither);
         paint.setShader(fShader);
         canvas->drawRect(SkRect::MakeWH(500, 500), paint);
     }
     
 private:
-    sk_sp<SkShader> fShader;
+    SkAutoTUnref<SkShader> fShader;
     bool fDither;
 
     typedef GM INHERITED;
 };
 DEF_GM( return new RadialGradient4GM(true); )
 DEF_GM( return new RadialGradient4GM(false); )
 
 class LinearGradientGM : public GM {
 public:
     LinearGradientGM(bool dither) : fDither(dither) { }
@@ skipping 14 matching lines @@
         const SkColor colors[] = { SK_ColorWHITE, SK_ColorWHITE, 0xFF008200, 0xFF008200,
                 SK_ColorWHITE, SK_ColorWHITE };
         const SkScalar unitPos[] = { 0, 50, 70, 500, 540 };
         SkScalar pos[6];
         pos[5] = 1;
         for (int index = 0; index < (int) SK_ARRAY_COUNT(fShader); ++index) {
             pts[1].fX = 500.f + index * kWidthBump;
             for (int inner = 0; inner < (int) SK_ARRAY_COUNT(unitPos); ++inner) {
                 pos[inner] = unitPos[inner] / (kMinWidth + index * kWidthBump);
             }
-            fShader[index] = SkGradientShader::MakeLinear(pts, colors, pos,
-                    SK_ARRAY_COUNT(gColors), SkShader::kClamp_TileMode);
+            fShader[index].reset(SkGradientShader::CreateLinear(pts, colors, pos, 
+                    SK_ARRAY_COUNT(gColors), SkShader::kClamp_TileMode));
         }
     }
 
     void onDraw(SkCanvas* canvas) override {
         SkPaint paint;
         paint.setAntiAlias(true);
         paint.setDither(fDither);
         for (int index = 0; index < (int) SK_ARRAY_COUNT(fShader); ++index) {
             paint.setShader(fShader[index]);
             canvas->drawRect(SkRect::MakeLTRB(0, index * kHeight, kMinWidth + index * kWidthBump,
                     (index + 1) * kHeight), paint);
         }
     }
     
 private:
-    sk_sp<SkShader> fShader[100];
+    SkAutoTUnref<SkShader> fShader[100];
     bool fDither;
 
     typedef GM INHERITED;
 };
 DEF_GM( return new LinearGradientGM(true); )
 DEF_GM( return new LinearGradientGM(false); )
 
 class LinearGradientTinyGM : public GM {
 public:
     LinearGradientTinyGM(uint32_t flags, const char* suffix = nullptr)
@@ skipping 31 matching lines @@
 
             { { SkPoint::Make(0, 0),        SkPoint::Make(0.00001f, 0) }, { 0, 0.5f, 1 }},
             { { SkPoint::Make(9.99999f, 0), SkPoint::Make(10, 0) },       { 0, 0.5f, 1 }},
             { { SkPoint::Make(0, 0),        SkPoint::Make(0, 0.00001f) }, { 0, 0.5f, 1 }},
             { { SkPoint::Make(0, 9.99999f), SkPoint::Make(0, 10) },       { 0, 0.5f, 1 }},
         };
 
         SkPaint paint;
         for (unsigned i = 0; i < SK_ARRAY_COUNT(configs); ++i) {
             SkAutoCanvasRestore acr(canvas, true);
-            paint.setShader(SkGradientShader::MakeLinear(configs[i].pts, colors, configs[i].pos,
-                                                         kStopCount, SkShader::kClamp_TileMode,
-                                                         fFlags, nullptr));
+            SkAutoTUnref<SkShader> gradient(
+                SkGradientShader::CreateLinear(configs[i].pts, colors, configs[i].pos, kStopCount,
+                                               SkShader::kClamp_TileMode, fFlags, nullptr));
             canvas->translate(kRectSize * ((i % 4) * 1.5f + 0.25f),
                               kRectSize * ((i / 4) * 1.5f + 0.25f));
 
+            paint.setShader(gradient);
             canvas->drawRect(SkRect::MakeWH(kRectSize, kRectSize), paint);
         }
     }
 
 private:
     typedef GM INHERITED;
 
     SkString fName;
     uint32_t fFlags;
 };
 DEF_GM( return new LinearGradientTinyGM(0); )
 DEF_GM( return new LinearGradientTinyGM(SkLinearGradient::kForce4fContext_PrivateFlag, "_4f"); )
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 struct GradRun {
     SkColor  fColors[4];
     SkScalar fPos[4];
     int      fCount;
 };
 
 #define SIZE 121
 
-static sk_sp<SkShader> make_linear(const GradRun& run, SkShader::TileMode mode) {
+static SkShader* make_linear(const GradRun& run, SkShader::TileMode mode) {
     const SkPoint pts[] { { 30, 30 }, { SIZE - 30, SIZE - 30 } };
-    return SkGradientShader::MakeLinear(pts, run.fColors, run.fPos, run.fCount, mode);
+    return SkGradientShader::CreateLinear(pts, run.fColors, run.fPos, run.fCount, mode);
 }
 
-static sk_sp<SkShader> make_radial(const GradRun& run, SkShader::TileMode mode) {
+static SkShader* make_radial(const GradRun& run, SkShader::TileMode mode) {
     const SkScalar half = SIZE * 0.5f;
-    return SkGradientShader::MakeRadial({half,half}, half - 10, run.fColors, run.fPos,
-                                        run.fCount, mode);
+    return SkGradientShader::CreateRadial({half,half}, half - 10,
+                                          run.fColors, run.fPos, run.fCount, mode);
 }
 
-static sk_sp<SkShader> make_conical(const GradRun& run, SkShader::TileMode mode) {
+static SkShader* make_conical(const GradRun& run, SkShader::TileMode mode) {
     const SkScalar half = SIZE * 0.5f;
     const SkPoint center { half, half };
-    return SkGradientShader::MakeTwoPointConical(center, 20, center, half - 10,
-                                                 run.fColors, run.fPos, run.fCount, mode);
+    return SkGradientShader::CreateTwoPointConical(center, 20, center, half - 10,
+                                          run.fColors, run.fPos, run.fCount, mode);
 }
 
-static sk_sp<SkShader> make_sweep(const GradRun& run, SkShader::TileMode) {
+static SkShader* make_sweep(const GradRun& run, SkShader::TileMode) {
     const SkScalar half = SIZE * 0.5f;
-    return SkGradientShader::MakeSweep(half, half, run.fColors, run.fPos, run.fCount);
+    return SkGradientShader::CreateSweep(half, half, run.fColors, run.fPos, run.fCount);
 }
 
 /*
  *  Exercise duplicate color-stops, at the ends, and in the middle
  *
  *  At the time of this writing, only Linear correctly deals with duplicates at the ends,
  *  and then only correctly on CPU backend.
  */
 DEF_SIMPLE_GM(gradients_dup_color_stops, canvas, 704, 564) {
     const SkColor preColor  = 0xFFFF0000;   // clamp color before start
@@ skipping 17 matching lines @@
         },
         {   { preColor, color0, color1, postColor },
             { 0, 0, 1, 1 },
             4,
         },
         {   { color0, color0, color1, color1 },
             { 0, 0.5f, 0.5f, 1 },
             4,
         },
     };
-    sk_sp<SkShader> (*factories[])(const GradRun&, SkShader::TileMode) {
+    SkShader* (*factories[])(const GradRun&, SkShader::TileMode) {
         make_linear, make_radial, make_conical, make_sweep
     };
 
     const SkRect rect = SkRect::MakeWH(SIZE, SIZE);
     const SkScalar dx = SIZE + 20;
     const SkScalar dy = SIZE + 20;
     const SkShader::TileMode mode = SkShader::kClamp_TileMode;
 
     SkPaint paint;
     canvas->translate(10, 10 - dy);
     for (auto factory : factories) {
         canvas->translate(0, dy);
         SkAutoCanvasRestore acr(canvas, true);
         for (const auto& run : runs) {
-            paint.setShader(factory(run, mode));
+            paint.setShader(factory(run, mode))->unref();
             canvas->drawRect(rect, paint);
             canvas->translate(dx, 0);
         }
     }
 }
 
 static void draw_many_stops(SkCanvas* canvas, uint32_t flags) {
     const unsigned kStopCount = 200;
     const SkPoint pts[] = { {50, 50}, {450, 465}};
 
     SkColor colors[kStopCount];
     for (unsigned i = 0; i < kStopCount; i++) {
         switch (i % 5) {
         case 0: colors[i] = SK_ColorRED; break;
         case 1: colors[i] = SK_ColorGREEN; break;
         case 2: colors[i] = SK_ColorGREEN; break;
         case 3: colors[i] = SK_ColorBLUE; break;
         case 4: colors[i] = SK_ColorRED; break;
         }
     }
 
+    SkAutoTUnref<SkShader> shader(SkGradientShader::CreateLinear(
+        pts, colors, nullptr, SK_ARRAY_COUNT(colors), SkShader::kClamp_TileMode, flags, nullptr));
+
     SkPaint p;
-    p.setShader(SkGradientShader::MakeLinear(
-        pts, colors, nullptr, SK_ARRAY_COUNT(colors), SkShader::kClamp_TileMode, flags, nullptr));
+    p.setShader(shader);
 
     canvas->drawRect(SkRect::MakeXYWH(0, 0, 500, 500), p);
 }
 
 DEF_SIMPLE_GM(gradient_many_stops, canvas, 500, 500) {
     draw_many_stops(canvas, 0);
 }
 
 DEF_SIMPLE_GM(gradient_many_stops_4f, canvas, 500, 500) {
     draw_many_stops(canvas, SkLinearGradient::kForce4fContext_PrivateFlag);
 }