Reland of [2] of "switch colorfilters to sk_sp (patchset #11 id:200001 of https://codereview.chromium.o…

gm/tablecolorfilter.cpp

 /*
  * Copyright 2011 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 "SkCanvas.h"
 #include "SkColorFilterImageFilter.h"
@@ skipping 55 matching lines @@
         table[i] = i * i / 255;
     }
 }
 static void make_table2(uint8_t table[]) {
     for (int i = 0; i < 256; ++i) {
         float fi = i / 255.0f;
         table[i] = static_cast<uint8_t>(sqrtf(fi) * 255);
     }
 }
 
-static SkColorFilter* make_null_cf() {
+static sk_sp<SkColorFilter> make_null_cf() {
     return nullptr;
 }
 
-static SkColorFilter* make_cf0() {
+static sk_sp<SkColorFilter> make_cf0() {
     uint8_t table[256]; make_table0(table);
-    return SkTableColorFilter::Create(table);
+    return SkTableColorFilter::Make(table);
 }
-static SkColorFilter* make_cf1() {
+static sk_sp<SkColorFilter> make_cf1() {
     uint8_t table[256]; make_table1(table);
-    return SkTableColorFilter::Create(table);
+    return SkTableColorFilter::Make(table);
 }
-static SkColorFilter* make_cf2() {
+static sk_sp<SkColorFilter> make_cf2() {
     uint8_t table[256]; make_table2(table);
-    return SkTableColorFilter::Create(table);
+    return SkTableColorFilter::Make(table);
 }
-static SkColorFilter* make_cf3() {
+static sk_sp<SkColorFilter> make_cf3() {
     uint8_t table0[256]; make_table0(table0);
     uint8_t table1[256]; make_table1(table1);
     uint8_t table2[256]; make_table2(table2);
-    return SkTableColorFilter::CreateARGB(nullptr, table0, table1, table2);
+    return SkTableColorFilter::MakeARGB(nullptr, table0, table1, table2);
 }
 
 class TableColorFilterGM : public skiagm::GM {
 public:
     TableColorFilterGM() {}
 
 protected:
     virtual SkString onShortName() {
         return SkString("tablecolorfilter");
     }
 
     virtual SkISize onISize() {
         return SkISize::Make(700, 1650);
     }
 
     virtual void onDraw(SkCanvas* canvas) {
         canvas->drawColor(sk_tool_utils::color_to_565(0xFFDDDDDD));
         canvas->translate(20, 20);
 
 
-        static SkColorFilter* (*gColorFilterMakers[])() = { make_null_cf, make_cf0, make_cf1,
-                                                 make_cf2, make_cf3 };
+        static sk_sp<SkColorFilter> (*gColorFilterMakers[])() = {
+            make_null_cf, make_cf0, make_cf1, make_cf2, make_cf3
+        };
         static void (*gBitmapMakers[])(SkBitmap*) = { make_bm0, make_bm1 };
 
         // This test will be done once for each bitmap with the results stacked vertically.
         // For a single bitmap the resulting image will be the following:
         //  - A first line with the original bitmap, followed by the image drawn once
         //  with each of the N color filters
         //  - N lines of the bitmap drawn N times, this will cover all N*N combinations of
         //  pair of color filters in order to test the collpsing of consecutive table
         //  color filters.
         //
@@ skipping 19 matching lines @@
 
             // Draw the first element of the first line
             x = 0;
             SkPaint paint;
             canvas->drawBitmap(bm, x, y, &paint);
 
             // Draws the rest of the first line for this bitmap
             // each draw being at xOffset of the previous one
             for (unsigned i = 1; i < SK_ARRAY_COUNT(gColorFilterMakers); ++i) {
                 x += xOffset;
-                paint.setColorFilter(gColorFilterMakers[i]())->unref();
+                paint.setColorFilter(gColorFilterMakers[i]());
                 canvas->drawBitmap(bm, x, y, &paint);
             }
 
             paint.setColorFilter(nullptr);
 
             for (unsigned i = 0; i < SK_ARRAY_COUNT(gColorFilterMakers); ++i) {
-                SkAutoTUnref<SkColorFilter> colorFilter1(gColorFilterMakers[i]());
+                auto colorFilter1(gColorFilterMakers[i]());
                 SkAutoTUnref<SkImageFilter> imageFilter1(SkColorFilterImageFilter::Create(
-                            colorFilter1, nullptr, nullptr));
+                            colorFilter1.get(), nullptr, nullptr));
 
                 // Move down to the next line and draw it
                 // each draw being at xOffset of the previous one
                 y += yOffset;
                 x = 0;
                 for (unsigned j = 1; j < SK_ARRAY_COUNT(gColorFilterMakers); ++j) {
-                    SkAutoTUnref<SkColorFilter> colorFilter2(gColorFilterMakers[j]());
+                    auto colorFilter2(gColorFilterMakers[j]());
                     SkAutoTUnref<SkImageFilter> imageFilter2(SkColorFilterImageFilter::Create(
-                                colorFilter2, imageFilter1, nullptr));
+                                colorFilter2.get(), imageFilter1, nullptr));
                     paint.setImageFilter(imageFilter2);
                     canvas->drawBitmap(bm, x, y, &paint);
                     x += xOffset;
                 }
             }
 
             // Move down one line to the beginning of the block for next bitmap
             y += yOffset;
         }
     }
@@ skipping 31 matching lines @@
         return SkISize::Make(790, 790);
     }
 
     virtual void onDraw(SkCanvas* canvas) {
         SkBitmap bm;
         make_bm1(&bm);
 
         canvas->drawColor(sk_tool_utils::color_to_565(0xFFDDDDDD));
 
         const int MODES = MODE_COUNT * COLOR_COUNT;
-        SkAutoTUnref<SkColorFilter> filters[MODES];
+        sk_sp<SkColorFilter> filters[MODES];
         int index = 0;
         for (int i = 0; i < MODE_COUNT; ++i) {
             for (int j = 0; j < COLOR_COUNT; ++j) {
-                filters[index++].reset(SkColorFilter::CreateModeFilter(fColors[j], fModes[i]));
+                filters[index++] = SkColorFilter::MakeModeFilter(fColors[j], fModes[i]);
             }
         }
 
         SkPaint paint;
         paint.setShader(make_shader1(50, 50));
         SkRect r = SkRect::MakeWH(50, 50);
         const SkScalar spacer = 10;
 
         canvas->translate(spacer, spacer);
 
@@ skipping 11 matching lines @@
             canvas->translate(0, (i + 1) * (r.width() + spacer));
             canvas->drawRect(r, paint);
             canvas->restore();
         }
 
         canvas->translate(r.width() + spacer, r.width() + spacer);
 
         for (int y = 0; y < MODES; ++y) {
             canvas->save();
             for (int x = 0; x < MODES; ++x) {
-                SkAutoTUnref<SkColorFilter> compose(SkColorFilter::CreateComposeFilter(filters[y],
-                                                                                       filters[x]));
-                paint.setColorFilter(compose);
+                paint.setColorFilter(SkColorFilter::MakeComposeFilter(filters[y], filters[x]));
                 canvas->drawRect(r, paint);
                 canvas->translate(r.width() + spacer, 0);
             }
             canvas->restore();
             canvas->translate(0, r.height() + spacer);
         }
     }
     
 private:
     typedef GM INHERITED;
 };
 
 const SkColor gColors0[] = { SK_ColorCYAN, SK_ColorMAGENTA, SK_ColorYELLOW };
 const SkXfermode::Mode gModes0[] = {
     SkXfermode::kOverlay_Mode,
     SkXfermode::kDarken_Mode,
     SkXfermode::kColorBurn_Mode,
     SkXfermode::kExclusion_Mode,
 };
 DEF_GM( return new ComposeColorFilterGM(gColors0, gModes0, "wacky"); )
 
 const SkColor gColors1[] = { 0x80FF0000, 0x8000FF00, 0x800000FF };
 const SkXfermode::Mode gModes1[] = {
     SkXfermode::kSrcOver_Mode,
     SkXfermode::kXor_Mode,
     SkXfermode::kDstOut_Mode,
     SkXfermode::kSrcATop_Mode,
 };
 DEF_GM( return new ComposeColorFilterGM(gColors1, gModes1, "alpha"); )