Switch new SkImageFilter internal methods over 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 441 matching lines @@
     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));
 
     FilterList filters(input.get(), &cropRect);
 
     for (int i = 0; i < filters.count(); ++i) {
         SkImageFilter* filter = filters.getFilter(i);
         SkIPoint offset;
         SkImageFilter::Context ctx(SkMatrix::I(), SkIRect::MakeWH(100, 100), nullptr);
-        SkAutoTUnref<SkSpecialImage> resultImg(filter->filterImage(srcImg.get(), ctx, &offset));
+        sk_sp<SkSpecialImage> resultImg(filter->filterImage(srcImg.get(), ctx, &offset));
         REPORTER_ASSERT_MESSAGE(reporter, resultImg, filters.getName(i));
         REPORTER_ASSERT_MESSAGE(reporter, offset.fX == 20 && offset.fY == 30, filters.getName(i));
     }
 }
 
 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));
 
     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);
 
-    SkAutoTUnref<SkSpecialImage> positiveResult1(positiveFilter->filterImage(imgSrc.get(),
-                                                                             ctx, &offset));
+    sk_sp<SkSpecialImage> positiveResult1(positiveFilter->filterImage(imgSrc.get(), ctx, &offset));
     REPORTER_ASSERT(reporter, positiveResult1);
 
-    SkAutoTUnref<SkSpecialImage> negativeResult1(negativeFilter->filterImage(imgSrc.get(),
-                                                                             ctx, &offset));
+    sk_sp<SkSpecialImage> negativeResult1(negativeFilter->filterImage(imgSrc.get(), ctx, &offset));
     REPORTER_ASSERT(reporter, negativeResult1);
 
     SkMatrix negativeScale;
     negativeScale.setScale(-SK_Scalar1, SK_Scalar1);
     SkImageFilter::Context negativeCTX(negativeScale, SkIRect::MakeWH(32, 32), nullptr);
 
-    SkAutoTUnref<SkSpecialImage> negativeResult2(positiveFilter->filterImage(imgSrc.get(),
-                                                                             negativeCTX,
-                                                                             &offset));
+    sk_sp<SkSpecialImage> negativeResult2(positiveFilter->filterImage(imgSrc.get(),
+                                                                      negativeCTX,
+                                                                      &offset));
     REPORTER_ASSERT(reporter, negativeResult2);
 
-    SkAutoTUnref<SkSpecialImage> positiveResult2(negativeFilter->filterImage(imgSrc.get(),
-                                                                             negativeCTX,
-                                                                             &offset));
+    sk_sp<SkSpecialImage> positiveResult2(negativeFilter->filterImage(imgSrc.get(),
+                                                                      negativeCTX,
+                                                                      &offset));
     REPORTER_ASSERT(reporter, positiveResult2);
 
 
     SkBitmap positiveResultBM1, positiveResultBM2;
     SkBitmap negativeResultBM1, negativeResultBM2;
 
