Update SkBlurImageFilter 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 88 matching lines @@
     SkBitmap bitmap;
     bitmap.allocN32Pixels(width, height);
     SkCanvas canvas(bitmap);
     draw_gradient_circle(&canvas, width, height);
     return bitmap;
 }
 
 class FilterList {
 public:
     FilterList(SkImageFilter* input = nullptr, const SkImageFilter::CropRect* cropRect = nullptr) {
-        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);
 
-        sk_sp<SkImage> gradientImage(SkImage::MakeFromBitmap(make_gradient_circle(64, 64)));
-        sk_sp<SkImageFilter> gradientSource(SkImageSource::Make(std::move(gradientImage)));
-        sk_sp<SkImageFilter> blur(SkBlurImageFilter::Create(five, five, input));
         SkMatrix matrix;
 
         matrix.setTranslate(SK_Scalar1, SK_Scalar1);
         matrix.postRotate(SkIntToScalar(45), SK_Scalar1, SK_Scalar1);
 
-        SkRTreeFactory factory;
-        SkPictureRecorder recorder;
-        SkCanvas* recordingCanvas = recorder.beginRecording(64, 64, &factory, 0);
+        {
+            sk_sp<SkColorFilter> cf(SkColorFilter::MakeModeFilter(SK_ColorRED,
+                                                                  SkXfermode::kSrcIn_Mode));
 
-        SkPaint greenPaint;
-        greenPaint.setColor(SK_ColorGREEN);
-        recordingCanvas->drawRect(SkRect::Make(SkIRect::MakeXYWH(10, 10, 30, 20)), greenPaint);
-        sk_sp<SkPicture> picture(recorder.finishRecordingAsPicture());
-        sk_sp<SkImageFilter> pictureFilter(SkPictureImageFilter::Make(picture));
-        sk_sp<SkShader> shader(SkPerlinNoiseShader::MakeTurbulence(SK_Scalar1, SK_Scalar1, 1, 0));
+            this->addFilter("color filter",
+                SkColorFilterImageFilter::Create(cf.get(), input, cropRect));
+        }
 
-        SkPaint paint;
-        paint.setShader(shader);
-        sk_sp<SkImageFilter> paintFilter(SkPaintImageFilter::Make(paint));
+        {
+            sk_sp<SkImage> gradientImage(SkImage::MakeFromBitmap(make_gradient_circle(64, 64)));
+            sk_sp<SkImageFilter> gradientSource(SkImageSource::Make(std::move(gradientImage)));
 
-        sk_sp<SkShader> greenColorShader(SkShader::MakeColorShader(SK_ColorGREEN));
-        SkPaint greenColorShaderPaint;
-        greenColorShaderPaint.setShader(greenColorShader);
-        SkImageFilter::CropRect leftSideCropRect(SkRect::MakeXYWH(0, 0, 32, 64));
-        sk_sp<SkImageFilter> paintFilterLeft(SkPaintImageFilter::Make(greenColorShaderPaint,
-                                                                      &leftSideCropRect));
-        SkImageFilter::CropRect rightSideCropRect(SkRect::MakeXYWH(32, 0, 32, 64));
-        sk_sp<SkImageFilter> paintFilterRight(SkPaintImageFilter::Make(greenColorShaderPaint,
-                                                                       &rightSideCropRect));
+            this->addFilter("displacement map", SkDisplacementMapEffect::Create(
+                SkDisplacementMapEffect::kR_ChannelSelectorType,
+                SkDisplacementMapEffect::kB_ChannelSelectorType,
+                20.0f, gradientSource.get(), input, cropRect));
+        }
 
-        this->addFilter("color filter",
-            SkColorFilterImageFilter::Create(cf.get(), input, cropRect));
-        this->addFilter("displacement map", SkDisplacementMapEffect::Create(
-            SkDisplacementMapEffect::kR_ChannelSelectorType,
-            SkDisplacementMapEffect::kB_ChannelSelectorType,
-            20.0f, gradientSource.get(), input, cropRect));
-        this->addFilter("blur", SkBlurImageFilter::Create(SK_Scalar1, SK_Scalar1, input, cropRect));
+        this->addFilter("blur", SkBlurImageFilter::Make(SK_Scalar1,
+                                                        SK_Scalar1,
+                                                        sk_ref_sp<SkImageFilter>(input),
+                                                        cropRect).release());
         this->addFilter("drop shadow", SkDropShadowImageFilter::Create(
                   SK_Scalar1, SK_Scalar1, SK_Scalar1, SK_Scalar1, SK_ColorGREEN,
                   SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode, input, cropRect));
         this->addFilter("diffuse lighting", SkLightingImageFilter::CreatePointLitDiffuse(
                   location, SK_ColorGREEN, 0, 0, input, cropRect));
         this->addFilter("specular lighting",
                   SkLightingImageFilter::CreatePointLitSpecular(location, SK_ColorGREEN, 0, 0, 0,
                                                                 input, cropRect));
         this->addFilter("matrix convolution",
                   SkMatrixConvolutionImageFilter::Create(
                       kernelSize, kernel, gain, bias, SkIPoint::Make(1, 1),
                       SkMatrixConvolutionImageFilter::kRepeat_TileMode, false, input, cropRect));
         this->addFilter("merge", SkMergeImageFilter::Make(sk_ref_sp<SkImageFilter>(input),
                                                           sk_ref_sp<SkImageFilter>(input),
                                                           SkXfermode::kSrcOver_Mode,
                                                           cropRect).release());
-        this->addFilter("merge with disjoint inputs", SkMergeImageFilter::Make(
+        {
+            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));
+            SkImageFilter::CropRect rightSideCropRect(SkRect::MakeXYWH(32, 0, 32, 64));
+            sk_sp<SkImageFilter> paintFilterRight(SkPaintImageFilter::Make(greenColorShaderPaint,
+                                                                           &rightSideCropRect));
+
+
+            this->addFilter("merge with disjoint inputs", SkMergeImageFilter::Make(
                   std::move(paintFilterLeft), std::move(paintFilterRight),
                   SkXfermode::kSrcOver_Mode, cropRect).release());
+        }
+
         this->addFilter("offset",
                         SkOffsetImageFilter::Make(SK_Scalar1, SK_Scalar1,
                                                   sk_ref_sp<SkImageFilter>(input),
                                                   cropRect).release());
         this->addFilter("dilate", SkDilateImageFilter::Create(3, 2, input, cropRect));
         this->addFilter("erode", SkErodeImageFilter::Create(2, 3, input, cropRect));
         this->addFilter("tile", SkTileImageFilter::Create(
             SkRect::MakeXYWH(0, 0, 50, 50),
             cropRect ? cropRect->rect() : SkRect::MakeXYWH(0, 0, 100, 100),
             input));
         if (!cropRect) {
             this->addFilter("matrix", SkImageFilter::CreateMatrixFilter(
                 matrix, kLow_SkFilterQuality, input));
         }
-        this->addFilter("blur and offset",
-                        SkOffsetImageFilter::Make(five, five, blur,
-                                                  cropRect).release());
-        this->addFilter("picture and blur", SkBlurImageFilter::Create(
-            five, five, pictureFilter.get(), cropRect));
-        this->addFilter("paint and blur", SkBlurImageFilter::Create(
-            five, five, paintFilter.get(), cropRect));
+
+        {
+            sk_sp<SkImageFilter> blur(SkBlurImageFilter::Make(five, five, 
+                                                              sk_ref_sp<SkImageFilter>(input)));
+
+            this->addFilter("blur and offset", SkOffsetImageFilter::Make(five, five,
+                                                                         std::move(blur),
+                                                                         cropRect).release());
+        }
+        {
+            SkRTreeFactory factory;
+            SkPictureRecorder recorder;
+            SkCanvas* recordingCanvas = recorder.beginRecording(64, 64, &factory, 0);
+
+            SkPaint greenPaint;
+            greenPaint.setColor(SK_ColorGREEN);
+            recordingCanvas->drawRect(SkRect::Make(SkIRect::MakeXYWH(10, 10, 30, 20)), greenPaint);
+            sk_sp<SkPicture> picture(recorder.finishRecordingAsPicture());
+            sk_sp<SkImageFilter> pictureFilter(SkPictureImageFilter::Make(picture));

[f(malita), 2016/04/03 16:47:50]

nit: std::move(picture)

[robertphillips, 2016/04/03 20:18:00]

Done.

+
+            this->addFilter("picture and blur", SkBlurImageFilter::Make(five, five,
+                                                                        std::move(pictureFilter),
+                                                                        cropRect).release());
+        }
+        {
+            SkPaint paint;
+            paint.setShader(SkPerlinNoiseShader::MakeTurbulence(SK_Scalar1, SK_Scalar1, 1, 0));
+            sk_sp<SkImageFilter> paintFilter(SkPaintImageFilter::Make(paint));
+
+            this->addFilter("paint and blur", SkBlurImageFilter::Make(five, five,
+                                                                      std::move(paintFilter),
+                                                                      cropRect).release());
+        }
         this->addFilter("xfermode", SkXfermodeImageFilter::Make(
             SkXfermode::Make(SkXfermode::kSrc_Mode), input, input, cropRect).release());
     }
     int count() const { return fFilters.count(); }
     SkImageFilter* getFilter(int index) const { return fFilters[index].fFilter.get(); }
     const char* getName(int index) const { return fFilters[index].fName; }
 private:
     struct Filter {
         Filter() : fName(nullptr), fFilter(nullptr) {}
         Filter(const char* name, SkImageFilter* filter) : fName(name), fFilter(filter) {}
@@ skipping 260 matching lines @@
 }
 
 static void test_negative_blur_sigma(SkImageFilter::Proxy* proxy,
                                      skiatest::Reporter* reporter,
                                      GrContext* context) {
     // Check that SkBlurImageFilter will accept a negative sigma, either in
     // the given arguments or after CTM application.
     const int width = 32, height = 32;
     const SkScalar five = SkIntToScalar(5);
 
-    SkAutoTUnref<SkImageFilter> positiveFilter(SkBlurImageFilter::Create(five, five));
-    SkAutoTUnref<SkImageFilter> negativeFilter(SkBlurImageFilter::Create(-five, five));
+    sk_sp<SkImageFilter> positiveFilter(SkBlurImageFilter::Make(five, five, nullptr));
+    sk_sp<SkImageFilter> negativeFilter(SkBlurImageFilter::Make(-five, five, nullptr));
 
     SkBitmap gradient = make_gradient_circle(width, height);
     sk_sp<SkSpecialImage> imgSrc(SkSpecialImage::MakeFromRaster(proxy,
                                                                 SkIRect::MakeWH(width, height),
                                                                 gradient));
 
     SkIPoint offset;
     SkImageFilter::Context ctx(SkMatrix::I(), SkIRect::MakeWH(32, 32), nullptr);
 
     sk_sp<SkSpecialImage> positiveResult1(positiveFilter->filterImage(imgSrc.get(), ctx, &offset));
@@ skipping 100 matching lines @@
     run_gpu_test(reporter, context, 100, test_negative_blur_sigma);
 }
 #endif
 
 static void test_zero_blur_sigma(SkImageFilter::Proxy* proxy,
                                  skiatest::Reporter* reporter,
                                  GrContext* context) {
     // Check that SkBlurImageFilter with a zero sigma and a non-zero srcOffset works correctly.
     SkImageFilter::CropRect cropRect(SkRect::Make(SkIRect::MakeXYWH(5, 0, 5, 10)));
     sk_sp<SkImageFilter> input(SkOffsetImageFilter::Make(0, 0, nullptr, &cropRect));
-    sk_sp<SkImageFilter> filter(SkBlurImageFilter::Create(0, 0, input.get(), &cropRect));
+    sk_sp<SkImageFilter> filter(SkBlurImageFilter::Make(0, 0, std::move(input), &cropRect));
 
     sk_sp<SkSpecialSurface> surf(create_empty_special_surface(context, proxy, 10));
     surf->getCanvas()->clear(SK_ColorGREEN);
     sk_sp<SkSpecialImage> image(surf->makeImageSnapshot());
 
     SkIPoint offset;
     SkImageFilter::Context ctx(SkMatrix::I(), SkIRect::MakeWH(32, 32), nullptr);
 
     sk_sp<SkSpecialImage> result(filter->filterImage(image.get(), ctx, &offset));
     REPORTER_ASSERT(reporter, offset.fX == 5 && offset.fY == 0);
@@ skipping 122 matching lines @@
 
     for (int y = 0; y < height; y++) {
         int diffs = memcmp(result1.getAddr32(0, y), result2.getAddr32(0, y), result1.rowBytes());
         REPORTER_ASSERT(reporter, !diffs);
         if (diffs) {
             break;
         }
     }
 }
 
