Revert of switch colorfilters to sk_sp

bench/ColorCubeBench.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 "SkColorCubeFilter.h"
 #include "SkGradientShader.h"
 #include "SkTemplates.h"
 
 class ColorCubeBench : public Benchmark {
     SkISize fSize;
     int fCubeDimension;
-    sk_sp<SkData> fCubeData;
+    SkData* fCubeData;
     SkBitmap fBitmap;
 
 public:
-    ColorCubeBench() : fCubeDimension(0) {
+    ColorCubeBench()
+     : fCubeDimension(0)
+     , fCubeData(nullptr) {
         fSize = SkISize::Make(2880, 1800); // 2014 Macbook Pro resolution
     }
 
+    ~ColorCubeBench() {
+        SkSafeUnref(fCubeData);
+    }
+
 protected:
     const char* onGetName() override {
         return "colorcube";
     }
 
     void onDelayedSetup() override {
         if (!SkToBool(fCubeData)) {
             this->makeCubeData();
             this->make_bitmap();
         }
@@ skipping 24 matching lines @@
         canvas.clear(0x00000000);
         SkPaint paint;
         paint.setAntiAlias(true);
         paint.setShader(MakeLinear(fSize));
         SkRect r = { 0, 0, SkIntToScalar(fSize.width()), SkIntToScalar(fSize.height()) };
         canvas.drawRect(r, paint);
     }
 
     void makeCubeData() {
         fCubeDimension = 32;
-        fCubeData = SkData::MakeUninitialized(sizeof(SkColor) *
+        fCubeData = SkData::NewUninitialized(sizeof(SkColor) *
             fCubeDimension * fCubeDimension * fCubeDimension);
         SkColor* pixels = (SkColor*)(fCubeData->writable_data());
         SkAutoTMalloc<uint8_t> lutMemory(fCubeDimension);
         uint8_t* lut = lutMemory.get();
         const int maxIndex = fCubeDimension - 1;
         for (int i = 0; i < fCubeDimension; ++i) {
             // Make an invert lut, but the content of
             // the lut shouldn't affect performance.
             lut[i] = ((maxIndex - i) * 255) / maxIndex;
         }
         for (int r = 0; r < fCubeDimension; ++r) {
             for (int g = 0; g < fCubeDimension; ++g) {
                 for (int b = 0; b < fCubeDimension; ++b) {
                     pixels[(fCubeDimension * ((fCubeDimension * b) + g)) + r] =
                         SkColorSetARGB(0xFF, lut[r], lut[g], lut[b]);
                 }
             }
         }
     }
 
     void test(int loops, SkCanvas* canvas) {
         SkPaint paint;
         for (int i = 0; i < loops; i++) {
-            paint.setColorFilter(SkColorCubeFilter::Make(fCubeData, fCubeDimension));
+            SkAutoTUnref<SkColorFilter> colorCube(
+                SkColorCubeFilter::Create(fCubeData, fCubeDimension));
+            paint.setColorFilter(colorCube);
             canvas->drawBitmap(fBitmap, 0, 0, &paint);
         }
     }
 
     typedef Benchmark INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 DEF_BENCH( return new ColorCubeBench(); )