Revert of Finish conversion to sk_sp<SkShader>

bench/AlternatingColorPatternBench.cpp

 /*
  * Copyright 2014 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 "SkGradientShader.h"
@@ skipping 33 matching lines @@
     SkScalar    s = SkIntToScalar(SkMin32(w, h));
     static const SkPoint     kPts0[] = { { 0, 0 }, { s, s } };
     static const SkPoint     kPts1[] = { { s/2, 0 }, { s/2, s } };
     static const SkScalar    kPos[] = { 0, SK_Scalar1/2, SK_Scalar1 };
     static const SkColor kColors0[] = {0x80F00080, 0xF0F08000, 0x800080F0 };
     static const SkColor kColors1[] = {0xF08000F0, 0x8080F000, 0xF000F080 };
 
 
     SkPaint     paint;
 
-    paint.setShader(SkGradientShader::MakeLinear(kPts0, kColors0, kPos, SK_ARRAY_COUNT(kColors0),
-                                                 SkShader::kClamp_TileMode));
+    paint.setShader(SkGradientShader::CreateLinear(kPts0, kColors0, kPos,
+                    SK_ARRAY_COUNT(kColors0), SkShader::kClamp_TileMode))->unref();
     canvas.drawPaint(paint);
-    paint.setShader(SkGradientShader::MakeLinear(kPts1, kColors1, kPos, SK_ARRAY_COUNT(kColors1),
-                                                 SkShader::kClamp_TileMode));
+    paint.setShader(SkGradientShader::CreateLinear(kPts1, kColors1, kPos,
+                    SK_ARRAY_COUNT(kColors1), SkShader::kClamp_TileMode))->unref();
     canvas.drawPaint(paint);
 }
 
 /**
  * This bench draws a grid of either rects or filled paths, with two alternating color patterns.
  * This color patterns are passed in as enums to the class. The options are:
  *   1) solid white color
  *   2) solid blue color
  *   3) opaque bitmap
  *   4) partial alpha bitmap
  * The same color pattern can be set for both arguments to create a uniform pattern on all draws.
  *
  * The bench is used to test a few things. First it can test any optimizations made for a specific
  * color pattern (for example drawing an opaque bitmap versus one with partial alpha). Also it can
  * be used to test the cost of program switching and/or batching when alternating between different
  * patterns when on the gpu.
  */
 class AlternatingColorPatternBench : public Benchmark {
 public:
     enum {
         NX = 5,
         NY = 5,
         NUM_DRAWS = NX * NY,
     };
-    sk_sp<SkShader> fBmShader;
+    SkShader* fBmShader;
 
     SkPath  fPaths[NUM_DRAWS];
     SkRect  fRects[NUM_DRAWS];
     SkColor fColors[NUM_DRAWS];
-    sk_sp<SkShader> fShaders[NUM_DRAWS];
+    SkShader* fShaders[NUM_DRAWS];
 
     SkString        fName;
     ColorPatternData    fPattern1;
     ColorPatternData    fPattern2;
     DrawType fDrawType;
     SkBitmap fBmp;
 
 
-    AlternatingColorPatternBench(ColorPattern pattern1, ColorPattern pattern2, DrawType drawType) {
+    AlternatingColorPatternBench(ColorPattern pattern1, ColorPattern pattern2, DrawType drawType)
+        : fBmShader(nullptr) {
         fPattern1 = gColorPatterns[pattern1];
         fPattern2 = gColorPatterns[pattern2];
         fName.printf("colorPattern_%s_%s_%s",
                      fPattern1.fName, fPattern2.fName,
                      kRect_DrawType == drawType ? "rect" : "path");
         fDrawType = drawType;
     }
 
+    virtual ~AlternatingColorPatternBench() {
+        SkSafeUnref(fBmShader);
+    }
+
 protected:
     const char* onGetName() override {
         return fName.c_str();
     }
 
     void onDelayedSetup() override {
         int w = 40;
         int h = 40;
         makebm(&fBmp, w, h);
-        fBmShader = SkShader::MakeBitmapShader(fBmp,
+        fBmShader = SkShader::CreateBitmapShader(fBmp,
                                                  SkShader::kRepeat_TileMode,
                                                  SkShader::kRepeat_TileMode);
         int offset = 2;
         int count = 0;
         for (int j = 0; j < NY; ++j) {
             for (int i = 0; i < NX; ++i) {
                 int x = (w + offset) * i;
                 int y = (h * offset) * j;
                 if (kRect_DrawType == fDrawType) {
                     fRects[count].set(SkIntToScalar(x), SkIntToScalar(y),
@@ skipping 60 matching lines @@
 
 DEF_BENCH(return new AlternatingColorPatternBench(kOpaqueBitmap_ColorPattern,
                                                   kOpaqueBitmap_ColorPattern,
                                                   kRect_DrawType);)
 DEF_BENCH(return new AlternatingColorPatternBench(kAlphaBitmap_ColorPattern,
                                                   kAlphaBitmap_ColorPattern,
                                                   kRect_DrawType);)
 DEF_BENCH(return new AlternatingColorPatternBench(kOpaqueBitmap_ColorPattern,
                                                   kAlphaBitmap_ColorPattern,
                                                   kRect_DrawType);)