-    TestingSpecialImageAccess::GetROPixels(positiveResult1, &positiveResultBM1);
-    TestingSpecialImageAccess::GetROPixels(positiveResult2, &positiveResultBM2);
-    TestingSpecialImageAccess::GetROPixels(negativeResult1, &negativeResultBM1);
-    TestingSpecialImageAccess::GetROPixels(negativeResult2, &negativeResultBM2);
+    TestingSpecialImageAccess::GetROPixels(positiveResult1.get(), &positiveResultBM1);
+    TestingSpecialImageAccess::GetROPixels(positiveResult2.get(), &positiveResultBM2);
+    TestingSpecialImageAccess::GetROPixels(negativeResult1.get(), &negativeResultBM1);
+    TestingSpecialImageAccess::GetROPixels(negativeResult2.get(), &negativeResultBM2);
 
     SkAutoLockPixels lockP1(positiveResultBM1);
     SkAutoLockPixels lockP2(positiveResultBM2);
     SkAutoLockPixels lockN1(negativeResultBM1);
     SkAutoLockPixels lockN2(negativeResultBM2);
     for (int y = 0; y < height; y++) {
         int diffs = memcmp(positiveResultBM1.getAddr32(0, y),
                            negativeResultBM1.getAddr32(0, y),
                            positiveResultBM1.rowBytes());
         REPORTER_ASSERT(reporter, !diffs);
@@ skipping 72 matching lines @@
     SkAutoTUnref<SkImageFilter> input(SkOffsetImageFilter::Create(0, 0, nullptr, &cropRect));
     SkAutoTUnref<SkImageFilter> filter(SkBlurImageFilter::Create(0, 0, 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);
 
-    SkAutoTUnref<SkSpecialImage> result(filter->filterImage(image.get(), ctx, &offset));
+    sk_sp<SkSpecialImage> result(filter->filterImage(image.get(), ctx, &offset));
     REPORTER_ASSERT(reporter, offset.fX == 5 && offset.fY == 0);
     REPORTER_ASSERT(reporter, result);
     REPORTER_ASSERT(reporter, result->width() == 5 && result->height() == 10);
 
     SkBitmap resultBM;
 
-    TestingSpecialImageAccess::GetROPixels(result, &resultBM);
+    TestingSpecialImageAccess::GetROPixels(result.get(), &resultBM);
 
     SkAutoLockPixels lock(resultBM);
     for (int y = 0; y < resultBM.height(); y++) {
         for (int x = 0; x < resultBM.width(); x++) {
             bool diff = *resultBM.getAddr32(x, y) != SK_ColorGREEN;
             REPORTER_ASSERT(reporter, !diff);
             if (diff) {
                 break;
             }
         }
@@ skipping 201 matching lines @@
     greenBM.eraseColor(SK_ColorGREEN);
     sk_sp<SkImage> greenImage(SkImage::MakeFromBitmap(greenBM));
     SkAutoTUnref<SkImageFilter> source(SkImageSource::Create(greenImage.get()));
     SkAutoTUnref<SkImageFilter> merge(SkMergeImageFilter::Create(source.get(), source.get()));
 
     sk_sp<SkSpecialImage> srcImg(create_empty_special_image(context, proxy, 1));
 
     SkImageFilter::Context ctx(SkMatrix::I(), SkIRect::MakeXYWH(0, 0, 100, 100), nullptr);
     SkIPoint offset;
 
-    SkAutoTUnref<SkSpecialImage> resultImg(merge->filterImage(srcImg.get(), ctx, &offset));
+    sk_sp<SkSpecialImage> resultImg(merge->filterImage(srcImg.get(), ctx, &offset));
     REPORTER_ASSERT(reporter, resultImg);
 
     REPORTER_ASSERT(reporter, resultImg->width() == 20 && resultImg->height() == 20);
 }
 
 DEF_TEST(ImageFilterMergeResultSize, reporter) {
     run_raster_test(reporter, 100, test_imagefilter_merge_result_size);
 }
 
 #if SK_SUPPORT_GPU
@@ skipping 243 matching lines @@
         picture = recorder.finishRecordingAsPicture();
     }
 
     sk_sp<SkSpecialImage> srcImg(create_empty_special_image(context, proxy, 2));
 
     SkAutoTUnref<SkImageFilter> imageFilter(SkPictureImageFilter::Create(picture.get()));
 
     SkIPoint offset;
     SkImageFilter::Context ctx(SkMatrix::I(), SkIRect::MakeXYWH(1, 1, 1, 1), nullptr);
 
-    SkAutoTUnref<SkSpecialImage> resultImage(imageFilter->filterImage(srcImg.get(), ctx, &offset));
+    sk_sp<SkSpecialImage> resultImage(imageFilter->filterImage(srcImg.get(), ctx, &offset));
     REPORTER_ASSERT(reporter, !resultImage);
 }
 
 DEF_TEST(ImageFilterClippedPictureImageFilter, reporter) {
     run_raster_test(reporter, 2, test_clipped_picture_imagefilter);
 }
 
 #if SK_SUPPORT_GPU
 DEF_GPUTEST_FOR_NATIVE_CONTEXT(ImageFilterClippedPictureImageFilter_Gpu, reporter, context) {
     run_gpu_test(reporter, context, 2, test_clipped_picture_imagefilter);
@@ skipping 233 matching lines @@
 
     SkImageFilter::CropRect cropRect(SkRect::MakeXYWH(1, 0, 20, 20));
     SkAutoTUnref<SkImageFilter> offsetFilter(SkOffsetImageFilter::Create(0, 0, nullptr, &cropRect));
     SkAutoTUnref<SkImageFilter> blurFilter(SkBlurImageFilter::Create(SK_Scalar1, SK_Scalar1,
                                                                      nullptr, &cropRect));
     SkAutoTUnref<SkImageFilter> composedFilter(SkComposeImageFilter::Create(blurFilter,
                                                                             offsetFilter.get()));
     SkIPoint offset;
     SkImageFilter::Context ctx(SkMatrix::I(), SkIRect::MakeWH(100, 100), nullptr);
 
-    SkAutoTUnref<SkSpecialImage> resultImg(composedFilter->filterImage(srcImg.get(), ctx, &offset));
+    sk_sp<SkSpecialImage> resultImg(composedFilter->filterImage(srcImg.get(), ctx, &offset));
     REPORTER_ASSERT(reporter, resultImg);
     REPORTER_ASSERT(reporter, offset.fX == 1 && offset.fY == 0);
 }
 
 DEF_TEST(ComposedImageFilterOffset, reporter) {
     run_raster_test(reporter, 100, test_composed_imagefilter_offset);
 }
 
 #if SK_SUPPORT_GPU
 DEF_GPUTEST_FOR_NATIVE_CONTEXT(ComposedImageFilterOffset_Gpu, reporter, context) {
@@ skipping 50 matching lines @@
                                    skiatest::Reporter* reporter,
                                    GrContext* context) {
     sk_sp<SkSpecialImage> srcImg(create_empty_special_image(context, proxy, 100));
 
     SkImageFilter::CropRect cropRect(SkRect::MakeXYWH(100, 0, 20, 30),
         SkImageFilter::CropRect::kHasWidth_CropEdge | SkImageFilter::CropRect::kHasHeight_CropEdge);
     SkAutoTUnref<SkImageFilter> filter(make_grayscale(nullptr, &cropRect));
     SkIPoint offset;
     SkImageFilter::Context ctx(SkMatrix::I(), SkIRect::MakeWH(100, 100), nullptr);
 
-    SkAutoTUnref<SkSpecialImage> resultImg(filter->filterImage(srcImg.get(), ctx, &offset));
+    sk_sp<SkSpecialImage> resultImg(filter->filterImage(srcImg.get(), ctx, &offset));
     REPORTER_ASSERT(reporter, resultImg);
 
     REPORTER_ASSERT(reporter, offset.fX == 0);
     REPORTER_ASSERT(reporter, offset.fY == 0);
     REPORTER_ASSERT(reporter, resultImg->width() == 20);
     REPORTER_ASSERT(reporter, resultImg->height() == 30);
 }
 
 DEF_TEST(PartialCropRect, reporter) {
     run_raster_test(reporter, 100, test_partial_crop_rect);
@@ skipping 157 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