Switch SkSpecialImage & SkSpecialSurface classes over to smart pointers

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 140 matching lines @@
     SkAutoTUnref<SkColorFilter> filter(SkColorMatrixFilter::Create(matrix));
     return SkColorFilterImageFilter::Create(filter, 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);
 }
 
-static SkSpecialSurface* create_empty_special_surface(GrContext* context,
-                                                      SkImageFilter::Proxy* proxy,
-                                                      int widthHeight) {
+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;
         desc.fHeight = widthHeight;
-        return SkSpecialSurface::NewRenderTarget(proxy, context, desc);
+        return SkSpecialSurface::MakeRenderTarget(proxy, context, desc);
     } else {
         const SkImageInfo info = SkImageInfo::MakeN32(widthHeight, widthHeight,
                                                       kOpaque_SkAlphaType);
-        return SkSpecialSurface::NewRaster(proxy, info);
+        return SkSpecialSurface::MakeRaster(proxy, info);
     }
 }
 
-static SkSpecialImage* create_empty_special_image(GrContext* context,
-                                                  SkImageFilter::Proxy* proxy,
-                                                  int widthHeight) {
-    SkAutoTUnref<SkSpecialSurface> surf(create_empty_special_surface(context, proxy, widthHeight));
+static sk_sp<SkSpecialImage> create_empty_special_image(GrContext* context,
+                                                        SkImageFilter::Proxy* proxy,
+                                                        int widthHeight) {
+    sk_sp<SkSpecialSurface> surf(create_empty_special_surface(context, proxy, widthHeight));
 
     SkASSERT(surf);
 
     SkCanvas* canvas = surf->getCanvas();
     SkASSERT(canvas);
 
     canvas->clear(0x0);
 
-    return surf->newImageSnapshot();
+    return surf->makeImageSnapshot();
 }
 
 
 DEF_TEST(ImageFilter, reporter) {
     {
         // Check that two non-clipping color-matrice-filters concatenate into a single filter.
         SkAutoTUnref<SkImageFilter> halfBrightness(make_scale(0.5f));
         SkAutoTUnref<SkImageFilter> quarterBrightness(make_scale(0.5f, halfBrightness));
         REPORTER_ASSERT(reporter, nullptr == quarterBrightness->getInput(0));
         SkColorFilter* cf;
@@ skipping 105 matching lines @@
         }
     }
 }
 
 static void test_crop_rects(SkImageFilter::Proxy* proxy,
                             skiatest::Reporter* reporter,
                             GrContext* context) {
     // Check that all filters offset to their absolute crop rect,
     // unaffected by the input crop rect.
     // Tests pass by not asserting.
-    SkAutoTUnref<SkSpecialImage> srcImg(create_empty_special_image(context, proxy, 100));
+    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));
     SkPoint3 location = SkPoint3::Make(0, 0, SK_Scalar1);
     SkScalar kernel[9] = {
         SkIntToScalar( 1), SkIntToScalar( 1), SkIntToScalar( 1),
@@ skipping 23 matching lines @@
         SkTileImageFilter::Create(inputCropRect.rect(), cropRect.rect(), input.get()),
         SkXfermodeImageFilter::Create(SkXfermode::Create(SkXfermode::kSrcOver_Mode), input.get(), input.get(), &cropRect),
     };
 
     for (size_t i = 0; i < SK_ARRAY_COUNT(filters); ++i) {
         SkImageFilter* filter = filters[i];
         SkIPoint offset;
         SkString str;
         str.printf("filter %d", static_cast<int>(i));
         SkImageFilter::Context ctx(SkMatrix::I(), SkIRect::MakeWH(100, 100), nullptr);
-        SkAutoTUnref<SkSpecialImage> resultImg(filter->filterImage(srcImg, ctx, &offset));
+        SkAutoTUnref<SkSpecialImage> resultImg(filter->filterImage(srcImg.get(), ctx, &offset));
         REPORTER_ASSERT_MESSAGE(reporter, resultImg, str.c_str());
         REPORTER_ASSERT_MESSAGE(reporter, offset.fX == 20 && offset.fY == 30, str.c_str());
     }
 
     for (size_t i = 0; i < SK_ARRAY_COUNT(filters); ++i) {
         SkSafeUnref(filters[i]);
     }
 }
 
 static SkBitmap make_gradient_circle(int width, int height) {
@@ skipping 21 matching lines @@
                                      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);
