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

samplecode/SampleFilterFuzz.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 "SampleCode.h"
 #include "Sk1DPathEffect.h"
 #include "Sk2DPathEffect.h"
 #include "SkAlphaThresholdFilter.h"
@@ skipping 280 matching lines @@
     static SkBitmap bitmap[2];
     static bool initialized = false;
     if (!initialized) {
         make_g_bitmap(bitmap[0]);
         make_checkerboard_bitmap(bitmap[1]);
         initialized = true;
     }
     return bitmap[R(2)];
 }
 
-static SkData* make_3Dlut(int* cubeDimension, bool invR, bool invG, bool invB) {
+static sk_sp<SkData> make_3Dlut(int* cubeDimension, bool invR, bool invG, bool invB) {
     int size = 4 << R(5);
-    SkData* data = SkData::NewUninitialized(sizeof(SkColor) * size * size * size);
+    auto data = SkData::MakeUninitialized(sizeof(SkColor) * size * size * size);
     SkColor* pixels = (SkColor*)(data->writable_data());
     SkAutoTMalloc<uint8_t> lutMemory(size);
     SkAutoTMalloc<uint8_t> invLutMemory(size);
     uint8_t* lut = lutMemory.get();
     uint8_t* invLut = invLutMemory.get();
     const int maxIndex = size - 1;
     for (int i = 0; i < size; i++) {
         lut[i] = (i * 255) / maxIndex;
         invLut[i] = ((maxIndex - i) * 255) / maxIndex;
     }
@@ skipping 29 matching lines @@
     paint.setTextSize(SkIntToScalar(kBitmapSize/3));
     canvas->drawText("Picture", 7, SkIntToScalar(kBitmapSize/2), SkIntToScalar(kBitmapSize/4), paint);
 }
 
 static void rand_color_table(uint8_t* table) {
     for (int i = 0; i < 256; ++i) {
         table[i] = R(256);
     }
 }
 
-static SkColorFilter* make_color_filter() {
-    SkColorFilter* colorFilter;
+static sk_sp<SkColorFilter> make_color_filter() {
     switch (R(6)) {
         case 0: {
             SkScalar array[20];
             for (int i = 0; i < 20; ++i) {
                 array[i] = make_scalar();
             }
-            colorFilter = SkColorMatrixFilter::Create(array);
-            break;
+            return SkColorFilter::MakeMatrixFilterRowMajor255(array);
         }
         case 1:
-            colorFilter = SkLumaColorFilter::Create();
-            break;
+            return SkLumaColorFilter::Make();
         case 2: {
             uint8_t tableA[256];
             uint8_t tableR[256];
             uint8_t tableG[256];
             uint8_t tableB[256];
             rand_color_table(tableA);
             rand_color_table(tableR);
             rand_color_table(tableG);
             rand_color_table(tableB);
-            colorFilter = SkTableColorFilter::CreateARGB(tableA, tableR, tableG, tableB);
-            break;
+            return SkTableColorFilter::MakeARGB(tableA, tableR, tableG, tableB);
         }
         case 3:
-            colorFilter = SkColorFilter::CreateModeFilter(make_color(), make_xfermode());
-            break;
+            return SkColorFilter::MakeModeFilter(make_color(), make_xfermode());
         case 4:
-            colorFilter = SkColorMatrixFilter::CreateLightingFilter(make_color(), make_color());
-            break;
+            return SkColorMatrixFilter::MakeLightingFilter(make_color(), make_color());
         case 5:
         default:
-            colorFilter = nullptr;
             break;
     }
-    return colorFilter;
+    return nullptr;
 }
 
 static SkPath make_path() {
     SkPath path;
     int numOps = R(30);
     for (int i = 0; i < numOps; ++i) {
         switch (R(6)) {
             case 0:
                 path.moveTo(make_scalar(), make_scalar());
                 break;
@@ skipping 130 matching lines @@
     }
 
     SkLayerRasterizer::Builder rasterizerBuilder;
     SkPaint paintForRasterizer;
     if (R(2) == 1) {
         paintForRasterizer = make_paint();
     }
     rasterizerBuilder.addLayer(paintForRasterizer);
     paint.setRasterizer(rasterizerBuilder.detach());
     paint.setImageFilter(make_image_filter());
-    SkAutoDataUnref data(make_3Dlut(nullptr, make_bool(), make_bool(), make_bool()));
+    sk_sp<SkData> data(make_3Dlut(nullptr, make_bool(), make_bool(), make_bool()));
     paint.setTextAlign(make_paint_align());
     paint.setTextSize(make_scalar());
     paint.setTextScaleX(make_scalar());
     paint.setTextSkewX(make_scalar());
     paint.setTextEncoding(make_paint_text_encoding());
     return paint;
 }
 
 static SkImageFilter* make_image_filter(bool canBeNull) {
     SkImageFilter* filter = 0;
 
     // Add a 1 in 3 chance to get a nullptr input
     if (canBeNull && (R(3) == 1)) { return filter; }
 
     enum { ALPHA_THRESHOLD, MERGE, COLOR, LUT3D, BLUR, MAGNIFIER,
            DOWN_SAMPLE, XFERMODE, OFFSET, MATRIX, MATRIX_CONVOLUTION, COMPOSE,
            DISTANT_LIGHT, POINT_LIGHT, SPOT_LIGHT, NOISE, DROP_SHADOW,
            MORPHOLOGY, BITMAP, DISPLACE, TILE, PICTURE, PAINT, NUM_FILTERS };
 
     switch (R(NUM_FILTERS)) {
     case ALPHA_THRESHOLD:
         filter = SkAlphaThresholdFilter::Create(make_region(), make_scalar(), make_scalar());
         break;
     case MERGE:
         filter = SkMergeImageFilter::Create(make_image_filter(), make_image_filter(), make_xfermode());
         break;
     case COLOR:
     {
-        SkAutoTUnref<SkColorFilter> cf(make_color_filter());
-        filter = cf.get() ? SkColorFilterImageFilter::Create(cf, make_image_filter()) : 0;
+        sk_sp<SkColorFilter> cf(make_color_filter());
+        filter = cf ? SkColorFilterImageFilter::Create(cf.get(), make_image_filter()) : 0;
     }
         break;
     case LUT3D:
     {
         int cubeDimension;
-        SkAutoDataUnref lut3D(make_3Dlut(&cubeDimension, (R(2) == 1), (R(2) == 1), (R(2) == 1)));
-        SkAutoTUnref<SkColorFilter> cf(SkColorCubeFilter::Create(lut3D, cubeDimension));
-        filter = cf.get() ? SkColorFilterImageFilter::Create(cf, make_image_filter()) : 0;
+        sk_sp<SkData> lut3D(make_3Dlut(&cubeDimension, (R(2) == 1), (R(2) == 1), (R(2) == 1)));
+        sk_sp<SkColorFilter> cf(SkColorCubeFilter::Make(lut3D, cubeDimension));
+        filter = cf ? SkColorFilterImageFilter::Create(cf.get(), make_image_filter()) : 0;
     }
         break;
     case BLUR:
         filter = SkBlurImageFilter::Create(make_scalar(true), make_scalar(true), make_image_filter());
         break;
     case MAGNIFIER:
         filter = SkMagnifierImageFilter::Create(make_rect(), make_scalar(true));
         break;
     case DOWN_SAMPLE:
         filter = SkDownSampleImageFilter::Create(make_scalar());
@@ skipping 222 matching lines @@
     }
 
 private:
     typedef SkView INHERITED;
 };
 
 //////////////////////////////////////////////////////////////////////////////
 
 static SkView* MyFactory() { return new ImageFilterFuzzView; }
 static SkViewRegister reg(MyFactory);