partial switch over to sp usage of shaders

gm/bleed.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 "SkBlurMask.h"
 #include "SkBlurMaskFilter.h"
@@ skipping 259 matching lines @@
                                                        int width, int height) {
     static const uint8_t kZero = 0x00;
     static const uint8_t kHalf = 0x80;
     static const uint8_t k3Q   = 0xC0;
     static const uint8_t kOne  = 0xFF;
     static const uint8_t k1Q   = 0x40;
     return make_oversized_texture_bitmap<uint8_t>(
         ctx, result, width, height, kAlpha_8_GrPixelConfig, kZero, kOne, k3Q, kHalf, k1Q);
 }
 
-static SkShader* make_shader() {
+static sk_sp<SkShader> make_shader() {
     static const SkPoint pts[] = { {0, 0}, {20, 20} };
     static const SkColor colors[] = { SK_ColorGREEN, SK_ColorYELLOW };
-    return SkGradientShader::CreateLinear(pts, colors, nullptr, 2, SkShader::kMirror_TileMode);
+    return SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kMirror_TileMode);
 }
 
-static SkShader* make_null_shader() { return nullptr; }
+static sk_sp<SkShader> make_null_shader() { return nullptr; }
 
 enum BleedTest {
     kUseBitmap_BleedTest,
     kUseTextureBitmap_BleedTest,
     kUseImage_BleedTest,
     kUseAlphaBitmap_BleedTest,
     kUseAlphaTextureBitmap_BleedTest,
     kUseAlphaImage_BleedTest,
     kUseAlphaBitmapShader_BleedTest,
     kUseAlphaTextureBitmapShader_BleedTest,
     kUseAlphaImageShader_BleedTest,
 };
 
 const struct {
     const char* fName;
     bool (*fPixelMaker)(GrContext*, TestPixels* result, int width, int height);
-    SkShader* (*fShaderMaker)();
+    sk_sp<SkShader> (*fShaderMaker)();
 } gBleedRec[] = {
     { "bleed",                          make_ringed_color_bitmap,                   make_null_shader },
     { "bleed_texture_bmp",              make_ringed_oversized_color_texture_bitmap, make_null_shader },
     { "bleed_image",                    make_ringed_color_image,                    make_null_shader },
     { "bleed_alpha_bmp",                make_ringed_alpha_bitmap,                   make_null_shader },
     { "bleed_alpha_texture_bmp",        make_ringed_oversized_alpha_texture_bitmap, make_null_shader },
     { "bleed_alpha_image",              make_ringed_alpha_image,                    make_null_shader },
     { "bleed_alpha_bmp_shader",         make_ringed_alpha_bitmap,                   make_shader      },
     { "bleed_alpha_texture_bmp_shader", make_ringed_oversized_alpha_texture_bitmap, make_shader      },
     { "bleed_alpha_image_shader",       make_ringed_alpha_image,                    make_shader      },
@@ skipping 147 matching lines @@
             fCreatedPixels = madePixels;
         }
 
         // Assume that if we coulnd't make the bitmap/image it's because it's a GPU test on a
         // non-GPU backend.
         if (!madePixels) {
             skiagm::GM::DrawGpuOnlyMessage(canvas);
             return;
         }
 
-        fShader.reset(gBleedRec[fBT].fShaderMaker());
+        fShader = gBleedRec[fBT].fShaderMaker();
 
         canvas->clear(SK_ColorGRAY);
         SkTDArray<SkMatrix> matrices;
         // Draw with identity
         *matrices.append() = SkMatrix::I();
 
         // Draw with rotation and scale down in x, up in y.
         SkMatrix m;
         static const SkScalar kBottom = SkIntToScalar(kRow4Y + kBlockSize + kBlockSpacing);
         m.setTranslate(0, kBottom);
@@ skipping 93 matching lines @@
 
     static const int kRow0Y = kBlockSpacing;
     static const int kRow1Y = 2*kBlockSpacing + kBlockSize;
     static const int kRow2Y = 3*kBlockSpacing + 2*kBlockSize;
     static const int kRow3Y = 4*kBlockSpacing + 3*kBlockSize;
     static const int kRow4Y = 5*kBlockSpacing + 4*kBlockSize;
 
     static const int kSmallTextureSize = 6;
     static const int kMaxTileSize = 32;
 
-    bool                    fCreatedPixels;
-    TestPixels              fBigTestPixels;
-    TestPixels              fSmallTestPixels;
+    bool            fCreatedPixels;
+    TestPixels      fBigTestPixels;
+    TestPixels      fSmallTestPixels;
 
-    SkAutoTUnref<SkShader>  fShader;
+    sk_sp<SkShader> fShader;
 
-    const BleedTest         fBT;
+    const BleedTest fBT;
 
     typedef GM INHERITED;
 };
 
 
 DEF_GM( return new BleedGM(kUseBitmap_BleedTest); )
 DEF_GM( return new BleedGM(kUseTextureBitmap_BleedTest); )
 DEF_GM( return new BleedGM(kUseImage_BleedTest); )
 DEF_GM( return new BleedGM(kUseAlphaBitmap_BleedTest); )
 DEF_GM( return new BleedGM(kUseAlphaTextureBitmap_BleedTest); )
 DEF_GM( return new BleedGM(kUseAlphaImage_BleedTest); )
 DEF_GM( return new BleedGM(kUseAlphaBitmapShader_BleedTest); )
 DEF_GM( return new BleedGM(kUseAlphaTextureBitmapShader_BleedTest); )
 DEF_GM( return new BleedGM(kUseAlphaImageShader_BleedTest); )