-    SkAutoTUnref<SkSpecialImage> imgSrc(SkSpecialImage::NewFromRaster(proxy,
-                                                                      SkIRect::MakeWH(width,
-                                                                                      height),
-                                                                      gradient));
+    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, ctx, &offset));
+    SkAutoTUnref<SkSpecialImage> positiveResult1(positiveFilter->filterImage(imgSrc.get(),
+                                                                             ctx, &offset));
     REPORTER_ASSERT(reporter, positiveResult1);
 
-    SkAutoTUnref<SkSpecialImage> negativeResult1(negativeFilter->filterImage(imgSrc, ctx, &offset));
+    SkAutoTUnref<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,
+    SkAutoTUnref<SkSpecialImage> negativeResult2(positiveFilter->filterImage(imgSrc.get(),
                                                                              negativeCTX,
                                                                              &offset));
     REPORTER_ASSERT(reporter, negativeResult2);
 
-    SkAutoTUnref<SkSpecialImage> positiveResult2(negativeFilter->filterImage(imgSrc,
+    SkAutoTUnref<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);
@@ skipping 77 matching lines @@
 #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));
 
-    SkAutoTUnref<SkSpecialSurface> surf(create_empty_special_surface(context, proxy, 10));
+    sk_sp<SkSpecialSurface> surf(create_empty_special_surface(context, proxy, 10));
     surf->getCanvas()->clear(SK_ColorGREEN);
-    SkAutoTUnref<SkSpecialImage> image(surf->newImageSnapshot());
+    sk_sp<SkSpecialImage> image(surf->makeImageSnapshot());
 
     SkIPoint offset;
     SkImageFilter::Context ctx(SkMatrix::I(), SkIRect::MakeWH(32, 32), nullptr);
 
-    SkAutoTUnref<SkSpecialImage> result(filter->filterImage(image, ctx, &offset));
+    SkAutoTUnref<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);
 
     SkAutoLockPixels lock(resultBM);
     for (int y = 0; y < resultBM.height(); y++) {
@@ skipping 280 matching lines @@
 static void test_imagefilter_merge_result_size(SkImageFilter::Proxy* proxy,
                                                skiatest::Reporter* reporter,
                                                GrContext* context) {
     SkBitmap greenBM;
     greenBM.allocN32Pixels(20, 20);
     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()));
 
-    SkAutoTUnref<SkSpecialImage> srcImg(create_empty_special_image(context, proxy, 1));
+    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, ctx, &offset));
+    SkAutoTUnref<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 237 matching lines @@
         SkPictureRecorder recorder;
         SkCanvas* recordingCanvas = recorder.beginRecording(1, 1, &factory, 0);
 
         // Create an SkPicture which simply draws a green 1x1 rectangle.
         SkPaint greenPaint;
         greenPaint.setColor(SK_ColorGREEN);
         recordingCanvas->drawRect(SkRect::Make(SkIRect::MakeWH(1, 1)), greenPaint);
         picture.reset(recorder.endRecording());
     }
 
-    SkAutoTUnref<SkSpecialImage> srcImg(create_empty_special_image(context, proxy, 2));
+    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, ctx, &offset));
+    SkAutoTUnref<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 224 matching lines @@
 DEF_TEST(XfermodeImageFilterCroppedInput, reporter) {
     SkBitmap temp;
     temp.allocN32Pixels(100, 100);
     SkCanvas canvas(temp);
     test_xfermode_cropped_input(&canvas, reporter);
 }
 
 static void test_composed_imagefilter_offset(SkImageFilter::Proxy* proxy,
                                              skiatest::Reporter* reporter,
                                              GrContext* context) {
-    SkAutoTUnref<SkSpecialImage> srcImg(create_empty_special_image(context, proxy, 100));
+    sk_sp<SkSpecialImage> srcImg(create_empty_special_image(context, proxy, 100));
 
     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, ctx, &offset));
+    SkAutoTUnref<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) {
     run_gpu_test(reporter, context, 100, test_composed_imagefilter_offset);
 }
 #endif
 
 static void test_partial_crop_rect(SkImageFilter::Proxy* proxy,
                                    skiatest::Reporter* reporter,
                                    GrContext* context) {
-    SkAutoTUnref<SkSpecialImage> srcImg(create_empty_special_image(context, proxy, 100));
+    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, ctx, &offset));
+    SkAutoTUnref<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 160 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