-static SkImageFilter* makeBlur(SkImageFilter* input = nullptr) {
-    return SkBlurImageFilter::Create(SK_Scalar1, SK_Scalar1, input);
+static sk_sp<SkImageFilter> make_blur(sk_sp<SkImageFilter> input) {
+    return SkBlurImageFilter::Make(SK_Scalar1, SK_Scalar1, std::move(input));
 }
 
-static SkImageFilter* makeDropShadow(SkImageFilter* input = nullptr) {
-    return SkDropShadowImageFilter::Create(
+static sk_sp<SkImageFilter> make_drop_shadow(sk_sp<SkImageFilter> input) {
+    return sk_sp<SkImageFilter>(SkDropShadowImageFilter::Create(
         SkIntToScalar(100), SkIntToScalar(100),
         SkIntToScalar(10), SkIntToScalar(10),
         SK_ColorBLUE, SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode,
-        input, nullptr);
+        input.get(), nullptr));
 }
 
 DEF_TEST(ImageFilterBlurThenShadowBounds, reporter) {
-    SkAutoTUnref<SkImageFilter> filter1(makeBlur());
-    SkAutoTUnref<SkImageFilter> filter2(makeDropShadow(filter1.get()));
+    sk_sp<SkImageFilter> filter1(make_blur(nullptr));
+    sk_sp<SkImageFilter> filter2(make_drop_shadow(std::move(filter1)));
 
     SkIRect bounds = SkIRect::MakeXYWH(0, 0, 100, 100);
     SkIRect expectedBounds = SkIRect::MakeXYWH(-133, -133, 236, 236);
     bounds = filter2->filterBounds(bounds, SkMatrix::I());
 
     REPORTER_ASSERT(reporter, bounds == expectedBounds);
 }
 
 DEF_TEST(ImageFilterShadowThenBlurBounds, reporter) {
-    SkAutoTUnref<SkImageFilter> filter1(makeDropShadow());
-    SkAutoTUnref<SkImageFilter> filter2(makeBlur(filter1.get()));
+    sk_sp<SkImageFilter> filter1(make_drop_shadow(nullptr));
+    sk_sp<SkImageFilter> filter2(make_blur(std::move(filter1)));
 
     SkIRect bounds = SkIRect::MakeXYWH(0, 0, 100, 100);
     SkIRect expectedBounds = SkIRect::MakeXYWH(-133, -133, 236, 236);
     bounds = filter2->filterBounds(bounds, SkMatrix::I());
 
     REPORTER_ASSERT(reporter, bounds == expectedBounds);
 }
 
 DEF_TEST(ImageFilterDilateThenBlurBounds, reporter) {
-    SkAutoTUnref<SkImageFilter> filter1(SkDilateImageFilter::Create(2, 2));
-    SkAutoTUnref<SkImageFilter> filter2(makeDropShadow(filter1.get()));
+    sk_sp<SkImageFilter> filter1(SkDilateImageFilter::Create(2, 2));
+    sk_sp<SkImageFilter> filter2(make_drop_shadow(std::move(filter1)));
 
     SkIRect bounds = SkIRect::MakeXYWH(0, 0, 100, 100);
     SkIRect expectedBounds = SkIRect::MakeXYWH(-132, -132, 234, 234);
     bounds = filter2->filterBounds(bounds, SkMatrix::I());
 
     REPORTER_ASSERT(reporter, bounds == expectedBounds);
 }
 
 DEF_TEST(ImageFilterComposedBlurFastBounds, reporter) {
-    sk_sp<SkImageFilter> filter1(makeBlur());
-    sk_sp<SkImageFilter> filter2(makeBlur());
+    sk_sp<SkImageFilter> filter1(make_blur(nullptr));
+    sk_sp<SkImageFilter> filter2(make_blur(nullptr));
     sk_sp<SkImageFilter> composedFilter(SkComposeImageFilter::Make(std::move(filter1),
                                                                    std::move(filter2)));
 
     SkRect boundsSrc = SkRect::MakeWH(SkIntToScalar(100), SkIntToScalar(100));
     SkRect expectedBounds = SkRect::MakeXYWH(
         SkIntToScalar(-6), SkIntToScalar(-6), SkIntToScalar(112), SkIntToScalar(112));
     SkRect boundsDst = composedFilter->computeFastBounds(boundsSrc);
 
     REPORTER_ASSERT(reporter, boundsDst == expectedBounds);
 }
@@ skipping 44 matching lines @@
     run_raster_test(reporter, 100, test_imagefilter_merge_result_size);
 }
 
 #if SK_SUPPORT_GPU
 DEF_GPUTEST_FOR_NATIVE_CONTEXT(ImageFilterMergeResultSize_Gpu, reporter, context) {
     run_gpu_test(reporter, context, 100, test_imagefilter_merge_result_size);
 }
 #endif
 
 static void draw_blurred_rect(SkCanvas* canvas) {
-    SkAutoTUnref<SkImageFilter> filter(SkBlurImageFilter::Create(SkIntToScalar(8), 0));
     SkPaint filterPaint;
     filterPaint.setColor(SK_ColorWHITE);
-    filterPaint.setImageFilter(filter);
+    filterPaint.setImageFilter(SkBlurImageFilter::Make(SkIntToScalar(8), 0, nullptr));
     canvas->saveLayer(nullptr, &filterPaint);
     SkPaint whitePaint;
     whitePaint.setColor(SK_ColorWHITE);
     canvas->drawRect(SkRect::Make(SkIRect::MakeWH(4, 4)), whitePaint);
     canvas->restore();
 }
 
 static void draw_picture_clipped(SkCanvas* canvas, const SkRect& clipRect, const SkPicture* picture) {
     canvas->save();
     canvas->clipRect(clipRect);
@@ skipping 294 matching lines @@
     pixel = *bitmap.getAddr32(0, 0);
     REPORTER_ASSERT(reporter, pixel == SK_ColorGREEN);
 }
 
 static void test_huge_blur(SkCanvas* canvas, skiatest::Reporter* reporter) {
     SkBitmap bitmap;
     bitmap.allocN32Pixels(100, 100);
     bitmap.eraseARGB(0, 0, 0, 0);
 
     // Check that a blur with an insane radius does not crash or assert.
-    SkAutoTUnref<SkImageFilter> blur(SkBlurImageFilter::Create(SkIntToScalar(1<<30), SkIntToScalar(1<<30)));
-
     SkPaint paint;
-    paint.setImageFilter(blur);
+    paint.setImageFilter(SkBlurImageFilter::Make(SkIntToScalar(1<<30),
+                                                 SkIntToScalar(1<<30),
+                                                 nullptr));
     canvas->drawBitmap(bitmap, 0, 0, &paint);
 }
 
 DEF_TEST(HugeBlurImageFilter, reporter) {
     SkBitmap temp;
     temp.allocN32Pixels(100, 100);
     SkCanvas canvas(temp);
     test_huge_blur(&canvas, reporter);
 }
 
@@ skipping 148 matching lines @@
     test_xfermode_cropped_input(&canvas, reporter);
 }
 
 static void test_composed_imagefilter_offset(SkImageFilter::Proxy* proxy,
                                              skiatest::Reporter* reporter,
                                              GrContext* context) {
     sk_sp<SkSpecialImage> srcImg(create_empty_special_image(context, proxy, 100));
 
     SkImageFilter::CropRect cropRect(SkRect::MakeXYWH(1, 0, 20, 20));
     sk_sp<SkImageFilter> offsetFilter(SkOffsetImageFilter::Make(0, 0, nullptr, &cropRect));
-    sk_sp<SkImageFilter> blurFilter(SkBlurImageFilter::Create(SK_Scalar1, SK_Scalar1,
-                                                              nullptr, &cropRect));
+    sk_sp<SkImageFilter> blurFilter(SkBlurImageFilter::Make(SK_Scalar1, SK_Scalar1,
+                                                            nullptr, &cropRect));
     sk_sp<SkImageFilter> composedFilter(SkComposeImageFilter::Make(std::move(blurFilter),
                                                                    std::move(offsetFilter)));
     SkIPoint offset;
     SkImageFilter::Context ctx(SkMatrix::I(), SkIRect::MakeWH(100, 100), nullptr);
 
     sk_sp<SkSpecialImage> resultImg(composedFilter->filterImage(srcImg.get(), ctx, &offset));
     REPORTER_ASSERT(reporter, resultImg);
     REPORTER_ASSERT(reporter, offset.fX == 1 && offset.fY == 0);
 }
 
