switch surface to sk_sp

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"
 #include "SkDevice.h"
 #include "SkImage_Base.h"
 #include "SkPath.h"
 #include "SkRRect.h"
 #include "SkSurface.h"
 #include "SkUtils.h"
 #include "Test.h"
 
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
 #include "GrGpu.h"
 #endif
 
 #include <initializer_list>
 
 static void release_direct_surface_storage(void* pixels, void* context) {
     SkASSERT(pixels == context);
     sk_free(pixels);
 }
-static SkSurface* create_surface(SkAlphaType at = kPremul_SkAlphaType,
-                                 SkImageInfo* requestedInfo = nullptr) {
+static sk_sp<SkSurface> create_surface(SkAlphaType at = kPremul_SkAlphaType,
+                                       SkImageInfo* requestedInfo = nullptr) {
     const SkImageInfo info = SkImageInfo::MakeN32(10, 10, at);
     if (requestedInfo) {
         *requestedInfo = info;
     }
-    return SkSurface::NewRaster(info);
+    return SkSurface::MakeRaster(info);
 }
-static SkSurface* create_direct_surface(SkAlphaType at = kPremul_SkAlphaType,
-                                        SkImageInfo* requestedInfo = nullptr) {
+static sk_sp<SkSurface> create_direct_surface(SkAlphaType at = kPremul_SkAlphaType,
+                                              SkImageInfo* requestedInfo = nullptr) {
     const SkImageInfo info = SkImageInfo::MakeN32(10, 10, at);
     if (requestedInfo) {
         *requestedInfo = info;
     }
     const size_t rowBytes = info.minRowBytes();
     void* storage = sk_malloc_throw(info.getSafeSize(rowBytes));
-    return SkSurface::NewRasterDirectReleaseProc(info, storage, rowBytes,
-                                                 release_direct_surface_storage,
-                                                 storage);
+    return SkSurface::MakeRasterDirectReleaseProc(info, storage, rowBytes,
+                                                  release_direct_surface_storage,
+                                                  storage);
 }
 #if SK_SUPPORT_GPU
-static SkSurface* create_gpu_surface(GrContext* context, SkAlphaType at = kPremul_SkAlphaType,
-                                     SkImageInfo* requestedInfo = nullptr) {
+static sk_sp<SkSurface> create_gpu_surface(GrContext* context, SkAlphaType at = kPremul_SkAlphaType,
+                                           SkImageInfo* requestedInfo = nullptr) {
     const SkImageInfo info = SkImageInfo::MakeN32(10, 10, at);
     if (requestedInfo) {
         *requestedInfo = info;
     }
-    return SkSurface::NewRenderTarget(context, SkBudgeted::kNo, info, 0, nullptr);
+    return SkSurface::MakeRenderTarget(context, SkBudgeted::kNo, info, 0, nullptr);
 }
-static SkSurface* create_gpu_scratch_surface(GrContext* context,
-                                             SkAlphaType at = kPremul_SkAlphaType,
-                                             SkImageInfo* requestedInfo = nullptr) {
+static sk_sp<SkSurface> create_gpu_scratch_surface(GrContext* context,
+                                                   SkAlphaType at = kPremul_SkAlphaType,
+                                                   SkImageInfo* requestedInfo = nullptr) {
     const SkImageInfo info = SkImageInfo::MakeN32(10, 10, at);
     if (requestedInfo) {
         *requestedInfo = info;
     }
-    return SkSurface::NewRenderTarget(context, SkBudgeted::kYes, info, 0, nullptr);
+    return SkSurface::MakeRenderTarget(context, SkBudgeted::kYes, info, 0, nullptr);
 }
 #endif
 
 DEF_TEST(SurfaceEmpty, reporter) {
     const SkImageInfo info = SkImageInfo::Make(0, 0, kN32_SkColorType, kPremul_SkAlphaType);
-    REPORTER_ASSERT(reporter, nullptr == SkSurface::NewRaster(info));
-    REPORTER_ASSERT(reporter, nullptr == SkSurface::NewRasterDirect(info, nullptr, 0));
+    REPORTER_ASSERT(reporter, nullptr == SkSurface::MakeRaster(info));
+    REPORTER_ASSERT(reporter, nullptr == SkSurface::MakeRasterDirect(info, nullptr, 0));
 
 }
 #if SK_SUPPORT_GPU
 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceEmpty_Gpu, reporter, context) {
     const SkImageInfo info = SkImageInfo::Make(0, 0, kN32_SkColorType, kPremul_SkAlphaType);
     REPORTER_ASSERT(reporter, nullptr ==
-                    SkSurface::NewRenderTarget(context, SkBudgeted::kNo, info, 0, nullptr));
+                    SkSurface::MakeRenderTarget(context, SkBudgeted::kNo, info, 0, nullptr));
 }
 #endif
 
 #if SK_SUPPORT_GPU
 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceWrappedTexture, reporter, context) {
     GrGpu* gpu = context->getGpu();
     if (!gpu) {
         return;
     }
 
     // Test the wrapped factory for SkSurface by creating a backend texture and then wrap it in
     // a SkSurface.
     static const int kW = 100;
     static const int kH = 100;
     static const uint32_t kOrigColor = 0xFFAABBCC;
     SkAutoTArray<uint32_t> pixels(kW * kH);
     sk_memset32(pixels.get(), kOrigColor, kW * kH);
     GrBackendObject texHandle = gpu->createTestingOnlyBackendTexture(pixels.get(), kW, kH,
                                                                      kRGBA_8888_GrPixelConfig);
 
     GrBackendTextureDesc wrappedDesc;
     wrappedDesc.fConfig = kRGBA_8888_GrPixelConfig;
     wrappedDesc.fWidth = kW;
     wrappedDesc.fHeight = kH;
     wrappedDesc.fOrigin = kBottomLeft_GrSurfaceOrigin;
     wrappedDesc.fSampleCnt = 0;
     wrappedDesc.fFlags = kRenderTarget_GrBackendTextureFlag;
     wrappedDesc.fTextureHandle = texHandle;
 
-    SkAutoTUnref<SkSurface> surface(
-        SkSurface::NewWrappedRenderTarget(context, wrappedDesc, nullptr));
+    auto surface(SkSurface::MakeFromBackendTexture(context, wrappedDesc, nullptr));
     REPORTER_ASSERT(reporter, surface);
     if (surface) {
         // Validate that we can draw to the canvas and that the original texture color is preserved
         // in pixels that aren't rendered to via the surface.
         SkPaint paint;
         static const SkColor kRectColor = ~kOrigColor | 0xFF000000;
         paint.setColor(kRectColor);
         surface->getCanvas()->drawRect(SkRect::MakeWH(SkIntToScalar(kW), SkIntToScalar(kH)/2),
                                        paint);
         SkImageInfo readInfo = SkImageInfo::MakeN32Premul(kW, kH);
@@ skipping 23 matching lines @@
                     stop = true;
                 }
             }
         }
     }
     gpu->deleteTestingOnlyBackendTexture(texHandle);
 }
 #endif
 
 static void test_canvas_peek(skiatest::Reporter* reporter,
-                             SkSurface* surface,
+                             sk_sp<SkSurface>& surface,
                              const SkImageInfo& requestInfo,
                              bool expectPeekSuccess) {
     const SkColor color = SK_ColorRED;
     const SkPMColor pmcolor = SkPreMultiplyColor(color);
     surface->getCanvas()->clear(color);
 
     SkPixmap pmap;
     bool success = surface->getCanvas()->peekPixels(&pmap);
     REPORTER_ASSERT(reporter, expectPeekSuccess == success);
 
     SkPixmap pmap2;
     const void* addr2 = surface->peekPixels(&pmap2) ? pmap2.addr() : nullptr;
 
     if (success) {
         REPORTER_ASSERT(reporter, requestInfo == pmap.info());
         REPORTER_ASSERT(reporter, requestInfo.minRowBytes() <= pmap.rowBytes());
         REPORTER_ASSERT(reporter, pmcolor == *pmap.addr32());
 
         REPORTER_ASSERT(reporter, pmap.addr() == pmap2.addr());
         REPORTER_ASSERT(reporter, pmap.info() == pmap2.info());
         REPORTER_ASSERT(reporter, pmap.rowBytes() == pmap2.rowBytes());
     } else {
         REPORTER_ASSERT(reporter, nullptr == addr2);
     }
 }
 DEF_TEST(SurfaceCanvasPeek, reporter) {
     for (auto& surface_func : { &create_surface, &create_direct_surface }) {
         SkImageInfo requestInfo;
-        SkAutoTUnref<SkSurface> surface(surface_func(kPremul_SkAlphaType, &requestInfo));
+        auto surface(surface_func(kPremul_SkAlphaType, &requestInfo));
         test_canvas_peek(reporter, surface, requestInfo, true);
     }
 }
 #if SK_SUPPORT_GPU
 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceCanvasPeek_Gpu, reporter, context) {
     for (auto& surface_func : { &create_gpu_surface, &create_gpu_scratch_surface }) {
         SkImageInfo requestInfo;
-        SkAutoTUnref<SkSurface> surface(surface_func(context, kPremul_SkAlphaType, &requestInfo));
+        auto surface(surface_func(context, kPremul_SkAlphaType, &requestInfo));
         test_canvas_peek(reporter, surface, requestInfo, false);
     }
 }
 #endif
 
 // For compatibility with clients that still call accessBitmap(), we need to ensure that we bump
 // the bitmap's genID when we draw to it, else they won't know it has new values. When they are
 // exclusively using surface/image, and we can hide accessBitmap from device, we can remove this
 // test.
