switch colorfilters to sk_sp

tests/ImageFilterTest.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 "SkBitmap.h"
 #include "SkBitmapDevice.h"
@@ skipping 119 matching lines @@
 
     return surface->makeImageSnapshot();
 }
 
 static SkImageFilter* make_scale(float amount, SkImageFilter* input = nullptr) {
     SkScalar s = amount;
     SkScalar matrix[20] = { s, 0, 0, 0, 0,
                             0, s, 0, 0, 0,
                             0, 0, s, 0, 0,
                             0, 0, 0, s, 0 };
-    SkAutoTUnref<SkColorFilter> filter(SkColorMatrixFilter::Create(matrix));
-    return SkColorFilterImageFilter::Create(filter, input);
+    auto filter(SkColorFilter::MakeMatrixFilterRowMajor255(matrix));
+    return SkColorFilterImageFilter::Create(filter.get(), input);
 }
 
 static SkImageFilter* make_grayscale(SkImageFilter* input, const SkImageFilter::CropRect* cropRect) {
     SkScalar matrix[20];
     memset(matrix, 0, 20 * sizeof(SkScalar));
     matrix[0] = matrix[5] = matrix[10] = 0.2126f;
     matrix[1] = matrix[6] = matrix[11] = 0.7152f;
     matrix[2] = matrix[7] = matrix[12] = 0.0722f;
     matrix[18] = 1.0f;
-    SkAutoTUnref<SkColorFilter> filter(SkColorMatrixFilter::Create(matrix));
-    return SkColorFilterImageFilter::Create(filter, input, cropRect);
+    auto filter(SkColorFilter::MakeMatrixFilterRowMajor255(matrix));
+    return SkColorFilterImageFilter::Create(filter.get(), input, cropRect);
 }
 
 static SkImageFilter* make_blue(SkImageFilter* input, const SkImageFilter::CropRect* cropRect) {
-    SkAutoTUnref<SkColorFilter> filter(SkColorFilter::CreateModeFilter(SK_ColorBLUE,
-                                                                       SkXfermode::kSrcIn_Mode));
-    return SkColorFilterImageFilter::Create(filter, input, cropRect);
+    auto filter(SkColorFilter::MakeModeFilter(SK_ColorBLUE, SkXfermode::kSrcIn_Mode));
+    return SkColorFilterImageFilter::Create(filter.get(), input, cropRect);
 }
 
 static sk_sp<SkSpecialSurface> create_empty_special_surface(GrContext* context,
                                                             SkImageFilter::Proxy* proxy,
                                                             int widthHeight) {
     if (context) {
         GrSurfaceDesc desc;
         desc.fConfig = kSkia8888_GrPixelConfig;
         desc.fFlags  = kRenderTarget_GrSurfaceFlag;
         desc.fWidth  = widthHeight;
@@ skipping 82 matching lines @@
         REPORTER_ASSERT(reporter, false == grayWithCrop->asColorFilter(nullptr));
     }
 
     {
         // Check that two non-commutative matrices are concatenated in
         // the correct order.
         SkScalar blueToRedMatrix[20] = { 0 };
         blueToRedMatrix[2] = blueToRedMatrix[18] = SK_Scalar1;
         SkScalar redToGreenMatrix[20] = { 0 };
         redToGreenMatrix[5] = redToGreenMatrix[18] = SK_Scalar1;
-        SkAutoTUnref<SkColorFilter> blueToRed(SkColorMatrixFilter::Create(blueToRedMatrix));
+        auto blueToRed(SkColorFilter::MakeMatrixFilterRowMajor255(blueToRedMatrix));
         SkAutoTUnref<SkImageFilter> filter1(SkColorFilterImageFilter::Create(blueToRed.get()));
-        SkAutoTUnref<SkColorFilter> redToGreen(SkColorMatrixFilter::Create(redToGreenMatrix));
+        auto redToGreen(SkColorFilter::MakeMatrixFilterRowMajor255(redToGreenMatrix));
         SkAutoTUnref<SkImageFilter> filter2(SkColorFilterImageFilter::Create(redToGreen.get(), filter1.get()));
 
         SkBitmap result;
         result.allocN32Pixels(kBitmapSize, kBitmapSize);
 
         SkPaint paint;
         paint.setColor(SK_ColorBLUE);
         paint.setImageFilter(filter2.get());
         SkCanvas canvas(result);
         canvas.clear(0x0);
@@ skipping 39 matching lines @@
     // Check that all filters offset to their absolute crop rect,
     // unaffected by the input crop rect.
     // Tests pass by not asserting.
     sk_sp<SkSpecialImage> srcImg(create_empty_special_image(context, proxy, 100));
     SkASSERT(srcImg);
 
     SkImageFilter::CropRect inputCropRect(SkRect::MakeXYWH(8, 13, 80, 80));
     SkImageFilter::CropRect cropRect(SkRect::MakeXYWH(20, 30, 60, 60));
     SkAutoTUnref<SkImageFilter> input(make_grayscale(nullptr, &inputCropRect));
 
-    SkAutoTUnref<SkColorFilter> cf(SkColorFilter::CreateModeFilter(SK_ColorRED, SkXfermode::kSrcIn_Mode));
+    auto cf(SkColorFilter::MakeModeFilter(SK_ColorRED, SkXfermode::kSrcIn_Mode));
     SkPoint3 location = SkPoint3::Make(0, 0, SK_Scalar1);
     SkScalar kernel[9] = {
         SkIntToScalar( 1), SkIntToScalar( 1), SkIntToScalar( 1),
         SkIntToScalar( 1), SkIntToScalar(-7), SkIntToScalar( 1),
         SkIntToScalar( 1), SkIntToScalar( 1), SkIntToScalar( 1),
     };
     SkISize kernelSize = SkISize::Make(3, 3);
     SkScalar gain = SK_Scalar1, bias = 0;
 
     SkImageFilter* filters[] = {
@@ skipping 223 matching lines @@
 DEF_GPUTEST_FOR_NATIVE_CONTEXT(TestZeroBlurSigma_Gpu, reporter, context) {
     run_gpu_test(reporter, context, 100, test_zero_blur_sigma);
 }
 #endif
 
 DEF_TEST(ImageFilterDrawTiled, reporter) {
     // Check that all filters when drawn tiled (with subsequent clip rects) exactly
     // match the same filters drawn with a single full-canvas bitmap draw.
     // Tests pass by not asserting.
 
-    SkAutoTUnref<SkColorFilter> cf(SkColorFilter::CreateModeFilter(SK_ColorRED, SkXfermode::kSrcIn_Mode));
+    auto cf(SkColorFilter::MakeModeFilter(SK_ColorRED, SkXfermode::kSrcIn_Mode));
     SkPoint3 location = SkPoint3::Make(0, 0, SK_Scalar1);
     SkScalar kernel[9] = {
         SkIntToScalar( 1), SkIntToScalar( 1), SkIntToScalar( 1),
         SkIntToScalar( 1), SkIntToScalar(-7), SkIntToScalar( 1),
         SkIntToScalar( 1), SkIntToScalar( 1), SkIntToScalar( 1),
     };
     const SkISize kernelSize = SkISize::Make(3, 3);
     const SkScalar gain = SK_Scalar1, bias = 0;
     const SkScalar five = SkIntToScalar(5);
 
@@ skipping 108 matching lines @@
         SkSafeUnref(filters[i].fFilter);
     }
 }
 
 static void draw_saveLayer_picture(int width, int height, int tileSize,
                                    SkBBHFactory* factory, SkBitmap* result) {
 
     SkMatrix matrix;
     matrix.setTranslate(SkIntToScalar(50), 0);
 
-    SkAutoTUnref<SkColorFilter> cf(SkColorFilter::CreateModeFilter(SK_ColorWHITE, SkXfermode::kSrc_Mode));
+    auto cf(SkColorFilter::MakeModeFilter(SK_ColorWHITE, SkXfermode::kSrc_Mode));
     SkAutoTUnref<SkImageFilter> cfif(SkColorFilterImageFilter::Create(cf.get()));
     SkAutoTUnref<SkImageFilter> imageFilter(SkImageFilter::CreateMatrixFilter(matrix, kNone_SkFilterQuality, cfif.get()));
 
     SkPaint paint;
     paint.setImageFilter(imageFilter.get());
     SkPictureRecorder recorder;
     SkRect bounds = SkRect::Make(SkIRect::MakeXYWH(0, 0, 50, 50));
     SkCanvas* recordingCanvas = recorder.beginRecording(SkIntToScalar(width),
                                                         SkIntToScalar(height),
                                                         factory, 0);
@@ skipping 408 matching lines @@
     // Even when there's an empty saveLayer()/restore(), ensure that an image
     // filter or color filter which affects transparent black still draws.
 
     SkBitmap bitmap;
     bitmap.allocN32Pixels(10, 10);
     SkCanvas canvas(bitmap);
 
     SkRTreeFactory factory;
     SkPictureRecorder recorder;
 
-    SkAutoTUnref<SkColorFilter> green(
-        SkColorFilter::CreateModeFilter(SK_ColorGREEN, SkXfermode::kSrc_Mode));
+    auto green(SkColorFilter::MakeModeFilter(SK_ColorGREEN, SkXfermode::kSrc_Mode));
     SkAutoTUnref<SkImageFilter> imageFilter(
         SkColorFilterImageFilter::Create(green.get()));
     SkPaint imageFilterPaint;
     imageFilterPaint.setImageFilter(imageFilter.get());
     SkPaint colorFilterPaint;
-    colorFilterPaint.setColorFilter(green.get());
+    colorFilterPaint.setColorFilter(green);
 
     SkRect bounds = SkRect::MakeWH(10, 10);
 
     SkCanvas* recordingCanvas = recorder.beginRecording(10, 10, &factory, 0);
     recordingCanvas->saveLayer(&bounds, &imageFilterPaint);
     recordingCanvas->restore();
     sk_sp<SkPicture> picture(recorder.finishRecordingAsPicture());
 
     canvas.clear(0);
     canvas.drawPicture(picture);
@@ skipping 95 matching lines @@
     REPORTER_ASSERT(reporter, nullptr == conv.get());
 }
 
 static void test_xfermode_cropped_input(SkCanvas* canvas, skiatest::Reporter* reporter) {
     canvas->clear(0);
 
     SkBitmap bitmap;
     bitmap.allocN32Pixels(1, 1);
     bitmap.eraseARGB(255, 255, 255, 255);
 
-    SkAutoTUnref<SkColorFilter> green(
-        SkColorFilter::CreateModeFilter(SK_ColorGREEN, SkXfermode::kSrcIn_Mode));
+    auto green(SkColorFilter::MakeModeFilter(SK_ColorGREEN, SkXfermode::kSrcIn_Mode));
     SkAutoTUnref<SkImageFilter> greenFilter(SkColorFilterImageFilter::Create(green.get()));
     SkImageFilter::CropRect cropRect(SkRect::MakeEmpty());
     SkAutoTUnref<SkImageFilter> croppedOut(
         SkColorFilterImageFilter::Create(green.get(), nullptr, &cropRect));
 
     // Check that an xfermode image filter whose input has been cropped out still draws the other
     // input. Also check that drawing with both inputs cropped out doesn't cause a GPU warning.
     SkXfermode* mode = SkXfermode::Create(SkXfermode::kSrcOver_Mode);
     SkAutoTUnref<SkImageFilter> xfermodeNoFg(
         SkXfermodeImageFilter::Create(mode, greenFilter, croppedOut));
@@ skipping 200 matching lines @@
     }
     REPORTER_ASSERT(reporter, gray->canComputeFastBounds());
 
     SkAutoTUnref<SkImageFilter> grayBlur(SkBlurImageFilter::Create(SK_Scalar1, SK_Scalar1, gray.get()));
     REPORTER_ASSERT(reporter, grayBlur->canComputeFastBounds());
 
     SkScalar greenMatrix[20] = { 0, 0, 0, 0, 0,
                                  0, 0, 0, 0, 1,
                                  0, 0, 0, 0, 0,
                                  0, 0, 0, 0, 1 };
-    SkAutoTUnref<SkColorFilter> greenCF(SkColorMatrixFilter::Create(greenMatrix));
-    SkAutoTUnref<SkImageFilter> green(SkColorFilterImageFilter::Create(greenCF));
+    auto greenCF(SkColorFilter::MakeMatrixFilterRowMajor255(greenMatrix));
+    SkAutoTUnref<SkImageFilter> green(SkColorFilterImageFilter::Create(greenCF.get()));
 
     REPORTER_ASSERT(reporter, greenCF->affectsTransparentBlack());
     REPORTER_ASSERT(reporter, !green->canComputeFastBounds());
 
     SkAutoTUnref<SkImageFilter> greenBlur(SkBlurImageFilter::Create(SK_Scalar1, SK_Scalar1, green.get()));
     REPORTER_ASSERT(reporter, !greenBlur->canComputeFastBounds());
 
     uint8_t allOne[256], identity[256];
     for (int i = 0; i < 256; ++i) {
         identity[i] = i;
         allOne[i] = 255;
     }
 
-    SkAutoTUnref<SkColorFilter> identityCF(
-        SkTableColorFilter::CreateARGB(identity, identity, identity, allOne));
+    auto identityCF(SkTableColorFilter::MakeARGB(identity, identity, identity, allOne));
     SkAutoTUnref<SkImageFilter> identityFilter(SkColorFilterImageFilter::Create(identityCF.get()));
     REPORTER_ASSERT(reporter, !identityCF->affectsTransparentBlack());
     REPORTER_ASSERT(reporter, identityFilter->canComputeFastBounds());
 
-    SkAutoTUnref<SkColorFilter> forceOpaqueCF(
-        SkTableColorFilter::CreateARGB(allOne, identity, identity, identity));
+    auto forceOpaqueCF(SkTableColorFilter::MakeARGB(allOne, identity, identity, identity));
     SkAutoTUnref<SkImageFilter> forceOpaque(SkColorFilterImageFilter::Create(forceOpaqueCF.get()));
     REPORTER_ASSERT(reporter, forceOpaqueCF->affectsTransparentBlack());
     REPORTER_ASSERT(reporter, !forceOpaque->canComputeFastBounds());
 }
 
 // Verify that SkImageSource survives serialization
 DEF_TEST(ImageFilterImageSourceSerialization, reporter) {
     SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterN32Premul(10, 10));
     surface->getCanvas()->clear(SK_ColorGREEN);
     sk_sp<SkImage> image(surface->makeImageSnapshot());
@@ skipping 95 matching lines @@
     test_xfermode_cropped_input(&canvas, reporter);
 }
 
 DEF_GPUTEST_FOR_ALL_CONTEXTS(BlurLargeImage_Gpu, reporter, context) {
     SkAutoTUnref<SkSurface> surface(
         SkSurface::NewRenderTarget(context, SkBudgeted::kYes,
                                    SkImageInfo::MakeN32Premul(100, 100)));
     test_large_blur_input(reporter, surface->getCanvas());
 }
 #endif