update callsites for Make image factories

tests/SurfaceTest.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 <functional>
 #include "SkCanvas.h"
 #include "SkData.h"
@@ skipping 213 matching lines @@
         SkAutoTUnref<SkSurface> surface(surface_func(context, kPremul_SkAlphaType, nullptr));
         test_access_pixels(reporter, surface);
     }
 }
 #endif
 
 static void test_snapshot_alphatype(skiatest::Reporter* reporter, SkSurface* surface,
                                     bool expectOpaque) {
     REPORTER_ASSERT(reporter, surface);
     if (surface) {
-        SkAutoTUnref<SkImage> image(surface->newImageSnapshot());
+        sk_sp<SkImage> image(surface->makeImageSnapshot());
         REPORTER_ASSERT(reporter, image);
         if (image) {
             REPORTER_ASSERT(reporter, image->isOpaque() == SkToBool(expectOpaque));
         }
     }
 }
 DEF_TEST(SurfaceSnapshotAlphaType, reporter) {
     for (auto& surface_func : { &create_surface, &create_direct_surface }) {
         for (auto& isOpaque : { true, false }) {
             SkAlphaType alphaType = isOpaque ? kOpaque_SkAlphaType : kPremul_SkAlphaType;
@@ skipping 24 matching lines @@
     if (!s->getRenderTargetHandle(&result, a)) {
         return 0;
     }
     return result;
 }
 
 static void test_backend_handle_access_copy_on_write(
     skiatest::Reporter* reporter, SkSurface* surface, SkSurface::BackendHandleAccess mode,
     GrBackendObject (*func)(SkSurface*, SkSurface::BackendHandleAccess)) {
     GrBackendObject obj1 = func(surface, mode);
-    SkAutoTUnref<SkImage> snap1(surface->newImageSnapshot());
+    sk_sp<SkImage> snap1(surface->makeImageSnapshot());
 
     GrBackendObject obj2 = func(surface, mode);
-    SkAutoTUnref<SkImage> snap2(surface->newImageSnapshot());
+    sk_sp<SkImage> snap2(surface->makeImageSnapshot());
 
     // If the access mode triggers CoW, then the backend objects should reflect it.
     REPORTER_ASSERT(reporter, (obj1 == obj2) == (snap1 == snap2));
 }
 DEF_TEST(SurfaceBackendHandleAccessCopyOnWrite, reporter) {
     const SkSurface::BackendHandleAccess accessModes[] = {
         SkSurface::kFlushRead_BackendHandleAccess,
         SkSurface::kFlushWrite_BackendHandleAccess,
         SkSurface::kDiscardWrite_BackendHandleAccess,
     };
@@ skipping 39 matching lines @@
 }
 
 static void test_unique_image_snap(skiatest::Reporter* reporter, SkSurface* surface,
                                    bool surfaceIsDirect,
                                    std::function<intptr_t(SkImage*)> imageBackingStore,
                                    std::function<intptr_t(SkSurface*)> surfaceBackingStore) {
     std::function<intptr_t(SkImage*)> ibs = imageBackingStore;
     std::function<intptr_t(SkSurface*)> sbs = surfaceBackingStore;
     static const SkBudgeted kB = SkBudgeted::kNo;
     {
-        SkAutoTUnref<SkImage> image(surface->newImageSnapshot(kB, SkSurface::kYes_ForceUnique));
-        REPORTER_ASSERT(reporter, !same_image_surf(image, surface, ibs, sbs));
+        sk_sp<SkImage> image(surface->makeImageSnapshot(kB, SkSurface::kYes_ForceUnique));
+        REPORTER_ASSERT(reporter, !same_image_surf(image.get(), surface, ibs, sbs));
         REPORTER_ASSERT(reporter, image->unique());
     }
     {
-        SkAutoTUnref<SkImage> image1(surface->newImageSnapshot(kB, SkSurface::kYes_ForceUnique));
-        REPORTER_ASSERT(reporter, !same_image_surf(image1, surface, ibs, sbs));
+        sk_sp<SkImage> image1(surface->makeImageSnapshot(kB, SkSurface::kYes_ForceUnique));
+        REPORTER_ASSERT(reporter, !same_image_surf(image1.get(), surface, ibs, sbs));
         REPORTER_ASSERT(reporter, image1->unique());
-        SkAutoTUnref<SkImage> image2(surface->newImageSnapshot(kB, SkSurface::kYes_ForceUnique));
-        REPORTER_ASSERT(reporter, !same_image_surf(image2, surface, ibs, sbs));
-        REPORTER_ASSERT(reporter, !same_image(image1, image2, ibs));
+        sk_sp<SkImage> image2(surface->makeImageSnapshot(kB, SkSurface::kYes_ForceUnique));
+        REPORTER_ASSERT(reporter, !same_image_surf(image2.get(), surface, ibs, sbs));
+        REPORTER_ASSERT(reporter, !same_image(image1.get(), image2.get(), ibs));
         REPORTER_ASSERT(reporter, image2->unique());
     }
     {
-        SkAutoTUnref<SkImage> image1(surface->newImageSnapshot(kB, SkSurface::kNo_ForceUnique));
-        SkAutoTUnref<SkImage> image2(surface->newImageSnapshot(kB, SkSurface::kYes_ForceUnique));
-        SkAutoTUnref<SkImage> image3(surface->newImageSnapshot(kB, SkSurface::kNo_ForceUnique));
-        SkAutoTUnref<SkImage> image4(surface->newImageSnapshot(kB, SkSurface::kYes_ForceUnique));
+        sk_sp<SkImage> image1(surface->makeImageSnapshot(kB, SkSurface::kNo_ForceUnique));
+        sk_sp<SkImage> image2(surface->makeImageSnapshot(kB, SkSurface::kYes_ForceUnique));
+        sk_sp<SkImage> image3(surface->makeImageSnapshot(kB, SkSurface::kNo_ForceUnique));
+        sk_sp<SkImage> image4(surface->makeImageSnapshot(kB, SkSurface::kYes_ForceUnique));
         // Image 1 and 3 ought to be the same (or we're missing an optimization).
-        REPORTER_ASSERT(reporter, same_image(image1, image3, ibs));
+        REPORTER_ASSERT(reporter, same_image(image1.get(), image3.get(), ibs));
         // If the surface is not direct then images 1 and 3 should alias the surface's
         // store.
-        REPORTER_ASSERT(reporter, !surfaceIsDirect == same_image_surf(image1, surface, ibs, sbs));
+        REPORTER_ASSERT(reporter, !surfaceIsDirect == same_image_surf(image1.get(), surface, ibs, sbs));
         // Image 2 should not be shared with any other image.
-        REPORTER_ASSERT(reporter, !same_image(image1, image2, ibs) &&
-                                  !same_image(image3, image2, ibs) &&
-                                  !same_image(image4, image2, ibs));
+        REPORTER_ASSERT(reporter, !same_image(image1.get(), image2.get(), ibs) &&
+                                  !same_image(image3.get(), image2.get(), ibs) &&
+                                  !same_image(image4.get(), image2.get(), ibs));
         REPORTER_ASSERT(reporter, image2->unique());
-        REPORTER_ASSERT(reporter, !same_image_surf(image2, surface, ibs, sbs));
+        REPORTER_ASSERT(reporter, !same_image_surf(image2.get(), surface, ibs, sbs));
         // Image 4 should not be shared with any other image.
-        REPORTER_ASSERT(reporter, !same_image(image1, image4, ibs) &&
-                                  !same_image(image3, image4, ibs));
-        REPORTER_ASSERT(reporter, !same_image_surf(image4, surface, ibs, sbs));
+        REPORTER_ASSERT(reporter, !same_image(image1.get(), image4.get(), ibs) &&
+                                  !same_image(image3.get(), image4.get(), ibs));
+        REPORTER_ASSERT(reporter, !same_image_surf(image4.get(), surface, ibs, sbs));
         REPORTER_ASSERT(reporter, image4->unique());
     }
 }
 
 DEF_TEST(UniqueImageSnapshot, reporter) {
     auto getImageBackingStore = [reporter](SkImage* image) {
         SkPixmap pm;
         bool success = image->peekPixels(&pm);
         REPORTER_ASSERT(reporter, success);
         return reinterpret_cast<intptr_t>(pm.addr());
@@ skipping 63 matching lines @@
 // May we (soon) eliminate the need to keep testing this, by hiding the bloody device!
 static uint32_t get_legacy_gen_id(SkSurface* surface) {
     SkBaseDevice* device =
             surface->getCanvas()->getDevice_just_for_deprecated_compatibility_testing();
     return device->accessBitmap(false).getGenerationID();
 }
 /*
  *  Test legacy behavor of bumping the surface's device's bitmap's genID when we access its
  *  texture handle for writing.
  *
- *  Note: this needs to be tested separately from checking newImageSnapshot, as calling that
+ *  Note: this needs to be tested separately from checking makeImageSnapshot, as calling that
  *  can also incidentally bump the genID (when a new backing surface is created).
  */
 static void test_backend_handle_gen_id(
     skiatest::Reporter* reporter, SkSurface* surface,
     GrBackendObject (*func)(SkSurface*, SkSurface::BackendHandleAccess)) {
     const uint32_t gen0 = get_legacy_gen_id(surface);
     func(surface, SkSurface::kFlushRead_BackendHandleAccess);
     const uint32_t gen1 = get_legacy_gen_id(surface);
     REPORTER_ASSERT(reporter, gen0 == gen1);
 
     func(surface, SkSurface::kFlushWrite_BackendHandleAccess);
     const uint32_t gen2 = get_legacy_gen_id(surface);
     REPORTER_ASSERT(reporter, gen0 != gen2);
 
     func(surface, SkSurface::kDiscardWrite_BackendHandleAccess);
     const uint32_t gen3 = get_legacy_gen_id(surface);
     REPORTER_ASSERT(reporter, gen0 != gen3);
     REPORTER_ASSERT(reporter, gen2 != gen3);
 }
 static void test_backend_handle_unique_id(
     skiatest::Reporter* reporter, SkSurface* surface,
     GrBackendObject (*func)(SkSurface*, SkSurface::BackendHandleAccess)) {
-    SkAutoTUnref<SkImage> image0(surface->newImageSnapshot());
+    sk_sp<SkImage> image0(surface->makeImageSnapshot());
     GrBackendObject obj = func(surface, SkSurface::kFlushRead_BackendHandleAccess);
     REPORTER_ASSERT(reporter, obj != 0);
-    SkAutoTUnref<SkImage> image1(surface->newImageSnapshot());
+    sk_sp<SkImage> image1(surface->makeImageSnapshot());
     // just read access should not affect the snapshot
     REPORTER_ASSERT(reporter, image0->uniqueID() == image1->uniqueID());
 
     obj = func(surface, SkSurface::kFlushWrite_BackendHandleAccess);
     REPORTER_ASSERT(reporter, obj != 0);
-    SkAutoTUnref<SkImage> image2(surface->newImageSnapshot());
+    sk_sp<SkImage> image2(surface->makeImageSnapshot());
     // expect a new image, since we claimed we would write
     REPORTER_ASSERT(reporter, image0->uniqueID() != image2->uniqueID());
 
     obj = func(surface, SkSurface::kDiscardWrite_BackendHandleAccess);
     REPORTER_ASSERT(reporter, obj != 0);
-    SkAutoTUnref<SkImage> image3(surface->newImageSnapshot());
+    sk_sp<SkImage> image3(surface->makeImageSnapshot());
     // expect a new(er) image, since we claimed we would write
     REPORTER_ASSERT(reporter, image0->uniqueID() != image3->uniqueID());
     REPORTER_ASSERT(reporter, image2->uniqueID() != image3->uniqueID());
 }
 // No CPU test.
 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceBackendHandleAccessIDs_Gpu, reporter, context) {
     for (auto& surface_func : { &create_gpu_surface, &create_gpu_scratch_surface }) {
         for (auto& test_func : { &test_backend_handle_unique_id, &test_backend_handle_gen_id }) {
             for (auto& handle_access_func :
                 { &get_surface_backend_texture_handle, &get_surface_backend_render_target_handle}) {
@@ skipping 49 matching lines @@
         { SkIntToScalar(5), SkIntToScalar(1) },
         { SkIntToScalar(6), SkIntToScalar(1) },
         { SkIntToScalar(7), SkIntToScalar(1) },
         { SkIntToScalar(8), SkIntToScalar(1) },
         { SkIntToScalar(9), SkIntToScalar(1) },
         { SkIntToScalar(10), SkIntToScalar(1) },
     };
 
 #define EXPECT_COPY_ON_WRITE(command)                               \
     {                                                               \
-        SkImage* imageBefore = surface->newImageSnapshot();         \
-        SkAutoTUnref<SkImage> aur_before(imageBefore);              \
+        sk_sp<SkImage> imageBefore = surface->makeImageSnapshot();  \
+        sk_sp<SkImage> aur_before(imageBefore);                     \
         canvas-> command ;                                          \
-        SkImage* imageAfter = surface->newImageSnapshot();          \
-        SkAutoTUnref<SkImage> aur_after(imageAfter);                \
+        sk_sp<SkImage> imageAfter = surface->makeImageSnapshot();   \
+        sk_sp<SkImage> aur_after(imageAfter);                       \
         REPORTER_ASSERT(reporter, imageBefore != imageAfter);       \
     }
 
     EXPECT_COPY_ON_WRITE(clear(testColor))
     EXPECT_COPY_ON_WRITE(drawPaint(testPaint))
     EXPECT_COPY_ON_WRITE(drawPoints(SkCanvas::kPoints_PointMode, testPointCount, testPoints, \
         testPaint))
     EXPECT_COPY_ON_WRITE(drawOval(testRect, testPaint))
     EXPECT_COPY_ON_WRITE(drawRect(testRect, testPaint))
     EXPECT_COPY_ON_WRITE(drawRRect(testRRect, testPaint))
@@ skipping 20 matching lines @@
 }
 #endif
 
 static void test_writable_after_snapshot_release(skiatest::Reporter* reporter,
                                                  SkSurface* surface) {
     // This test succeeds by not triggering an assertion.
     // The test verifies that the surface remains writable (usable) after
     // acquiring and releasing a snapshot without triggering a copy on write.
     SkCanvas* canvas = surface->getCanvas();
     canvas->clear(1);
-    surface->newImageSnapshot()->unref();  // Create and destroy SkImage
+    surface->makeImageSnapshot();  // Create and destroy SkImage
     canvas->clear(2);  // Must not assert internally
 }
 DEF_TEST(SurfaceWriteableAfterSnapshotRelease, reporter) {
     SkAutoTUnref<SkSurface> surface(create_surface());
     test_writable_after_snapshot_release(reporter, surface);
 }
 #if SK_SUPPORT_GPU
 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceWriteableAfterSnapshotRelease_Gpu, reporter, context) {
     for (auto& surface_func : { &create_gpu_surface, &create_gpu_scratch_surface }) {
         SkAutoTUnref<SkSurface> surface(surface_func(context, kPremul_SkAlphaType, nullptr));
         test_writable_after_snapshot_release(reporter, surface);
     }
 }
 #endif
 
 #if SK_SUPPORT_GPU
 static void test_crbug263329(skiatest::Reporter* reporter,
                              SkSurface* surface1,
                              SkSurface* surface2) {
     // This is a regression test for crbug.com/263329
     // Bug was caused by onCopyOnWrite releasing the old surface texture
     // back to the scratch texture pool even though the texture is used
     // by and active SkImage_Gpu.
     SkCanvas* canvas1 = surface1->getCanvas();
     SkCanvas* canvas2 = surface2->getCanvas();
     canvas1->clear(1);
-    SkAutoTUnref<SkImage> image1(surface1->newImageSnapshot());
+    sk_sp<SkImage> image1(surface1->makeImageSnapshot());
     // Trigger copy on write, new backing is a scratch texture
     canvas1->clear(2);
-    SkAutoTUnref<SkImage> image2(surface1->newImageSnapshot());
+    sk_sp<SkImage> image2(surface1->makeImageSnapshot());
     // Trigger copy on write, old backing should not be returned to scratch
     // pool because it is held by image2
     canvas1->clear(3);
 
     canvas2->clear(4);
-    SkAutoTUnref<SkImage> image3(surface2->newImageSnapshot());
+    sk_sp<SkImage> image3(surface2->makeImageSnapshot());
     // Trigger copy on write on surface2. The new backing store should not
     // be recycling a texture that is held by an existing image.
     canvas2->clear(5);
-    SkAutoTUnref<SkImage> image4(surface2->newImageSnapshot());
+    sk_sp<SkImage> image4(surface2->makeImageSnapshot());
     REPORTER_ASSERT(reporter, as_IB(image4)->peekTexture() != as_IB(image3)->peekTexture());
     // The following assertion checks crbug.com/263329
     REPORTER_ASSERT(reporter, as_IB(image4)->peekTexture() != as_IB(image2)->peekTexture());
     REPORTER_ASSERT(reporter, as_IB(image4)->peekTexture() != as_IB(image1)->peekTexture());
     REPORTER_ASSERT(reporter, as_IB(image3)->peekTexture() != as_IB(image2)->peekTexture());
     REPORTER_ASSERT(reporter, as_IB(image3)->peekTexture() != as_IB(image1)->peekTexture());
     REPORTER_ASSERT(reporter, as_IB(image2)->peekTexture() != as_IB(image1)->peekTexture());
 }
 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceCRBug263329_Gpu, reporter, context) {
     for (auto& surface_func : { &create_gpu_surface, &create_gpu_scratch_surface }) {
         SkAutoTUnref<SkSurface> surface1(surface_func(context, kPremul_SkAlphaType, nullptr));
         SkAutoTUnref<SkSurface> surface2(surface_func(context, kPremul_SkAlphaType, nullptr));
         test_crbug263329(reporter, surface1, surface2);
     }
 }
 #endif
 
 DEF_TEST(SurfaceGetTexture, reporter) {
     SkAutoTUnref<SkSurface> surface(create_surface());
-    SkAutoTUnref<SkImage> image(surface->newImageSnapshot());
+    sk_sp<SkImage> image(surface->makeImageSnapshot());
     REPORTER_ASSERT(reporter, as_IB(image)->peekTexture() == nullptr);
     surface->notifyContentWillChange(SkSurface::kDiscard_ContentChangeMode);
     REPORTER_ASSERT(reporter, as_IB(image)->peekTexture() == nullptr);
 }
 #if SK_SUPPORT_GPU
 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfacepeekTexture_Gpu, reporter, context) {
     for (auto& surface_func : { &create_gpu_surface, &create_gpu_scratch_surface }) {
         SkAutoTUnref<SkSurface> surface(surface_func(context, kPremul_SkAlphaType, nullptr));
-        SkAutoTUnref<SkImage> image(surface->newImageSnapshot());
+        sk_sp<SkImage> image(surface->makeImageSnapshot());
         GrTexture* texture = as_IB(image)->peekTexture();
         REPORTER_ASSERT(reporter, texture);
         REPORTER_ASSERT(reporter, 0 != texture->getTextureHandle());
         surface->notifyContentWillChange(SkSurface::kDiscard_ContentChangeMode);
         REPORTER_ASSERT(reporter, as_IB(image)->peekTexture() == texture);
     }
 }
 #endif
 
 #if SK_SUPPORT_GPU
 #include "GrGpuResourcePriv.h"
 #include "SkGpuDevice.h"
 #include "SkImage_Gpu.h"
 #include "SkSurface_Gpu.h"
 
 static SkBudgeted is_budgeted(SkSurface* surf) {
     return ((SkSurface_Gpu*)surf)->getDevice()->accessRenderTarget()->resourcePriv().isBudgeted();
 }
 
 static SkBudgeted is_budgeted(SkImage* image) {
     return ((SkImage_Gpu*)image)->peekTexture()->resourcePriv().isBudgeted();
 }
 
+static SkBudgeted is_budgeted(const sk_sp<SkImage> image) {
+    return is_budgeted(image.get());
+}
+
 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceBudget, reporter, context) {
     SkImageInfo info = SkImageInfo::MakeN32Premul(8,8);
     for (auto sbudgeted : { SkBudgeted::kNo, SkBudgeted::kYes }) {
         for (auto ibudgeted : { SkBudgeted::kNo, SkBudgeted::kYes }) {
             SkAutoTUnref<SkSurface>
                 surface(SkSurface::NewRenderTarget(context, sbudgeted, info, 0));
             SkASSERT(surface);
             REPORTER_ASSERT(reporter, sbudgeted == is_budgeted(surface));
 
-            SkAutoTUnref<SkImage> image(surface->newImageSnapshot(ibudgeted));
+            sk_sp<SkImage> image(surface->makeImageSnapshot(ibudgeted));
 
             // Initially the image shares a texture with the surface, and the surface decides
             // whether it is budgeted or not.
             REPORTER_ASSERT(reporter, sbudgeted == is_budgeted(surface));
             REPORTER_ASSERT(reporter, sbudgeted == is_budgeted(image));
 
             // Now trigger copy-on-write
             surface->getCanvas()->clear(SK_ColorBLUE);
 
             // They don't share a texture anymore. They should each have made their own budget
@@ skipping 10 matching lines @@
                             SkSurface::ContentChangeMode mode) {
     // Test passes by not asserting
     surface->notifyContentWillChange(mode);
     SkDEBUGCODE(surface->validate();)
 }
 static void test_no_canvas2(skiatest::Reporter* reporter,
                             SkSurface* surface,
                             SkSurface::ContentChangeMode mode) {
     // Verifies the robustness of SkSurface for handling use cases where calls
     // are made before a canvas is created.
-    SkImage* image1 = surface->newImageSnapshot();
-    SkAutoTUnref<SkImage> aur_image1(image1);
+    sk_sp<SkImage> image1 = surface->makeImageSnapshot();
+    sk_sp<SkImage> aur_image1(image1);
     SkDEBUGCODE(image1->validate();)
     SkDEBUGCODE(surface->validate();)
     surface->notifyContentWillChange(mode);
     SkDEBUGCODE(image1->validate();)
     SkDEBUGCODE(surface->validate();)
-    SkImage* image2 = surface->newImageSnapshot();
-    SkAutoTUnref<SkImage> aur_image2(image2);
+    sk_sp<SkImage> image2 = surface->makeImageSnapshot();
+    sk_sp<SkImage> aur_image2(image2);
     SkDEBUGCODE(image2->validate();)
     SkDEBUGCODE(surface->validate();)
     REPORTER_ASSERT(reporter, image1 != image2);
 }
 DEF_TEST(SurfaceNoCanvas, reporter) {
     SkSurface::ContentChangeMode modes[] =
             { SkSurface::kDiscard_ContentChangeMode, SkSurface::kRetain_ContentChangeMode};
     for (auto& test_func : { &test_no_canvas1, &test_no_canvas2 }) {
         for (auto& mode : modes) {
             SkAutoTUnref<SkSurface> surface(create_surface());
@@ skipping 14 matching lines @@
             }
         }
     }
 }
 #endif
 
 static void check_rowbytes_remain_consistent(SkSurface* surface, skiatest::Reporter* reporter) {
     SkPixmap surfacePM;
     REPORTER_ASSERT(reporter, surface->peekPixels(&surfacePM));
 
-    SkAutoTUnref<SkImage> image(surface->newImageSnapshot());
+    sk_sp<SkImage> image(surface->makeImageSnapshot());
     SkPixmap pm;
     REPORTER_ASSERT(reporter, image->peekPixels(&pm));
 
     REPORTER_ASSERT(reporter, surfacePM.rowBytes() == pm.rowBytes());
 
     // trigger a copy-on-write
     surface->getCanvas()->drawPaint(SkPaint());
-    SkAutoTUnref<SkImage> image2(surface->newImageSnapshot());
+    sk_sp<SkImage> image2(surface->makeImageSnapshot());
     REPORTER_ASSERT(reporter, image->uniqueID() != image2->uniqueID());
 
     SkPixmap pm2;
     REPORTER_ASSERT(reporter, image2->peekPixels(&pm2));
     REPORTER_ASSERT(reporter, pm2.rowBytes() == pm.rowBytes());
 }
 
 DEF_TEST(surface_rowbytes, reporter) {
     const SkImageInfo info = SkImageInfo::MakeN32Premul(100, 100);
 
@@ skipping 53 matching lines @@
     }
 }
 
 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceClear_Gpu, reporter, context) {
     std::function<GrSurface*(SkSurface*)> grSurfaceGetters[] = {
         [] (SkSurface* s){ return s->getCanvas()->internal_private_accessTopLayerRenderTarget(); },
         [] (SkSurface* s){
             SkBaseDevice* d =
                 s->getCanvas()->getDevice_just_for_deprecated_compatibility_testing();
             return d->accessRenderTarget(); },
-        [] (SkSurface* s){ SkAutoTUnref<SkImage> i(s->newImageSnapshot());
+        [] (SkSurface* s){ sk_sp<SkImage> i(s->makeImageSnapshot());
                            return as_IB(i)->peekTexture(); },
     };
     for (auto grSurfaceGetter : grSurfaceGetters) {
         for (auto& surface_func : {&create_gpu_surface, &create_gpu_scratch_surface}) {
             SkSurface* surface = surface_func(context, kPremul_SkAlphaType, nullptr);
             test_surface_clear(reporter, surface, grSurfaceGetter, 0x0);
         }
         // Wrapped RTs are *not* supposed to clear (to allow client to partially update a surface).
         static const int kWidth = 10;
         static const int kHeight = 10;
@@ skipping 10 matching lines @@
         desc.fHeight = kHeight;
         desc.fFlags = kRenderTarget_GrBackendTextureFlag;
         desc.fTextureHandle = textureObject;
 
         SkSurface* surface = SkSurface::NewFromBackendTexture(context, desc, nullptr);
         test_surface_clear(reporter, surface, grSurfaceGetter, 0xABABABAB);
         context->getGpu()->deleteTestingOnlyBackendTexture(textureObject);
     }
 }
 #endif