-void test_access_pixels(skiatest::Reporter* reporter, SkSurface* surface) {
+void test_access_pixels(skiatest::Reporter* reporter, const sk_sp<SkSurface>& surface) {
     SkCanvas* canvas = surface->getCanvas();
     canvas->clear(0);
 
     SkBaseDevice* device = canvas->getDevice_just_for_deprecated_compatibility_testing();
     SkBitmap bm = device->accessBitmap(false);
     uint32_t genID0 = bm.getGenerationID();
     // Now we draw something, which needs to "dirty" the genID (sorta like copy-on-write)
     canvas->drawColor(SK_ColorBLUE);
     // Now check that we get a different genID
     uint32_t genID1 = bm.getGenerationID();
     REPORTER_ASSERT(reporter, genID0 != genID1);
 }
 DEF_TEST(SurfaceAccessPixels, reporter) {
     for (auto& surface_func : { &create_surface, &create_direct_surface }) {
-        SkAutoTUnref<SkSurface> surface(surface_func(kPremul_SkAlphaType, nullptr));
+        auto surface(surface_func(kPremul_SkAlphaType, nullptr));
         test_access_pixels(reporter, surface);
     }
 }
 #if SK_SUPPORT_GPU
 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceAccessPixels_Gpu, reporter, context) {
     for (auto& surface_func : { &create_gpu_surface, &create_gpu_scratch_surface }) {
-        SkAutoTUnref<SkSurface> surface(surface_func(context, kPremul_SkAlphaType, nullptr));
+        auto surface(surface_func(context, kPremul_SkAlphaType, nullptr));
         test_access_pixels(reporter, surface);
     }
 }
 #endif
 