@@ skipping 81 matching lines @@
 }
 #endif
 
 DEF_TEST(ImageFilterCanComputeFastBounds, reporter) {
 
     SkPoint3 location = SkPoint3::Make(0, 0, SK_Scalar1);
     SkAutoTUnref<SkImageFilter> lighting(SkLightingImageFilter::CreatePointLitDiffuse(
           location, SK_ColorGREEN, 0, 0));
     REPORTER_ASSERT(reporter, !lighting->canComputeFastBounds());
 
-    SkAutoTUnref<SkImageFilter> gray(make_grayscale(nullptr, nullptr));
-    REPORTER_ASSERT(reporter, gray->canComputeFastBounds());
     {
-        SkColorFilter* grayCF;
-        REPORTER_ASSERT(reporter, gray->asAColorFilter(&grayCF));
-        REPORTER_ASSERT(reporter, !grayCF->affectsTransparentBlack());
-        grayCF->unref();
+        sk_sp<SkImageFilter> gray(make_grayscale(nullptr, nullptr));
+        REPORTER_ASSERT(reporter, gray->canComputeFastBounds());
+        {
+            SkColorFilter* grayCF;
+            REPORTER_ASSERT(reporter, gray->asAColorFilter(&grayCF));
+            REPORTER_ASSERT(reporter, !grayCF->affectsTransparentBlack());
+            grayCF->unref();
+        }
+        REPORTER_ASSERT(reporter, gray->canComputeFastBounds());
+
+        sk_sp<SkImageFilter> grayBlur(SkBlurImageFilter::Make(SK_Scalar1, SK_Scalar1,
+                                                              std::move(gray)));
+        REPORTER_ASSERT(reporter, grayBlur->canComputeFastBounds());
     }
-    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 };
+        sk_sp<SkColorFilter> greenCF(SkColorFilter::MakeMatrixFilterRowMajor255(greenMatrix));
+        sk_sp<SkImageFilter> green(SkColorFilterImageFilter::Create(greenCF.get()));
 
