Update SkOffsetImageFilter 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 101 matching lines @@
             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)));
         SkAutoTUnref<SkImageFilter> gradientSource(SkImageSource::Create(gradientImage.get()));
-        SkAutoTUnref<SkImageFilter> blur(SkBlurImageFilter::Create(five, five, input));
+        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);
 
         SkPaint greenPaint;
@@ skipping 37 matching lines @@
                       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(
                   std::move(paintFilterLeft), std::move(paintFilterRight),
                   SkXfermode::kSrcOver_Mode, cropRect).release());
         this->addFilter("offset",
-                        SkOffsetImageFilter::Create(SK_Scalar1, SK_Scalar1, input, cropRect));
+                        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::Create(
-            five, five, blur.get(), cropRect));
+        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));
         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; }
@@ skipping 385 matching lines @@
 DEF_GPUTEST_FOR_NATIVE_CONTEXT(TestNegativeBlurSigma_Gpu, reporter, context) {
     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)));
-    SkAutoTUnref<SkImageFilter> input(SkOffsetImageFilter::Create(0, 0, nullptr, &cropRect));
-    SkAutoTUnref<SkImageFilter> filter(SkBlurImageFilter::Create(0, 0, input, &cropRect));
+    sk_sp<SkImageFilter> input(SkOffsetImageFilter::Make(0, 0, nullptr, &cropRect));
+    sk_sp<SkImageFilter> filter(SkBlurImageFilter::Create(0, 0, input.get(), &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 182 matching lines @@
 
     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);
 }
 
 DEF_TEST(ImageFilterUnionBounds, reporter) {
-    SkAutoTUnref<SkImageFilter> offset(SkOffsetImageFilter::Create(50, 0));
+    sk_sp<SkImageFilter> offset(SkOffsetImageFilter::Make(50, 0, nullptr));
     // Regardless of which order they appear in, the image filter bounds should
     // be combined correctly.
     {
         sk_sp<SkImageFilter> composite(SkXfermodeImageFilter::Make(nullptr, offset.get()));
         SkRect bounds = SkRect::MakeWH(100, 100);
         // Intentionally aliasing here, as that's what the real callers do.
         bounds = composite->computeFastBounds(bounds);
         REPORTER_ASSERT(reporter, bounds == SkRect::MakeWH(150, 100));
     }
     {
@@ skipping 520 matching lines @@
     SkCanvas canvas(temp);
     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::Create(0, 0, nullptr, &cropRect));
+    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> 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 18 matching lines @@
     // Here, accounting for the outer offset is necessary so that the green
     // pixels of the picture are not clipped.
 
     SkPictureRecorder recorder;
     SkCanvas* recordingCanvas = recorder.beginRecording(SkRect::MakeWH(200, 100));
     recordingCanvas->clipRect(SkRect::MakeXYWH(100, 0, 100, 100));
     recordingCanvas->clear(SK_ColorGREEN);
     sk_sp<SkPicture> picture(recorder.finishRecordingAsPicture());
     sk_sp<SkImageFilter> pictureFilter(SkPictureImageFilter::Make(picture));
     SkImageFilter::CropRect cropRect(SkRect::MakeWH(100, 100));
-    sk_sp<SkImageFilter> offsetFilter(SkOffsetImageFilter::Create(-100, 0, nullptr, &cropRect));
+    sk_sp<SkImageFilter> offsetFilter(SkOffsetImageFilter::Make(-100, 0, nullptr, &cropRect));
     sk_sp<SkImageFilter> composedFilter(SkComposeImageFilter::Make(std::move(offsetFilter),
                                                                    std::move(pictureFilter)));
 
     sk_sp<SkSpecialImage> sourceImage(create_empty_special_image(context, proxy, 100));
     SkImageFilter::Context ctx(SkMatrix::I(), SkIRect::MakeWH(100, 100), nullptr);
     SkIPoint offset;
     sk_sp<SkSpecialImage> result(composedFilter->filterImage(sourceImage.get(), ctx, &offset));
     REPORTER_ASSERT(reporter, offset.isZero());
     REPORTER_ASSERT(reporter, result);
     REPORTER_ASSERT(reporter, result->subset().size() == SkISize::Make(100, 100));
@@ skipping 196 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