-static void test_snapshot_alphatype(skiatest::Reporter* reporter, SkSurface* surface,
+static void test_snapshot_alphatype(skiatest::Reporter* reporter, const sk_sp<SkSurface>& surface,
                                     bool expectOpaque) {
     REPORTER_ASSERT(reporter, surface);
     if (surface) {
         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;
-            SkAutoTUnref<SkSurface> surface(surface_func(alphaType, nullptr));
+            auto surface(surface_func(alphaType, nullptr));
             test_snapshot_alphatype(reporter, surface, isOpaque);
         }
     }
 }
 #if SK_SUPPORT_GPU
 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceSnapshotAlphaType_Gpu, reporter, context) {
     for (auto& surface_func : { &create_gpu_surface, &create_gpu_scratch_surface }) {
         for (auto& isOpaque : { true, false }) {
             SkAlphaType alphaType = isOpaque ? kOpaque_SkAlphaType : kPremul_SkAlphaType;
-            SkAutoTUnref<SkSurface> surface(surface_func(context, alphaType, nullptr));
+            auto surface(surface_func(context, alphaType, nullptr));
             test_snapshot_alphatype(reporter, surface, isOpaque);
         }
     }
 }
 #endif
 
 static GrBackendObject get_surface_backend_texture_handle(
     SkSurface* s, SkSurface::BackendHandleAccess a) {
     return s->getTextureHandle(a);
 }