-    SkScalar greenMatrix[20] = { 0, 0, 0, 0, 0,
-                                 0, 0, 0, 0, 1,
-                                 0, 0, 0, 0, 0,
-                                 0, 0, 0, 0, 1 };
-    auto greenCF(SkColorFilter::MakeMatrixFilterRowMajor255(greenMatrix));
-    SkAutoTUnref<SkImageFilter> green(SkColorFilterImageFilter::Create(greenCF.get()));
+        REPORTER_ASSERT(reporter, greenCF->affectsTransparentBlack());
+        REPORTER_ASSERT(reporter, !green->canComputeFastBounds());
 
-    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());
+        sk_sp<SkImageFilter> greenBlur(SkBlurImageFilter::Make(SK_Scalar1, SK_Scalar1,
+                                                               std::move(green)));
+        REPORTER_ASSERT(reporter, !greenBlur->canComputeFastBounds());
+    }
 
     uint8_t allOne[256], identity[256];
     for (int i = 0; i < 256; ++i) {
         identity[i] = i;
         allOne[i] = 255;
     }
 
     auto identityCF(SkTableColorFilter::MakeARGB(identity, identity, identity, allOne));
     SkAutoTUnref<SkImageFilter> identityFilter(SkColorFilterImageFilter::Create(identityCF.get()));
     REPORTER_ASSERT(reporter, !identityCF->affectsTransparentBlack());
