Update SkImageSource 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 100 matching lines @@
         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)));
-        SkAutoTUnref<SkImageFilter> gradientSource(SkImageSource::Create(gradientImage.get()));
-        SkAutoTUnref<SkImageFilter> blur(SkBlurImageFilter::Create(five, five, input));
+        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);
 
         SkPaint greenPaint;
@@ skipping 287 matching lines @@
 
         {
             // This tests for :
             // 1 ) location at (0,0,1)
             SkPoint3 location = SkPoint3::Make(0, 0, SK_Scalar1);
             // 2 ) location and target at same value
             SkPoint3 target = SkPoint3::Make(location.fX, location.fY, location.fZ);
             // 3 ) large negative specular exponent value
             SkScalar specularExponent = -1000;
 
-            SkAutoTUnref<SkImageFilter> bmSrc(SkImageSource::Create(image.get()));
+            sk_sp<SkImageFilter> bmSrc(SkImageSource::Make(std::move(image)));
             SkPaint paint;
             paint.setImageFilter(SkLightingImageFilter::CreateSpotLitSpecular(
                     location, target, specularExponent, 180,
                     0xFFFFFFFF, SK_Scalar1, SK_Scalar1, SK_Scalar1,
-                    bmSrc))->unref();
+                    bmSrc.get()))->unref();
             SkCanvas canvas(result);
             SkRect r = SkRect::MakeWH(SkIntToScalar(kBitmapSize),
                                       SkIntToScalar(kBitmapSize));
             canvas.drawRect(r, paint);
         }
     }
 }
 
 static void test_crop_rects(SkImageFilter::Proxy* proxy,
                             skiatest::Reporter* reporter,
@@ skipping 373 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));
-    sk_sp<SkImageFilter> source(SkImageSource::Create(greenImage.get()));
+    sk_sp<SkImageFilter> source(SkImageSource::Make(std::move(greenImage)));
     sk_sp<SkImageFilter> merge(SkMergeImageFilter::Make(source, source));
 
     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;
 
     sk_sp<SkSpecialImage> resultImg(merge->filterImage(srcImg.get(), ctx, &offset));
     REPORTER_ASSERT(reporter, resultImg);
 
@@ skipping 645 matching lines @@
     SkAutoTUnref<SkImageFilter> forceOpaque(SkColorFilterImageFilter::Create(forceOpaqueCF.get()));
     REPORTER_ASSERT(reporter, forceOpaqueCF->affectsTransparentBlack());
     REPORTER_ASSERT(reporter, !forceOpaque->canComputeFastBounds());
 }
 
 // Verify that SkImageSource survives serialization
 DEF_TEST(ImageFilterImageSourceSerialization, reporter) {
     auto surface(SkSurface::MakeRasterN32Premul(10, 10));
     surface->getCanvas()->clear(SK_ColorGREEN);
     sk_sp<SkImage> image(surface->makeImageSnapshot());
-    SkAutoTUnref<SkImageFilter> filter(SkImageSource::Create(image.get()));
+    sk_sp<SkImageFilter> filter(SkImageSource::Make(std::move(image)));
 
-    SkAutoTUnref<SkData> data(SkValidatingSerializeFlattenable(filter));
-    SkAutoTUnref<SkFlattenable> flattenable(SkValidatingDeserializeFlattenable(
+    sk_sp<SkData> data(SkValidatingSerializeFlattenable(filter.get()));
+    sk_sp<SkFlattenable> flattenable(SkValidatingDeserializeFlattenable(
         data->data(), data->size(), SkImageFilter::GetFlattenableType()));
     SkImageFilter* unflattenedFilter = static_cast<SkImageFilter*>(flattenable.get());
     REPORTER_ASSERT(reporter, unflattenedFilter);
 
     SkBitmap bm;
     bm.allocN32Pixels(10, 10);
     bm.eraseColor(SK_ColorBLUE);
     SkPaint paint;
     paint.setColor(SK_ColorRED);
     paint.setImageFilter(unflattenedFilter);
@@ skipping 20 matching lines @@
         ERRORF(reporter, "Failed to allocate large bmp.");
         return;
     }
 
     sk_sp<SkImage> largeImage(SkImage::MakeFromBitmap(largeBmp));
     if (!largeImage) {
         ERRORF(reporter, "Failed to create large image.");
         return;
     }
 
-    SkAutoTUnref<SkImageFilter> largeSource(SkImageSource::Create(largeImage.get()));
+    sk_sp<SkImageFilter> largeSource(SkImageSource::Make(std::move(largeImage)));
     if (!largeSource) {
         ERRORF(reporter, "Failed to create large SkImageSource.");
         return;
     }
 
-    SkAutoTUnref<SkImageFilter> blur(SkBlurImageFilter::Create(10.f, 10.f, largeSource));
+    sk_sp<SkImageFilter> blur(SkBlurImageFilter::Create(10.f, 10.f, largeSource.get()));
     if (!blur) {
         ERRORF(reporter, "Failed to create SkBlurImageFilter.");
         return;
     }
 
     SkPaint paint;
-    paint.setImageFilter(blur);
+    paint.setImageFilter(std::move(blur));
 
     // This should not crash (http://crbug.com/570479).
     canvas->drawRect(SkRect::MakeIWH(largeW, largeH), paint);
 }
 
 DEF_TEST(BlurLargeImage, reporter) {
     auto surface(SkSurface::MakeRaster(SkImageInfo::MakeN32Premul(100, 100)));
     test_large_blur_input(reporter, surface->getCanvas());
 }
 
@@ skipping 26 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