@@ skipping 20 matching lines @@
 }
 DEF_TEST(SurfaceBackendHandleAccessCopyOnWrite, reporter) {
     const SkSurface::BackendHandleAccess accessModes[] = {
         SkSurface::kFlushRead_BackendHandleAccess,
         SkSurface::kFlushWrite_BackendHandleAccess,
         SkSurface::kDiscardWrite_BackendHandleAccess,
     };
     for (auto& handle_access_func :
             { &get_surface_backend_texture_handle, &get_surface_backend_render_target_handle }) {
         for (auto& accessMode : accessModes) {
-            SkAutoTUnref<SkSurface> surface(create_surface());
-            test_backend_handle_access_copy_on_write(reporter, surface, accessMode,
+            auto surface(create_surface());
+            test_backend_handle_access_copy_on_write(reporter, surface.get(), accessMode,
                                                      handle_access_func);
         }
     }
 }
 #if SK_SUPPORT_GPU
 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceBackendHandleAccessCopyOnWrite_Gpu, reporter, context) {
         const SkSurface::BackendHandleAccess accessModes[] = {
         SkSurface::kFlushRead_BackendHandleAccess,
         SkSurface::kFlushWrite_BackendHandleAccess,
         SkSurface::kDiscardWrite_BackendHandleAccess,
     };
     for (auto& surface_func : { &create_gpu_surface, &create_gpu_scratch_surface }) {
         for (auto& handle_access_func :
                 { &get_surface_backend_texture_handle, &get_surface_backend_render_target_handle }) {
             for (auto& accessMode : accessModes) {
-                SkAutoTUnref<SkSurface> surface(surface_func(context, kPremul_SkAlphaType,
-                                                             nullptr));
-                test_backend_handle_access_copy_on_write(reporter, surface, accessMode,
+                auto surface(surface_func(context, kPremul_SkAlphaType, nullptr));
+                test_backend_handle_access_copy_on_write(reporter, surface.get(), accessMode,
                                                          handle_access_func);
             }
         }
     }
 }
 #endif
 
 static bool same_image(SkImage* a, SkImage* b,
                        std::function<intptr_t(SkImage*)> getImageBackingStore) {
     return getImageBackingStore(a) == getImageBackingStore(b);
@@ skipping 57 matching lines @@
         REPORTER_ASSERT(reporter, success);
         return reinterpret_cast<intptr_t>(pm.addr());
     };
     auto getSufaceBackingStore = [reporter](SkSurface* surface) {
         SkPixmap pmap;
         const void* pixels = surface->getCanvas()->peekPixels(&pmap) ? pmap.addr() : nullptr;
         REPORTER_ASSERT(reporter, pixels);
         return reinterpret_cast<intptr_t>(pixels);
     };
 
-    SkAutoTUnref<SkSurface> surface(create_surface());
-    test_unique_image_snap(reporter, surface, false, getImageBackingStore, getSufaceBackingStore);
-    surface.reset(create_direct_surface());
-    test_unique_image_snap(reporter, surface, true, getImageBackingStore, getSufaceBackingStore);
+    auto surface(create_surface());
+    test_unique_image_snap(reporter, surface.get(), false, getImageBackingStore,
+                           getSufaceBackingStore);
+    surface = create_direct_surface();
+    test_unique_image_snap(reporter, surface.get(), true, getImageBackingStore,
+                           getSufaceBackingStore);
 }
 
 #if SK_SUPPORT_GPU
 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(UniqueImageSnapshot_Gpu, reporter, context) {
     for (auto& surface_func : { &create_gpu_surface, &create_gpu_scratch_surface }) {
-        SkAutoTUnref<SkSurface> surface(surface_func(context, kOpaque_SkAlphaType, nullptr));
+        auto surface(surface_func(context, kOpaque_SkAlphaType, nullptr));
 
         auto imageBackingStore = [reporter](SkImage* image) {
             GrTexture* texture = as_IB(image)->peekTexture();
             if (!texture) {
                 ERRORF(reporter, "Not texture backed.");
                 return static_cast<intptr_t>(0);
             }
             return static_cast<intptr_t>(texture->getUniqueID());
         };
 
         auto surfaceBackingStore = [reporter](SkSurface* surface) {
             GrRenderTarget* rt =
                 surface->getCanvas()->internal_private_accessTopLayerRenderTarget();
             if (!rt) {
                 ERRORF(reporter, "Not render target backed.");
                 return static_cast<intptr_t>(0);
             }
             return static_cast<intptr_t>(rt->getUniqueID());
         };
 
-        test_unique_image_snap(reporter, surface, false, imageBackingStore, surfaceBackingStore);
+        test_unique_image_snap(reporter, surface.get(), false, imageBackingStore,
+                               surfaceBackingStore);
 
         // Test again with a "direct" render target;
         GrBackendObject textureObject = context->getGpu()->createTestingOnlyBackendTexture(nullptr,
             10, 10, kRGBA_8888_GrPixelConfig);
         GrBackendTextureDesc desc;
         desc.fConfig = kRGBA_8888_GrPixelConfig;
         desc.fWidth = 10;
         desc.fHeight = 10;
         desc.fFlags = kRenderTarget_GrBackendTextureFlag;
         desc.fTextureHandle = textureObject;
         GrTexture* texture = context->textureProvider()->wrapBackendTexture(desc);
         {
-            SkAutoTUnref<SkSurface> surface(
-                SkSurface::NewRenderTargetDirect(texture->asRenderTarget()));
-            test_unique_image_snap(reporter, surface, true, imageBackingStore,
+            auto surface(SkSurface::MakeRenderTargetDirect(texture->asRenderTarget()));
+            test_unique_image_snap(reporter, surface.get(), true, imageBackingStore,
                                    surfaceBackingStore);
         }
         texture->unref();
         context->getGpu()->deleteTestingOnlyBackendTexture(textureObject);
     }
 }
 #endif
 
 #if SK_SUPPORT_GPU
 // May we (soon) eliminate the need to keep testing this, by hiding the bloody device!
@@ skipping 48 matching lines @@
     // 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}) {
-                SkAutoTUnref<SkSurface> surface(surface_func(context, kPremul_SkAlphaType,
-                                                             nullptr));
-                test_func(reporter, surface, handle_access_func);
+                auto surface(surface_func(context, kPremul_SkAlphaType, nullptr));
+                test_func(reporter, surface.get(), handle_access_func);
             }
         }
     }
 }
 #endif
 
 // Verify that the right canvas commands trigger a copy on write.
 static void test_copy_on_write(skiatest::Reporter* reporter, SkSurface* surface) {
     SkCanvas* canvas = surface->getCanvas();
 
@@ skipping 62 matching lines @@
     EXPECT_COPY_ON_WRITE(drawBitmap(testBitmap, 0, 0))
     EXPECT_COPY_ON_WRITE(drawBitmapRect(testBitmap, testRect, nullptr))
     EXPECT_COPY_ON_WRITE(drawBitmapNine(testBitmap, testIRect, testRect, nullptr))
     EXPECT_COPY_ON_WRITE(drawText(testText.c_str(), testText.size(), 0, 1, testPaint))
     EXPECT_COPY_ON_WRITE(drawPosText(testText.c_str(), testText.size(), testPoints2, \
         testPaint))
     EXPECT_COPY_ON_WRITE(drawTextOnPath(testText.c_str(), testText.size(), testPath, nullptr, \
         testPaint))
 }
 DEF_TEST(SurfaceCopyOnWrite, reporter) {
-    SkAutoTUnref<SkSurface> surface(create_surface());
-    test_copy_on_write(reporter, surface);
+    test_copy_on_write(reporter, create_surface().get());
 }
 #if SK_SUPPORT_GPU
 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceCopyOnWrite_Gpu, reporter, context) {
     for (auto& surface_func : { &create_gpu_surface, &create_gpu_scratch_surface }) {
-        SkAutoTUnref<SkSurface> surface(surface_func(context, kPremul_SkAlphaType, nullptr));
-        test_copy_on_write(reporter, surface);
+        auto surface(surface_func(context, kPremul_SkAlphaType, nullptr));
+        test_copy_on_write(reporter, surface.get());
     }
 }
 #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->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);
