update callsites for Make image factories

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 78 matching lines @@
     return new MatrixTestImageFilter(reporter, matrix);
 }
 
 #ifndef SK_IGNORE_TO_STRING
 void MatrixTestImageFilter::toString(SkString* str) const {
     str->appendf("MatrixTestImageFilter: (");
     str->append(")");
 }
 #endif
 
-static SkImage* make_small_image() {
+static sk_sp<SkImage> make_small_image() {
     SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterN32Premul(kBitmapSize, kBitmapSize));
     SkCanvas* canvas = surface->getCanvas();
     canvas->clear(0x00000000);
     SkPaint darkPaint;
     darkPaint.setColor(0xFF804020);
     SkPaint lightPaint;
     lightPaint.setColor(0xFF244484);
     const int i = kBitmapSize / 4;
     for (int y = 0; y < kBitmapSize; y += i) {
         for (int x = 0; x < kBitmapSize; x += i) {
@@ skipping 11 matching lines @@
                                              SkIntToScalar(i),
                                              SkIntToScalar(i)), lightPaint);
             canvas->drawRect(SkRect::MakeXYWH(SkIntToScalar(i),
                                              SkIntToScalar(i),
                                              SkIntToScalar(i),
                                              SkIntToScalar(i)), darkPaint);
             canvas->restore();
         }
     }
 
-    return surface->newImageSnapshot();
+    return surface->makeImageSnapshot();
 }
 
 static SkImageFilter* make_scale(float amount, SkImageFilter* input = nullptr) {
     SkScalar s = amount;
     SkScalar matrix[20] = { s, 0, 0, 0, 0,
                             0, s, 0, 0, 0,
                             0, 0, s, 0, 0,
                             0, 0, 0, s, 0 };
     SkAutoTUnref<SkColorFilter> filter(SkColorMatrixFilter::Create(matrix));
     return SkColorFilterImageFilter::Create(filter, input);
@@ skipping 131 matching lines @@
         canvas.clear(0x0);
         SkRect rect = SkRect::Make(SkIRect::MakeWH(kBitmapSize, kBitmapSize));
         canvas.drawRect(rect, paint);
         uint32_t pixel = *result.getAddr32(0, 0);
         // The result here should be green, since we have effectively shifted blue to green.
         REPORTER_ASSERT(reporter, pixel == SK_ColorGREEN);
     }
 
     {
         // Tests pass by not asserting
-        SkAutoTUnref<SkImage> image(make_small_image());
+        sk_sp<SkImage> image(make_small_image());
         SkBitmap result;
         result.allocN32Pixels(kBitmapSize, kBitmapSize);
 
         {
             // 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));
+            SkAutoTUnref<SkImageFilter> bmSrc(SkImageSource::Create(image.get()));
             SkPaint paint;
             paint.setImageFilter(SkLightingImageFilter::CreateSpotLitSpecular(
                     location, target, specularExponent, 180,
                     0xFFFFFFFF, SK_Scalar1, SK_Scalar1, SK_Scalar1,
                     bmSrc))->unref();
             SkCanvas canvas(result);
             SkRect r = SkRect::MakeWH(SkIntToScalar(kBitmapSize),
                                       SkIntToScalar(kBitmapSize));
             canvas.drawRect(r, paint);
         }
@@ skipping 260 matching lines @@
     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);
 
-    SkAutoTUnref<SkImage> gradientImage(SkImage::NewFromBitmap(make_gradient_circle(64, 64)));
-    SkAutoTUnref<SkImageFilter> gradientSource(SkImageSource::Create(gradientImage));
+    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));
     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);
 
@@ skipping 206 matching lines @@
 
     REPORTER_ASSERT(reporter, boundsDst == expectedBounds);
 }
 
 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);
-    SkAutoTUnref<SkImage> greenImage(SkImage::NewFromBitmap(greenBM));
+    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));
 
     SkImageFilter::Context ctx(SkMatrix::I(), SkIRect::MakeXYWH(0, 0, 100, 100), nullptr);
     SkIPoint offset;
 
     SkAutoTUnref<SkSpecialImage> resultImg(merge->filterImage(srcImg, ctx, &offset));
     REPORTER_ASSERT(reporter, resultImg);
@@ skipping 610 matching lines @@
         SkTableColorFilter::CreateARGB(allOne, identity, identity, identity));
     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) {
     SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterN32Premul(10, 10));
     surface->getCanvas()->clear(SK_ColorGREEN);
-    SkAutoTUnref<SkImage> image(surface->newImageSnapshot());
-    SkAutoTUnref<SkImageFilter> filter(SkImageSource::Create(image));
+    sk_sp<SkImage> image(surface->makeImageSnapshot());
+    SkAutoTUnref<SkImageFilter> filter(SkImageSource::Create(image.get()));
 
     SkAutoTUnref<SkData> data(SkValidatingSerializeFlattenable(filter));
     SkAutoTUnref<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);
@@ skipping 17 matching lines @@
     }
 #endif
 
     largeBmp.allocN32Pixels(largeW, largeH);
     largeBmp.eraseColor(0);
     if (!largeBmp.getPixels()) {
         ERRORF(reporter, "Failed to allocate large bmp.");
         return;
     }
 
-    SkAutoTUnref<SkImage> largeImage(SkImage::NewFromBitmap(largeBmp));
+    sk_sp<SkImage> largeImage(SkImage::MakeFromBitmap(largeBmp));
     if (!largeImage) {
         ERRORF(reporter, "Failed to create large image.");
         return;
     }
 
-    SkAutoTUnref<SkImageFilter> largeSource(SkImageSource::Create(largeImage));
+    SkAutoTUnref<SkImageFilter> largeSource(SkImageSource::Create(largeImage.get()));
     if (!largeSource) {
         ERRORF(reporter, "Failed to create large SkImageSource.");
         return;
     }
 
     SkAutoTUnref<SkImageFilter> blur(SkBlurImageFilter::Create(10.f, 10.f, largeSource));
     if (!blur) {
         ERRORF(reporter, "Failed to create SkBlurImageFilter.");
         return;
     }
@@ skipping 40 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