@@ skipping 53 matching lines @@
         ERRORF(reporter, "Failed to create large image.");
         return;
     }
 
     sk_sp<SkImageFilter> largeSource(SkImageSource::Make(std::move(largeImage)));
     if (!largeSource) {
         ERRORF(reporter, "Failed to create large SkImageSource.");
         return;
     }
 
-    sk_sp<SkImageFilter> blur(SkBlurImageFilter::Create(10.f, 10.f, largeSource.get()));
+    sk_sp<SkImageFilter> blur(SkBlurImageFilter::Make(10.f, 10.f, std::move(largeSource)));
     if (!blur) {
         ERRORF(reporter, "Failed to create SkBlurImageFilter.");
         return;
     }
 
     SkPaint paint;
     paint.setImageFilter(std::move(blur));
 
     // This should not crash (http://crbug.com/570479).
     canvas->drawRect(SkRect::MakeIWH(largeW, largeH), paint);
@@ skipping 33 matching lines @@
 
     test_xfermode_cropped_input(&canvas, reporter);
 }
 
 DEF_GPUTEST_FOR_ALL_CONTEXTS(BlurLargeImage_Gpu, reporter, context) {
     auto surface(SkSurface::MakeRenderTarget(context, SkBudgeted::kYes,
                                              SkImageInfo::MakeN32Premul(100, 100)));
     test_large_blur_input(reporter, surface->getCanvas());
 }
 #endif