Revert of more shader-->sp conversions

gm/gradients_no_texture.cpp

 /*
  * Copyright 2013 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"
 
 using namespace skiagm;
 
 struct GradData {
     int             fCount;
     const SkColor*  fColors;
     const SkScalar* fPos;
 };
 
 static const SkColor gColors[] = {
     SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorWHITE,
 };
 
 static const GradData gGradData[] = {
     { 1, gColors, nullptr },
     { 2, gColors, nullptr },
     { 3, gColors, nullptr },
     { 4, gColors, nullptr },
 };
 
-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* 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> MakeRadial(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
+static 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::MakeRadial(center, center.fX, data.fColors, data.fPos, data.fCount, tm);
+    return SkGradientShader::CreateRadial(center, center.fX, data.fColors,
+                                          data.fPos, data.fCount, tm);
 }
 
-static sk_sp<SkShader> MakeSweep(const SkPoint pts[2], const GradData& data, SkShader::TileMode) {
+static SkShader* MakeSweep(const SkPoint pts[2], const GradData& data, SkShader::TileMode) {
     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);
+    return SkGradientShader::CreateSweep(center.fX, center.fY, data.fColors, data.fPos, data.fCount);
 }
 
-static sk_sp<SkShader> Make2Radial(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
+static SkShader* Make2Radial(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::MakeTwoPointConical(
+    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);
 }
 
-static sk_sp<SkShader> Make2Conical(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
+static SkShader* Make2Conical(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm) {
     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,
+    return SkGradientShader::CreateTwoPointConical(center1, radius1,
                                                    center0, radius0,
                                                    data.fColors, data.fPos,
                                                    data.fCount, tm);
 }
 
 
-typedef sk_sp<SkShader> (*GradMaker)(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm);
+typedef SkShader* (*GradMaker)(const SkPoint pts[2], const GradData& data, SkShader::TileMode tm);
 
 static const GradMaker gGradMakers[] = {
     MakeLinear, MakeRadial, MakeSweep, Make2Radial, Make2Conical,
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class GradientsNoTextureGM : public GM {
 public:
     GradientsNoTextureGM(bool dither) : fDither(dither) {
@@ skipping 16 matching lines @@
         SkPaint paint;
         paint.setAntiAlias(true);
         paint.setDither(fDither);
 
         canvas->translate(SkIntToScalar(20), SkIntToScalar(20));
         static const uint8_t kAlphas[] = { 0xff, 0x40 };
         for (size_t a = 0; a < SK_ARRAY_COUNT(kAlphas); ++a) {
             for (size_t i = 0; i < SK_ARRAY_COUNT(gGradData); ++i) {
                 canvas->save();
                 for (size_t j = 0; j < SK_ARRAY_COUNT(gGradMakers); ++j) {
-                    paint.setShader(gGradMakers[j](kPts, gGradData[i], kTM));
+                    SkShader* shader = gGradMakers[j](kPts, gGradData[i], kTM);
+                    paint.setShader(shader)->unref();
                     paint.setAlpha(kAlphas[a]);
                     canvas->drawRect(kRect, paint);
                     canvas->translate(0, SkIntToScalar(kRect.height() + 20));
                 }
                 canvas->restore();
                 canvas->translate(SkIntToScalar(kRect.width() + 20), 0);
             }
         }
     }
 
@@ skipping 127 matching lines @@
         for (int i = 0; i <= 8; ++i) {
             SkScalar x = r.width() * i / 8;
             canvas->drawLine(x, 0, x, 10000, paint);
         }
 
         // expand the drawing rect so we exercise clampping in the gradients
         const SkRect drawR = r.makeOutset(20, 0);
         for (size_t i = 0; i < SK_ARRAY_COUNT(procs); ++i) {
             ColorPos rec;
             procs[i](&rec);
-            paint.setShader(SkGradientShader::MakeLinear(pts, rec.fColors, rec.fPos, rec.fCount,
-                                                         SkShader::kClamp_TileMode));
+            SkShader* s = SkGradientShader::CreateLinear(pts, rec.fColors, rec.fPos, rec.fCount,
+                                                         SkShader::kClamp_TileMode);
+            paint.setShader(s)->unref();
             canvas->drawRect(drawR, paint);
 
             canvas->save();
             canvas->translate(r.centerX(), r.height() + 4);
             canvas->scale(-1, 1);
             canvas->translate(-r.centerX(), 0);
             canvas->drawRect(drawR, paint);
             canvas->restore();
 
             canvas->translate(0, r.height() + 2*r.height() + 8);
         }
     }
 
 private:
     bool fDither;
 
     typedef GM INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 DEF_GM(return new GradientsNoTextureGM(true);)
 DEF_GM(return new GradientsNoTextureGM(false);)
 DEF_GM(return new GradientsManyColorsGM(true);)
 DEF_GM(return new GradientsManyColorsGM(false);)