Update MatrixConvolutionImageFilter 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"
 #include "SkBlurImageFilter.h"
@@ skipping 173 matching lines @@
         this->addFilter("drop shadow", SkDropShadowImageFilter::Make(
                   SK_Scalar1, SK_Scalar1, SK_Scalar1, SK_Scalar1, SK_ColorGREEN,
                   SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode,
                   input, cropRect).release());
         this->addFilter("diffuse lighting", SkLightingImageFilter::CreatePointLitDiffuse(
                   location, SK_ColorGREEN, 0, 0, input.get(), cropRect));
         this->addFilter("specular lighting",
                   SkLightingImageFilter::CreatePointLitSpecular(location, SK_ColorGREEN, 0, 0, 0,
                                                                 input.get(), cropRect));
         this->addFilter("matrix convolution",
-                  SkMatrixConvolutionImageFilter::Create(
+                  SkMatrixConvolutionImageFilter::Make(
                       kernelSize, kernel, gain, bias, SkIPoint::Make(1, 1),
                       SkMatrixConvolutionImageFilter::kRepeat_TileMode, false,
-                      input.get(), cropRect));
+                      input, cropRect).release());
         this->addFilter("merge", SkMergeImageFilter::Make(input, input,
                                                           SkXfermode::kSrcOver_Mode,
                                                           cropRect).release());
         {
             SkPaint greenColorShaderPaint;
             greenColorShaderPaint.setShader(SkShader::MakeColorShader(SK_ColorGREEN));
 
             SkImageFilter::CropRect leftSideCropRect(SkRect::MakeXYWH(0, 0, 32, 64));
             sk_sp<SkImageFilter> paintFilterLeft(SkPaintImageFilter::Make(greenColorShaderPaint,
                                                                           &leftSideCropRect));
@@ skipping 818 matching lines @@
 
 DEF_TEST(ImageFilterMatrixConvolution, reporter) {
     // Check that a 1x3 filter does not cause a spurious assert.
     SkScalar kernel[3] = {
         SkIntToScalar( 1), SkIntToScalar( 1), SkIntToScalar( 1),
     };
     SkISize kernelSize = SkISize::Make(1, 3);
     SkScalar gain = SK_Scalar1, bias = 0;
     SkIPoint kernelOffset = SkIPoint::Make(0, 0);
 
-    SkAutoTUnref<SkImageFilter> filter(
-        SkMatrixConvolutionImageFilter::Create(
-            kernelSize, kernel, gain, bias, kernelOffset,
-            SkMatrixConvolutionImageFilter::kRepeat_TileMode, false));
+    sk_sp<SkImageFilter> filter(SkMatrixConvolutionImageFilter::Make(
+                                            kernelSize, kernel,
+                                            gain, bias, kernelOffset,
+                                            SkMatrixConvolutionImageFilter::kRepeat_TileMode,
+                                            false, nullptr));
 
     SkBitmap result;
     int width = 16, height = 16;
     result.allocN32Pixels(width, height);
     SkCanvas canvas(result);
     canvas.clear(0);
 
     SkPaint paint;
-    paint.setImageFilter(filter);
+    paint.setImageFilter(std::move(filter));
     SkRect rect = SkRect::Make(SkIRect::MakeWH(width, height));
     canvas.drawRect(rect, paint);
 }
 
 DEF_TEST(ImageFilterMatrixConvolutionBorder, reporter) {
     // Check that a filter with borders outside the target bounds
     // does not crash.
     SkScalar kernel[3] = {
         0, 0, 0,
     };
     SkISize kernelSize = SkISize::Make(3, 1);
     SkScalar gain = SK_Scalar1, bias = 0;
     SkIPoint kernelOffset = SkIPoint::Make(2, 0);
 
-    SkAutoTUnref<SkImageFilter> filter(
-        SkMatrixConvolutionImageFilter::Create(
-            kernelSize, kernel, gain, bias, kernelOffset,
-            SkMatrixConvolutionImageFilter::kClamp_TileMode, true));
+    sk_sp<SkImageFilter> filter(SkMatrixConvolutionImageFilter::Make(
+                                            kernelSize, kernel, gain, bias, kernelOffset,
+                                            SkMatrixConvolutionImageFilter::kClamp_TileMode,
+                                            true, nullptr));
 
     SkBitmap result;
 
     int width = 10, height = 10;
     result.allocN32Pixels(width, height);
     SkCanvas canvas(result);
     canvas.clear(0);
 
     SkPaint filterPaint;
-    filterPaint.setImageFilter(filter);
+    filterPaint.setImageFilter(std::move(filter));
     SkRect bounds = SkRect::MakeWH(1, 10);
     SkRect rect = SkRect::Make(SkIRect::MakeWH(width, height));
     SkPaint rectPaint;
     canvas.saveLayer(&bounds, &filterPaint);
     canvas.drawRect(rect, rectPaint);
     canvas.restore();
 }
 
 DEF_TEST(ImageFilterCropRect, reporter) {
     run_raster_test(reporter, 100, test_crop_rects);
@@ skipping 199 matching lines @@
     SkCanvas canvas(temp);
     test_huge_blur(&canvas, reporter);
 }
 
 DEF_TEST(MatrixConvolutionSanityTest, reporter) {
     SkScalar kernel[1] = { 0 };
     SkScalar gain = SK_Scalar1, bias = 0;
     SkIPoint kernelOffset = SkIPoint::Make(1, 1);
 
     // Check that an enormous (non-allocatable) kernel gives a nullptr filter.
-    SkAutoTUnref<SkImageFilter> conv(SkMatrixConvolutionImageFilter::Create(
+    sk_sp<SkImageFilter> conv(SkMatrixConvolutionImageFilter::Make(
         SkISize::Make(1<<30, 1<<30),
         kernel,
         gain,
         bias,
         kernelOffset,
         SkMatrixConvolutionImageFilter::kRepeat_TileMode,
-        false));
+        false,
+        nullptr));
 
     REPORTER_ASSERT(reporter, nullptr == conv.get());
 
     // Check that a nullptr kernel gives a nullptr filter.
-    conv.reset(SkMatrixConvolutionImageFilter::Create(
+    conv = SkMatrixConvolutionImageFilter::Make(
         SkISize::Make(1, 1),
         nullptr,
         gain,
         bias,
         kernelOffset,
         SkMatrixConvolutionImageFilter::kRepeat_TileMode,
-        false));
+        false,
+        nullptr);
 
     REPORTER_ASSERT(reporter, nullptr == conv.get());
 
     // Check that a kernel width < 1 gives a nullptr filter.
-    conv.reset(SkMatrixConvolutionImageFilter::Create(
+    conv = SkMatrixConvolutionImageFilter::Make(
         SkISize::Make(0, 1),
         kernel,
         gain,
         bias,
         kernelOffset,
         SkMatrixConvolutionImageFilter::kRepeat_TileMode,
-        false));
+        false,
+        nullptr);
 
     REPORTER_ASSERT(reporter, nullptr == conv.get());
 
     // Check that kernel height < 1 gives a nullptr filter.
-    conv.reset(SkMatrixConvolutionImageFilter::Create(
+    conv = SkMatrixConvolutionImageFilter::Make(
         SkISize::Make(1, -1),
         kernel,
         gain,
         bias,
         kernelOffset,
         SkMatrixConvolutionImageFilter::kRepeat_TileMode,
-        false));
+        false,
+        nullptr);
 
     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);
@@ skipping 354 matching lines @@
 
     test_xfermode_cropped_input(&canvas, reporter);
 }
 
 DEF_GPUTEST_FOR_ALL_GL_CONTEXTS(BlurLargeImage_Gpu, reporter, ctxInfo) {
     auto surface(SkSurface::MakeRenderTarget(ctxInfo.fGrContext, SkBudgeted::kYes,
                                              SkImageInfo::MakeN32Premul(100, 100)));
     test_large_blur_input(reporter, surface->getCanvas());
 }
 #endif