+    test_writable_after_snapshot_release(reporter, create_surface().get());
 }
 #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);
+        auto surface(surface_func(context, kPremul_SkAlphaType, nullptr));
+        test_writable_after_snapshot_release(reporter, surface.get());
     }
 }
 #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
@@ skipping 19 matching lines @@
     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);
+        auto surface1(surface_func(context, kPremul_SkAlphaType, nullptr));
+        auto surface2(surface_func(context, kPremul_SkAlphaType, nullptr));
+        test_crbug263329(reporter, surface1.get(), surface2.get());
     }
 }
 #endif
 
 DEF_TEST(SurfaceGetTexture, reporter) {
-    SkAutoTUnref<SkSurface> surface(create_surface());
+    auto surface(create_surface());
     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));
+        auto surface(surface_func(context, kPremul_SkAlphaType, nullptr));
         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(const sk_sp<SkSurface>& surf) {
+    SkSurface_Gpu* gsurf = (SkSurface_Gpu*)surf.get();
+    return gsurf->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));
+            auto surface(SkSurface::MakeRenderTarget(context, sbudgeted, info));
             SkASSERT(surface);
             REPORTER_ASSERT(reporter, sbudgeted == is_budgeted(surface));
 
             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));
 
@@ skipping 32 matching lines @@
     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());
