Update SkColorFilterImageFilter to sk_sp

bench/ImageFilterCollapse.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 "SkBitmap.h"
 #include "SkCanvas.h"
 #include "SkColorFilterImageFilter.h"
 #include "SkColorMatrixFilter.h"
 #include "SkGradientShader.h"
 #include "SkImageFilter.h"
 #include "SkTableColorFilter.h"
 
 // Chains several matrix color filters image filter or several
 // table filter image filters and draws a bitmap.
 // This bench shows an improvement in performance and memory
 // when collapsing matrices or tables is implemented since all
 // the passes are collapsed in one.
 
 class BaseImageFilterCollapseBench : public Benchmark {
 public:
-    BaseImageFilterCollapseBench(): fImageFilter(nullptr) {}
-    ~BaseImageFilterCollapseBench() {
-        SkSafeUnref(fImageFilter);
-    }
+    BaseImageFilterCollapseBench() {}
 
 protected:
     void doPreDraw(sk_sp<SkColorFilter> colorFilters[], int nFilters) {
+        SkASSERT(!fImageFilter);
+
         // Create a chain of ImageFilters from colorFilters
-        fImageFilter = nullptr;
         for(int i = nFilters; i --> 0;) {
-            SkAutoTUnref<SkImageFilter> filter(
-                    SkColorFilterImageFilter::Create(colorFilters[i].get(), fImageFilter, nullptr)
-            );
-            SkRefCnt_SafeAssign(fImageFilter, filter.get());
+            fImageFilter = SkColorFilterImageFilter::Make(colorFilters[i], fImageFilter);
         }
     }
 
     void onDraw(int loops, SkCanvas* canvas) override {
         makeBitmap();
 
         for(int i = 0; i < loops; i++) {
             SkPaint paint;
             paint.setImageFilter(fImageFilter);
             canvas->drawBitmap(fBitmap, 0, 0, &paint);
         }
     }
 
 private:
-    SkImageFilter* fImageFilter;
+    sk_sp<SkImageFilter> fImageFilter;
     SkBitmap fBitmap;
 
     void makeBitmap() {
         int W = 400;
         int H = 400;
         fBitmap.allocN32Pixels(W, H);
         fBitmap.eraseColor(SK_ColorTRANSPARENT);
 
         SkCanvas canvas(fBitmap);
         SkPaint paint;
@@ skipping 24 matching lines @@
             float fi = i / 255.0f;
             table3[i] = static_cast<uint8_t>(sqrtf(fi) * 255);
         }
 
         sk_sp<SkColorFilter> colorFilters[] = {
             SkTableColorFilter::Make(table1),
             SkTableColorFilter::Make(table2),
             SkTableColorFilter::Make(table3),
         };
 
-        doPreDraw(colorFilters, SK_ARRAY_COUNT(colorFilters));
+        this->doPreDraw(colorFilters, SK_ARRAY_COUNT(colorFilters));
     }
 
 private:
     uint8_t table1[256], table2[256], table3[256];
 };
 
 static sk_sp<SkColorFilter> make_brightness(float amount) {
     SkScalar amount255 = SkScalarMul(amount, SkIntToScalar(255));
     SkScalar matrix[20] = { 1, 0, 0, 0, amount255,
                             0, 1, 0, 0, amount255,
@@ skipping 18 matching lines @@
         return "image_filter_collapse_matrix";
     }
 
     void onDelayedSetup() override {
         sk_sp<SkColorFilter> colorFilters[] = {
             make_brightness(0.1f),
             make_grayscale(),
             make_brightness(-0.1f),
         };
 
-        doPreDraw(colorFilters, SK_ARRAY_COUNT(colorFilters));
+        this->doPreDraw(colorFilters, SK_ARRAY_COUNT(colorFilters));
     }
 };
 
 DEF_BENCH(return new TableCollapseBench;)
 DEF_BENCH(return new MatrixCollapseBench;)