-            test_func(reporter, surface, mode);
+            test_func(reporter, create_surface().get(), mode);
         }
     }
 }
 #if SK_SUPPORT_GPU
 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceNoCanvas_Gpu, reporter, context) {
     SkSurface::ContentChangeMode modes[] =
             { SkSurface::kDiscard_ContentChangeMode, SkSurface::kRetain_ContentChangeMode};
     for (auto& surface_func : { &create_gpu_surface, &create_gpu_scratch_surface }) {
         for (auto& test_func : { &test_no_canvas1, &test_no_canvas2 }) {
             for (auto& mode : modes) {
-                SkAutoTUnref<SkSurface> surface(
-                    surface_func(context, kPremul_SkAlphaType, nullptr));
-                test_func(reporter, surface, mode);
+                auto surface(surface_func(context, kPremul_SkAlphaType, nullptr));
+                test_func(reporter, surface.get(), mode);
             }
         }
     }
 }
 #endif
 
 static void check_rowbytes_remain_consistent(SkSurface* surface, skiatest::Reporter* reporter) {
     SkPixmap surfacePM;
     REPORTER_ASSERT(reporter, surface->peekPixels(&surfacePM));
 
     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());
     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);
 
-    SkAutoTUnref<SkSurface> surf0(SkSurface::NewRaster(info));
-    check_rowbytes_remain_consistent(surf0, reporter);
+    auto surf0(SkSurface::MakeRaster(info));
+    check_rowbytes_remain_consistent(surf0.get(), reporter);
 
     // specify a larger rowbytes
-    SkAutoTUnref<SkSurface> surf1(SkSurface::NewRaster(info, 500, nullptr));
-    check_rowbytes_remain_consistent(surf1, reporter);
+    auto surf1(SkSurface::MakeRaster(info, 500, nullptr));
+    check_rowbytes_remain_consistent(surf1.get(), reporter);
 
     // Try some illegal rowByte values
-    SkSurface* s = SkSurface::NewRaster(info, 396, nullptr);    // needs to be at least 400
+    auto s = SkSurface::MakeRaster(info, 396, nullptr);    // needs to be at least 400
     REPORTER_ASSERT(reporter, nullptr == s);
-    s = SkSurface::NewRaster(info, 1 << 30, nullptr); // allocation to large
+    s = SkSurface::MakeRaster(info, 1 << 30, nullptr); // allocation to large
     REPORTER_ASSERT(reporter, nullptr == s);
 }
 
 #if SK_SUPPORT_GPU
 
-void test_surface_clear(skiatest::Reporter* reporter, SkSurface* surfacePtr,
+void test_surface_clear(skiatest::Reporter* reporter, sk_sp<SkSurface> surface,
                         std::function<GrSurface*(SkSurface*)> grSurfaceGetter,
                         uint32_t expectedValue) {
-    SkAutoTUnref<SkSurface> surface(surfacePtr);
     if (!surface) {
         ERRORF(reporter, "Could not create GPU SkSurface.");
         return;
     }
     int w = surface->width();
     int h = surface->height();
     SkAutoTDeleteArray<uint32_t> pixels(new uint32_t[w * h]);
     memset(pixels.get(), ~expectedValue, sizeof(uint32_t) * w * h);
 
-    SkAutoTUnref<GrSurface> grSurface(SkSafeRef(grSurfaceGetter(surface)));
+    SkAutoTUnref<GrSurface> grSurface(SkSafeRef(grSurfaceGetter(surface.get())));
     if (!grSurface) {
         ERRORF(reporter, "Could access render target of GPU SkSurface.");
         return;
     }
-    SkASSERT(surface->unique());
     surface.reset();
     grSurface->readPixels(0, 0, w, h, kRGBA_8888_GrPixelConfig, pixels.get());
     for (int y = 0; y < h; ++y) {
         for (int x = 0; x < w; ++x) {
             uint32_t pixel = pixels.get()[y * w + x];
             if (pixel != expectedValue) {
                 SkString msg;
                 if (expectedValue) {
                     msg = "SkSurface should have left render target unmodified";
                 } else {
@@ skipping 13 matching lines @@
         [] (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){ 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);
+            auto 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;
         SkAutoTDeleteArray<uint32_t> pixels(new uint32_t[kWidth * kHeight]);
         memset(pixels.get(), 0xAB, sizeof(uint32_t) * kWidth * kHeight);
 
         GrBackendObject textureObject =
                 context->getGpu()->createTestingOnlyBackendTexture(pixels.get(), kWidth, kHeight,
                                                                    kRGBA_8888_GrPixelConfig);
 
         GrBackendTextureDesc desc;
         desc.fConfig = kRGBA_8888_GrPixelConfig;
         desc.fWidth = kWidth;
         desc.fHeight = kHeight;
         desc.fFlags = kRenderTarget_GrBackendTextureFlag;
         desc.fTextureHandle = textureObject;
 
-        SkSurface* surface = SkSurface::NewFromBackendTexture(context, desc, nullptr);
+        auto surface = SkSurface::MakeFromBackendTexture(context, desc, nullptr);
         test_surface_clear(reporter, surface, grSurfaceGetter, 0xABABABAB);
         context->getGpu()->deleteTestingOnlyBackendTexture(textureObject);
     }
 }
 #endif