Remove SkAutoTDelete.

Replace with std::unique_ptr.

Change-Id: I5806cfbb30515fcb20e5e66ce13fb5f3b8728176
Reviewed-on: https://skia-review.googlesource.com/4381
Commit-Queue: Ben Wagner <bungeman@google.com>
Reviewed-by: Mike Klein <mtklein@chromium.org>

24 files changed, 133 insertions, 134 deletions

diff --git a/tests/BadIcoTest.cpp b/tests/BadIcoTest.cpp
index 4affa85b7b..a0664f1c5e 100644
--- a/tests/BadIcoTest.cpp
+++ b/tests/BadIcoTest.cpp
@@ -28,8 +28,8 @@ DEF_TEST(BadImage, reporter) {
 
     for (size_t i = 0; i < SK_ARRAY_COUNT(badImages); ++i) {
         SkString resourcePath = SkOSPath::Join(badImagesFolder, badImages[i]);
-        SkAutoTDelete<SkStream> stream(GetResourceAsStream(resourcePath.c_str()));
-        SkAutoTDelete<SkCodec> codec(SkCodec::NewFromStream(stream.release()));
+        std::unique_ptr<SkStream> stream(GetResourceAsStream(resourcePath.c_str()));
+        std::unique_ptr<SkCodec> codec(SkCodec::NewFromStream(stream.release()));
 
         // These images are corrupt.  It's not important whether we succeed/fail in codec
         // creation or decoding.  We just want to make sure that we don't crash.
diff --git a/tests/CodecPartialTest.cpp b/tests/CodecPartialTest.cpp
index 22d4e7b594..ba1a51f4ef 100644
--- a/tests/CodecPartialTest.cpp
+++ b/tests/CodecPartialTest.cpp
@@ -28,12 +28,12 @@ static SkImageInfo standardize_info(SkCodec* codec) {
 }
 
 static bool create_truth(sk_sp<SkData> data, SkBitmap* dst) {
-    SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(std::move(data)));
+    std::unique_ptr<SkCodec> codec(SkCodec::NewFromData(std::move(data)));
     if (!codec) {
         return false;
     }
 
-    const SkImageInfo info = standardize_info(codec);
+    const SkImageInfo info = standardize_info(codec.get());
     dst->allocPixels(info);
     return SkCodec::kSuccess == codec->getPixels(info, dst->getPixels(), dst->rowBytes());
 }
@@ -108,7 +108,7 @@ static void test_partial(skiatest::Reporter* r, const char* name) {
 
     // Note that we cheat and hold on to a pointer to stream, though it is owned by
     // partialCodec.
-    SkAutoTDelete<SkCodec> partialCodec(SkCodec::NewFromStream(stream));
+    std::unique_ptr<SkCodec> partialCodec(SkCodec::NewFromStream(stream));
     if (!partialCodec) {
         // Technically, this could be a small file where half the file is not
         // enough.
@@ -116,7 +116,7 @@ static void test_partial(skiatest::Reporter* r, const char* name) {
         return;
     }
 
-    const SkImageInfo info = standardize_info(partialCodec);
+    const SkImageInfo info = standardize_info(partialCodec.get());
     SkASSERT(info == truth.info());
     SkBitmap incremental;
     incremental.allocPixels(info);
@@ -284,14 +284,14 @@ static void test_interleaved(skiatest::Reporter* r, const char* name) {
         return;
     }
     const size_t halfSize = file->size() / 2;
-    SkAutoTDelete<SkCodec> partialCodec(SkCodec::NewFromStream(
+    std::unique_ptr<SkCodec> partialCodec(SkCodec::NewFromStream(
             new HaltingStream(std::move(file), halfSize)));
     if (!partialCodec) {
         ERRORF(r, "Failed to create codec for %s", name);
         return;
     }
 
-    const SkImageInfo info = standardize_info(partialCodec);
+    const SkImageInfo info = standardize_info(partialCodec.get());
     SkBitmap incremental;
     incremental.allocPixels(info);
 
diff --git a/tests/CodecPriv.h b/tests/CodecPriv.h
index a5afb09ba4..e9ea24261d 100644
--- a/tests/CodecPriv.h
+++ b/tests/CodecPriv.h
@@ -10,7 +10,7 @@
 #include "SkData.h"
 
 inline bool decode_memory(const void* mem, size_t size, SkBitmap* bm) {
-    SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(SkData::MakeWithoutCopy(mem, size)));
+    std::unique_ptr<SkCodec> codec(SkCodec::NewFromData(SkData::MakeWithoutCopy(mem, size)));
     if (!codec) {
         return false;
     }
diff --git a/tests/CodecTest.cpp b/tests/CodecTest.cpp
index c171a7eac4..c8b573a668 100644
--- a/tests/CodecTest.cpp
+++ b/tests/CodecTest.cpp
@@ -260,16 +260,16 @@ static void check(skiatest::Reporter* r,
                   bool supportsIncomplete,
                   bool supportsNewScanlineDecoding = false) {
 
-    SkAutoTDelete<SkStream> stream(GetResourceAsStream(path));
+    std::unique_ptr<SkStream> stream(GetResourceAsStream(path));
     if (!stream) {
         return;
     }
 
-    SkAutoTDelete<SkCodec> codec(nullptr);
+    std::unique_ptr<SkCodec> codec(nullptr);
     bool isIncomplete = supportsIncomplete;
     if (isIncomplete) {
         size_t size = stream->getLength();
-        sk_sp<SkData> data((SkData::MakeFromStream(stream, 2 * size / 3)));
+        sk_sp<SkData> data((SkData::MakeFromStream(stream.get(), 2 * size / 3)));
         codec.reset(SkCodec::NewFromData(data));
     } else {
         codec.reset(SkCodec::NewFromStream(stream.release()));
@@ -289,12 +289,12 @@ static void check(skiatest::Reporter* r,
     // Scanline decoding follows.
 
     if (supportsNewScanlineDecoding && !isIncomplete) {
-        test_incremental_decode(r, codec, info, codecDigest);
+        test_incremental_decode(r, codec.get(), info, codecDigest);
         // This is only supported by codecs that use incremental decoding to
         // support subset decodes - png and jpeg (once SkJpegCodec is
         // converted).
         if (SkStrEndsWith(path, "png") || SkStrEndsWith(path, "PNG")) {
-            test_in_stripes(r, codec, info, codecDigest);
+            test_in_stripes(r, codec.get(), info, codecDigest);
         }
     }
 
@@ -397,15 +397,15 @@ static void check(skiatest::Reporter* r,
     // SkAndroidCodec tests
     if (supportsScanlineDecoding || supportsSubsetDecoding || supportsNewScanlineDecoding) {
 
-        SkAutoTDelete<SkStream> stream(GetResourceAsStream(path));
+        std::unique_ptr<SkStream> stream(GetResourceAsStream(path));
         if (!stream) {
             return;
         }
 
-        SkAutoTDelete<SkAndroidCodec> androidCodec(nullptr);
+        std::unique_ptr<SkAndroidCodec> androidCodec(nullptr);
         if (isIncomplete) {
             size_t size = stream->getLength();
-            sk_sp<SkData> data((SkData::MakeFromStream(stream, 2 * size / 3)));
+            sk_sp<SkData> data((SkData::MakeFromStream(stream.get(), 2 * size / 3)));
             androidCodec.reset(SkAndroidCodec::NewFromData(data));
         } else {
             androidCodec.reset(SkAndroidCodec::NewFromStream(stream.release()));
@@ -423,9 +423,9 @@ static void check(skiatest::Reporter* r,
 
     if (!isIncomplete) {
         // Test SkCodecImageGenerator
-        SkAutoTDelete<SkStream> stream(GetResourceAsStream(path));
-        sk_sp<SkData> fullData(SkData::MakeFromStream(stream, stream->getLength()));
-        SkAutoTDelete<SkImageGenerator> gen(
+        std::unique_ptr<SkStream> stream(GetResourceAsStream(path));
+        sk_sp<SkData> fullData(SkData::MakeFromStream(stream.get(), stream->getLength()));
+        std::unique_ptr<SkImageGenerator> gen(
                 SkCodecImageGenerator::NewFromEncodedCodec(fullData.get()));
         SkBitmap bm;
         bm.allocPixels(info);
@@ -560,11 +560,11 @@ DEF_TEST(Codec_null, r) {
 
 static void test_dimensions(skiatest::Reporter* r, const char path[]) {
     // Create the codec from the resource file
-    SkAutoTDelete<SkStream> stream(GetResourceAsStream(path));
+    std::unique_ptr<SkStream> stream(GetResourceAsStream(path));
     if (!stream) {
         return;
     }
-    SkAutoTDelete<SkAndroidCodec> codec(SkAndroidCodec::NewFromStream(stream.release()));
+    std::unique_ptr<SkAndroidCodec> codec(SkAndroidCodec::NewFromStream(stream.release()));
     if (!codec) {
         ERRORF(r, "Unable to create codec '%s'", path);
         return;
@@ -624,11 +624,11 @@ DEF_TEST(Codec_Dimensions, r) {
 }
 
 static void test_invalid(skiatest::Reporter* r, const char path[]) {
-    SkAutoTDelete<SkStream> stream(GetResourceAsStream(path));
+    std::unique_ptr<SkStream> stream(GetResourceAsStream(path));
     if (!stream) {
         return;
     }
-    SkAutoTDelete<SkCodec> codec(SkCodec::NewFromStream(stream.release()));
+    std::unique_ptr<SkCodec> codec(SkCodec::NewFromStream(stream.release()));
     REPORTER_ASSERT(r, nullptr == codec);
 }
 
@@ -649,11 +649,11 @@ DEF_TEST(Codec_Empty, r) {
 }
 
 static void test_invalid_parameters(skiatest::Reporter* r, const char path[]) {
-    SkAutoTDelete<SkStream> stream(GetResourceAsStream(path));
+    std::unique_ptr<SkStream> stream(GetResourceAsStream(path));
     if (!stream) {
         return;
     }
-    SkAutoTDelete<SkCodec> decoder(SkCodec::NewFromStream(stream.release()));
+    std::unique_ptr<SkCodec> decoder(SkCodec::NewFromStream(stream.release()));
     if (!decoder) {
         SkDebugf("Missing codec for %s\n", path);
         return;
@@ -818,7 +818,7 @@ DEF_TEST(Codec_pngChunkReader, r) {
     ChunkReader chunkReader(r);
 
     // Now read the file with SkCodec.
-    SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(wStream.detachAsData(), &chunkReader));
+    std::unique_ptr<SkCodec> codec(SkCodec::NewFromData(wStream.detachAsData(), &chunkReader));
     REPORTER_ASSERT(r, codec);
     if (!codec) {
         return;
@@ -922,7 +922,7 @@ DEF_TEST(Codec_raw_notseekable, r) {
         return;
     }
 
-    SkAutoTDelete<SkCodec> codec(SkCodec::NewFromStream(new NotAssetMemStream(std::move(data))));
+    std::unique_ptr<SkCodec> codec(SkCodec::NewFromStream(new NotAssetMemStream(std::move(data))));
     REPORTER_ASSERT(r, codec);
 
     test_info(r, codec.get(), codec->getInfo(), SkCodec::kSuccess, nullptr);
@@ -941,7 +941,7 @@ DEF_TEST(Codec_webp_peek, r) {
     }
 
     // The limit is less than webp needs to peek or read.
-    SkAutoTDelete<SkCodec> codec(SkCodec::NewFromStream(
+    std::unique_ptr<SkCodec> codec(SkCodec::NewFromStream(
                                  new LimitedPeekingMemStream(data, 25)));
     REPORTER_ASSERT(r, codec);
 
@@ -960,18 +960,18 @@ DEF_TEST(Codec_webp_peek, r) {
 // Test that SkCodec now supports an image with these bits set.
 DEF_TEST(Codec_wbmp, r) {
     const char* path = "mandrill.wbmp";
-    SkAutoTDelete<SkStream> stream(GetResourceAsStream(path));
+    std::unique_ptr<SkStream> stream(GetResourceAsStream(path));
     if (!stream) {
         return;
     }
 
     // Modify the stream to contain a second byte with some bits set.
-    auto data = SkCopyStreamToData(stream);
+    auto data = SkCopyStreamToData(stream.get());
     uint8_t* writeableData = static_cast<uint8_t*>(data->writable_data());
     writeableData[1] = static_cast<uint8_t>(~0x9F);
 
     // SkCodec should support this.
-    SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(data));
+    std::unique_ptr<SkCodec> codec(SkCodec::NewFromData(data));
     REPORTER_ASSERT(r, codec);
     if (!codec) {
         return;
@@ -988,8 +988,8 @@ DEF_TEST(Codec_wbmp_max_size, r) {
     const unsigned char maxSizeWbmp[] = { 0x00, 0x00,           // Header
                                           0x83, 0xFF, 0x7F,     // W: 65535
                                           0x83, 0xFF, 0x7F };   // H: 65535
-    SkAutoTDelete<SkStream> stream(new SkMemoryStream(maxSizeWbmp, sizeof(maxSizeWbmp), false));
-    SkAutoTDelete<SkCodec> codec(SkCodec::NewFromStream(stream.release()));
+    std::unique_ptr<SkStream> stream(new SkMemoryStream(maxSizeWbmp, sizeof(maxSizeWbmp), false));
+    std::unique_ptr<SkCodec> codec(SkCodec::NewFromStream(stream.release()));
 
     REPORTER_ASSERT(r, codec);
     if (!codec) return;
@@ -1010,11 +1010,11 @@ DEF_TEST(Codec_wbmp_max_size, r) {
 
 DEF_TEST(Codec_jpeg_rewind, r) {
     const char* path = "mandrill_512_q075.jpg";
-    SkAutoTDelete<SkStream> stream(GetResourceAsStream(path));
+    std::unique_ptr<SkStream> stream(GetResourceAsStream(path));
     if (!stream) {
         return;
     }
-    SkAutoTDelete<SkAndroidCodec> codec(SkAndroidCodec::NewFromStream(stream.release()));
+    std::unique_ptr<SkAndroidCodec> codec(SkAndroidCodec::NewFromStream(stream.release()));
     if (!codec) {
         ERRORF(r, "Unable to create codec '%s'.", path);
         return;
@@ -1037,7 +1037,7 @@ DEF_TEST(Codec_jpeg_rewind, r) {
 }
 
 static void check_color_xform(skiatest::Reporter* r, const char* path) {
-    SkAutoTDelete<SkAndroidCodec> codec(SkAndroidCodec::NewFromStream(GetResourceAsStream(path)));
+    std::unique_ptr<SkAndroidCodec> codec(SkAndroidCodec::NewFromStream(GetResourceAsStream(path)));
 
     SkAndroidCodec::AndroidOptions opts;
     opts.fSampleSize = 3;
@@ -1104,7 +1104,7 @@ static void check_round_trip(skiatest::Reporter* r, SkCodec* origCodec, const Sk
     sk_sp<SkData> data =
             sk_sp<SkData>(SkImageEncoder::EncodeData(bm1, SkImageEncoder::kPNG_Type, 100));
 
-    SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(data));
+    std::unique_ptr<SkCodec> codec(SkCodec::NewFromData(data));
     REPORTER_ASSERT(r, color_type_match(info.colorType(), codec->getInfo().colorType()));
     REPORTER_ASSERT(r, alpha_type_match(info.alphaType(), codec->getInfo().alphaType()));
 
@@ -1123,8 +1123,8 @@ static void check_round_trip(skiatest::Reporter* r, SkCodec* origCodec, const Sk
 
 DEF_TEST(Codec_PngRoundTrip, r) {
     const char* path = "mandrill_512_q075.jpg";
-    SkAutoTDelete<SkStream> stream(GetResourceAsStream(path));
-    SkAutoTDelete<SkCodec> codec(SkCodec::NewFromStream(stream.release()));
+    std::unique_ptr<SkStream> stream(GetResourceAsStream(path));
+    std::unique_ptr<SkCodec> codec(SkCodec::NewFromStream(stream.release()));
 
     SkColorType colorTypesOpaque[] = {
             kRGB_565_SkColorType, kRGBA_8888_SkColorType, kBGRA_8888_SkColorType
@@ -1173,8 +1173,8 @@ DEF_TEST(Codec_PngRoundTrip, r) {
 static void test_conversion_possible(skiatest::Reporter* r, const char* path,
                                      bool supportsScanlineDecoder,
                                      bool supportsIncrementalDecoder) {
-    SkAutoTDelete<SkStream> stream(GetResourceAsStream(path));
-    SkAutoTDelete<SkCodec> codec(SkCodec::NewFromStream(stream.release()));
+    std::unique_ptr<SkStream> stream(GetResourceAsStream(path));
+    std::unique_ptr<SkCodec> codec(SkCodec::NewFromStream(stream.release()));
     SkImageInfo infoF16 = codec->getInfo().makeColorType(kRGBA_F16_SkColorType);
 
     SkBitmap bm;
@@ -1314,9 +1314,9 @@ public:
     }
 
 private:
-    SkAutoTDelete<SkStream> fStream;
-    const size_t            fLimit;
-    size_t                  fPosition;
+    std::unique_ptr<SkStream> fStream;
+    const size_t              fLimit;
+    size_t                    fPosition;
 
     LimitedRewindingStream(SkStream* stream, size_t limit)
         : fStream(stream)
@@ -1346,7 +1346,7 @@ DEF_TEST(Codec_fallBack, r) {
             return;
         }
 
-        SkAutoTDelete<SkCodec> codec(SkCodec::NewFromStream(stream));
+        std::unique_ptr<SkCodec> codec(SkCodec::NewFromStream(stream));
         if (!codec) {
             ERRORF(r, "Failed to create codec for %s,", file);
             continue;
diff --git a/tests/ColorSpaceTest.cpp b/tests/ColorSpaceTest.cpp
index ca08563581..e1ff1609b2 100644
--- a/tests/ColorSpaceTest.cpp
+++ b/tests/ColorSpaceTest.cpp
@@ -46,13 +46,13 @@ static void test_space(skiatest::Reporter* r, SkColorSpace* space,
 static void test_path(skiatest::Reporter* r, const char* path,
                       const float red[], const float green[], const float blue[],
                       const SkGammaNamed expectedGamma) {
-    SkAutoTDelete<SkStream> stream(GetResourceAsStream(path));
+    std::unique_ptr<SkStream> stream(GetResourceAsStream(path));
     REPORTER_ASSERT(r, nullptr != stream);
     if (!stream) {
         return;
     }
 
-    SkAutoTDelete<SkCodec> codec(SkCodec::NewFromStream(stream.release()));
+    std::unique_ptr<SkCodec> codec(SkCodec::NewFromStream(stream.release()));
     REPORTER_ASSERT(r, nullptr != codec);
     if (!codec) {
         return;
diff --git a/tests/DataRefTest.cpp b/tests/DataRefTest.cpp
index 391124e840..72bad6f948 100644
--- a/tests/DataRefTest.cpp
+++ b/tests/DataRefTest.cpp
@@ -365,7 +365,7 @@ DEF_TEST(RWBuffer_noAppend, r) {
         REPORTER_ASSERT(r, !iter.next());
     }
 
-    SkAutoTDelete<SkStream> stream(buffer.newStreamSnapshot());
+    std::unique_ptr<SkStream> stream(buffer.newStreamSnapshot());
     REPORTER_ASSERT(r, stream);
     if (stream) {
         REPORTER_ASSERT(r, stream->hasLength());
diff --git a/tests/DiscardableMemoryPoolTest.cpp b/tests/DiscardableMemoryPoolTest.cpp
index cabd14b6ea..d1ba38a857 100644
--- a/tests/DiscardableMemoryPoolTest.cpp
+++ b/tests/DiscardableMemoryPoolTest.cpp
@@ -14,7 +14,7 @@ DEF_TEST(DiscardableMemoryPool, reporter) {
     pool->setRAMBudget(3);
     REPORTER_ASSERT(reporter, 0 == pool->getRAMUsed());
 
-    SkAutoTDelete<SkDiscardableMemory> dm1(pool->create(100));
+    std::unique_ptr<SkDiscardableMemory> dm1(pool->create(100));
     REPORTER_ASSERT(reporter, dm1->data() != nullptr);
     REPORTER_ASSERT(reporter, 100 == pool->getRAMUsed());
     dm1->unlock();
@@ -22,7 +22,7 @@ DEF_TEST(DiscardableMemoryPool, reporter) {
     REPORTER_ASSERT(reporter, !dm1->lock());
 
 
-    SkAutoTDelete<SkDiscardableMemory> dm2(pool->create(200));
+    std::unique_ptr<SkDiscardableMemory> dm2(pool->create(200));
     REPORTER_ASSERT(reporter, 200 == pool->getRAMUsed());
     pool->setRAMBudget(400);
     dm2->unlock();
diff --git a/tests/EGLImageTest.cpp b/tests/EGLImageTest.cpp
index de305c7443..3d2ee05a8b 100644
--- a/tests/EGLImageTest.cpp
+++ b/tests/EGLImageTest.cpp
@@ -96,7 +96,7 @@ DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(EGLImageTest, reporter, ctxInfo) {
         return;
     }
 
-    SkAutoTDelete<GLTestContext> glCtx1 = glCtx0->createNew();
+    std::unique_ptr<GLTestContext> glCtx1 = glCtx0->makeNew();
     if (!glCtx1) {
         return;
     }
@@ -107,13 +107,13 @@ DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(EGLImageTest, reporter, ctxInfo) {
     externalTexture.fID = 0;
 
     if (!context1) {
-        cleanup(glCtx0, externalTexture.fID, glCtx1, context1, backendTexture1, image);
+        cleanup(glCtx0, externalTexture.fID, glCtx1.get(), context1, backendTexture1, image);
         return;
     }
 
     if (!glCtx1->gl()->hasExtension("EGL_KHR_image") ||
         !glCtx1->gl()->hasExtension("EGL_KHR_gl_texture_2D_image")) {
-        cleanup(glCtx0, externalTexture.fID, glCtx1, context1, backendTexture1, image);
+        cleanup(glCtx0, externalTexture.fID, glCtx1.get(), context1, backendTexture1, image);
         return;
     }
 
@@ -127,12 +127,12 @@ DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(EGLImageTest, reporter, ctxInfo) {
         gpu1->createTestingOnlyBackendTexture(nullptr, kSize, kSize, kRGBA_8888_GrPixelConfig));
     if (!backendTexture1 || !backendTexture1->fID) {
         ERRORF(reporter, "Error creating texture for EGL Image");
-        cleanup(glCtx0, externalTexture.fID, glCtx1, context1, backendTexture1, image);
+        cleanup(glCtx0, externalTexture.fID, glCtx1.get(), context1, backendTexture1, image);
         return;
     }
     if (GR_GL_TEXTURE_2D != backendTexture1->fTarget) {
         ERRORF(reporter, "Expected backend texture to be 2D");
-        cleanup(glCtx0, externalTexture.fID, glCtx1, context1, backendTexture1, image);
+        cleanup(glCtx0, externalTexture.fID, glCtx1.get(), context1, backendTexture1, image);
         return;
     }
 
@@ -140,7 +140,7 @@ DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(EGLImageTest, reporter, ctxInfo) {
     image = glCtx1->texture2DToEGLImage(backendTexture1->fID);
     if (GR_EGL_NO_IMAGE == image) {
         ERRORF(reporter, "Error creating EGL Image from texture");
-        cleanup(glCtx0, externalTexture.fID, glCtx1, context1, backendTexture1, image);
+        cleanup(glCtx0, externalTexture.fID, glCtx1.get(), context1, backendTexture1, image);
         return;
     }
 
@@ -177,7 +177,7 @@ DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(EGLImageTest, reporter, ctxInfo) {
         context0->textureProvider()->wrapBackendTexture(externalDesc));
     if (!externalTextureObj) {
         ERRORF(reporter, "Error wrapping external texture in GrTexture.");
-        cleanup(glCtx0, externalTexture.fID, glCtx1, context1, backendTexture1, image);
+        cleanup(glCtx0, externalTexture.fID, glCtx1.get(), context1, backendTexture1, image);
         return;
     }
 
@@ -205,7 +205,7 @@ DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(EGLImageTest, reporter, ctxInfo) {
 
     test_copy_surface(reporter, context0, externalTextureObj.get(), pixels.get());
 
-    cleanup(glCtx0, externalTexture.fID, glCtx1, context1, backendTexture1, image);
+    cleanup(glCtx0, externalTexture.fID, glCtx1.get(), context1, backendTexture1, image);
 }
 
 #endif
diff --git a/tests/ExifTest.cpp b/tests/ExifTest.cpp
index 4aac487064..4fed2b0db1 100644
--- a/tests/ExifTest.cpp
+++ b/tests/ExifTest.cpp
@@ -10,13 +10,13 @@
 #include "Test.h"
 
 DEF_TEST(ExifOrientation, r) {
-    SkAutoTDelete<SkStream> stream(GetResourceAsStream("exif-orientation-2-ur.jpg"));
+    std::unique_ptr<SkStream> stream(GetResourceAsStream("exif-orientation-2-ur.jpg"));
     REPORTER_ASSERT(r, nullptr != stream);
     if (!stream) {
         return;
     }
 
-    SkAutoTDelete<SkCodec> codec(SkCodec::NewFromStream(stream.release()));
+    std::unique_ptr<SkCodec> codec(SkCodec::NewFromStream(stream.release()));
     REPORTER_ASSERT(r, nullptr != codec);
     SkCodec::Origin origin = codec->getOrigin();
     REPORTER_ASSERT(r, SkCodec::kTopRight_Origin == origin);
diff --git a/tests/FontHostStreamTest.cpp b/tests/FontHostStreamTest.cpp
index 66908bcb72..efb1453487 100644
--- a/tests/FontHostStreamTest.cpp
+++ b/tests/FontHostStreamTest.cpp
@@ -90,7 +90,7 @@ DEF_TEST(FontHostStream, reporter) {
         sk_sp<SkTypeface> typeface(SkToBool(paint.getTypeface()) ? sk_ref_sp(paint.getTypeface())
                                                                  : SkTypeface::MakeDefault());
         int ttcIndex;
-        SkAutoTDelete<SkStreamAsset> fontData(typeface->openStream(&ttcIndex));
+        std::unique_ptr<SkStreamAsset> fontData(typeface->openStream(&ttcIndex));
         sk_sp<SkTypeface> streamTypeface(SkTypeface::MakeFromStream(fontData.release()));
 
         SkFontDescriptor desc;
diff --git a/tests/FontHostTest.cpp b/tests/FontHostTest.cpp
index 811b4b3926..55c524424f 100644
--- a/tests/FontHostTest.cpp
+++ b/tests/FontHostTest.cpp
@@ -138,18 +138,18 @@ static void test_fontstream(skiatest::Reporter* reporter, SkStream* stream, int
 }
 
 static void test_fontstream(skiatest::Reporter* reporter) {
-    SkAutoTDelete<SkStreamAsset> stream(GetResourceAsStream("/fonts/test.ttc"));
+    std::unique_ptr<SkStreamAsset> stream(GetResourceAsStream("/fonts/test.ttc"));
     if (!stream) {
         SkDebugf("Skipping FontHostTest::test_fontstream\n");
         return;
     }
 
-    int count = SkFontStream::CountTTCEntries(stream);
+    int count = SkFontStream::CountTTCEntries(stream.get());
 #ifdef DUMP_TTC_TABLES
     SkDebugf("CountTTCEntries %d\n", count);
 #endif
     for (int i = 0; i < count; ++i) {
-        test_fontstream(reporter, stream, i);
+        test_fontstream(reporter, stream.get(), i);
     }
 }
 
diff --git a/tests/FrontBufferedStreamTest.cpp b/tests/FrontBufferedStreamTest.cpp
index 445f0bf4c9..a3862741e3 100644
--- a/tests/FrontBufferedStreamTest.cpp
+++ b/tests/FrontBufferedStreamTest.cpp
@@ -56,70 +56,70 @@ static void test_incremental_buffering(skiatest::Reporter* reporter, size_t buff
     // deleted yet (and we only call const methods in it).
     SkMemoryStream* memStream = new SkMemoryStream(gAbcs, strlen(gAbcs), false);
 
-    SkAutoTDelete<SkStream> bufferedStream(SkFrontBufferedStream::Create(memStream, bufferSize));
-    test_hasLength(reporter, *bufferedStream.get(), *memStream);
+    std::unique_ptr<SkStream> bufferedStream(SkFrontBufferedStream::Create(memStream, bufferSize));
+    test_hasLength(reporter, *bufferedStream, *memStream);
 
     // First, test reading less than the max buffer size.
-    test_read(reporter, bufferedStream, gAbcs, bufferSize / 2);
+    test_read(reporter, bufferedStream.get(), gAbcs, bufferSize / 2);
 
     // Now test rewinding back to the beginning and reading less than what was
     // already buffered.
-    test_rewind(reporter, bufferedStream, true);
-    test_read(reporter, bufferedStream, gAbcs, bufferSize / 4);
+    test_rewind(reporter, bufferedStream.get(), true);
+    test_read(reporter, bufferedStream.get(), gAbcs, bufferSize / 4);
 
     // Now test reading part of what was buffered, and buffering new data.
-    test_read(reporter, bufferedStream, gAbcs + bufferSize / 4, bufferSize / 2);
+    test_read(reporter, bufferedStream.get(), gAbcs + bufferSize / 4, bufferSize / 2);
 
     // Now test reading what was buffered, buffering new data, and
     // reading directly from the stream.
-    test_rewind(reporter, bufferedStream, true);
-    test_read(reporter, bufferedStream, gAbcs, bufferSize << 1);
+    test_rewind(reporter, bufferedStream.get(), true);
+    test_read(reporter, bufferedStream.get(), gAbcs, bufferSize << 1);
 
     // We have reached the end of the buffer, so rewinding will fail.
     // This test assumes that the stream is larger than the buffer; otherwise the
     // result of rewind should be true.
-    test_rewind(reporter, bufferedStream, false);
+    test_rewind(reporter, bufferedStream.get(), false);
 }
 
 static void test_perfectly_sized_buffer(skiatest::Reporter* reporter, size_t bufferSize) {
     SkMemoryStream* memStream = new SkMemoryStream(gAbcs, strlen(gAbcs), false);
-    SkAutoTDelete<SkStream> bufferedStream(SkFrontBufferedStream::Create(memStream, bufferSize));
-    test_hasLength(reporter, *bufferedStream.get(), *memStream);
+    std::unique_ptr<SkStream> bufferedStream(SkFrontBufferedStream::Create(memStream, bufferSize));
+    test_hasLength(reporter, *bufferedStream, *memStream);
 
     // Read exactly the amount that fits in the buffer.
-    test_read(reporter, bufferedStream, gAbcs, bufferSize);
+    test_read(reporter, bufferedStream.get(), gAbcs, bufferSize);
 
     // Rewinding should succeed.
-    test_rewind(reporter, bufferedStream, true);
+    test_rewind(reporter, bufferedStream.get(), true);
 
     // Once again reading buffered info should succeed
-    test_read(reporter, bufferedStream, gAbcs, bufferSize);
+    test_read(reporter, bufferedStream.get(), gAbcs, bufferSize);
 
     // Read past the size of the buffer. At this point, we cannot return.
-    test_read(reporter, bufferedStream, gAbcs + memStream->getPosition(), 1);
-    test_rewind(reporter, bufferedStream, false);
+    test_read(reporter, bufferedStream.get(), gAbcs + memStream->getPosition(), 1);
+    test_rewind(reporter, bufferedStream.get(), false);
 }
 
 static void test_skipping(skiatest::Reporter* reporter, size_t bufferSize) {
     SkMemoryStream* memStream = new SkMemoryStream(gAbcs, strlen(gAbcs), false);
-    SkAutoTDelete<SkStream> bufferedStream(SkFrontBufferedStream::Create(memStream, bufferSize));
-    test_hasLength(reporter, *bufferedStream.get(), *memStream);
+    std::unique_ptr<SkStream> bufferedStream(SkFrontBufferedStream::Create(memStream, bufferSize));
+    test_hasLength(reporter, *bufferedStream, *memStream);
 
     // Skip half the buffer.
     bufferedStream->skip(bufferSize / 2);
 
     // Rewind, then read part of the buffer, which should have been read.
-    test_rewind(reporter, bufferedStream, true);
-    test_read(reporter, bufferedStream, gAbcs, bufferSize / 4);
+    test_rewind(reporter, bufferedStream.get(), true);
+    test_read(reporter, bufferedStream.get(), gAbcs, bufferSize / 4);
 
     // Now skip beyond the buffered piece, but still within the total buffer.
     bufferedStream->skip(bufferSize / 2);
 
     // Test that reading will still work.
-    test_read(reporter, bufferedStream, gAbcs + memStream->getPosition(), bufferSize / 4);
+    test_read(reporter, bufferedStream.get(), gAbcs + memStream->getPosition(), bufferSize / 4);
 
-    test_rewind(reporter, bufferedStream, true);
-    test_read(reporter, bufferedStream, gAbcs, bufferSize);
+    test_rewind(reporter, bufferedStream.get(), true);
+    test_read(reporter, bufferedStream.get(), gAbcs, bufferSize);
 }
 
 // A custom class whose isAtEnd behaves the way Android's stream does - since it is an adaptor to a
@@ -156,7 +156,7 @@ static void test_read_beyond_buffer(skiatest::Reporter* reporter, size_t bufferS
             new AndroidLikeMemoryStream((void*)gAbcs, bufferSize, false);
 
     // Create a buffer that matches the length of the stream.
-    SkAutoTDelete<SkStream> bufferedStream(SkFrontBufferedStream::Create(memStream, bufferSize));
+    std::unique_ptr<SkStream> bufferedStream(SkFrontBufferedStream::Create(memStream, bufferSize));
     test_hasLength(reporter, *bufferedStream.get(), *memStream);
 
     // Attempt to read one more than the bufferSize
@@ -164,7 +164,7 @@ static void test_read_beyond_buffer(skiatest::Reporter* reporter, size_t bufferS
     test_rewind(reporter, bufferedStream.get(), true);
 
     // Ensure that the initial read did not invalidate the buffer.
-    test_read(reporter, bufferedStream, gAbcs, bufferSize);
+    test_read(reporter, bufferedStream.get(), gAbcs, bufferSize);
 }
 
 // Dummy stream that optionally has a length and/or position. Tests that FrontBufferedStream's
@@ -203,7 +203,7 @@ static void test_length_combos(skiatest::Reporter* reporter, size_t bufferSize)
         for (int hasPos = 0; hasPos <= 1; hasPos++) {
             LengthOptionalStream* stream =
                     new LengthOptionalStream(SkToBool(hasLen), SkToBool(hasPos));
-            SkAutoTDelete<SkStream> buffered(SkFrontBufferedStream::Create(stream, bufferSize));
+            std::unique_ptr<SkStream> buffered(SkFrontBufferedStream::Create(stream, bufferSize));
             test_hasLength(reporter, *buffered.get(), *stream);
         }
     }
@@ -217,7 +217,7 @@ static void test_initial_offset(skiatest::Reporter* reporter, size_t bufferSize)
     // the stream it wraps.
     const size_t arbitraryOffset = 17;
     memStream->skip(arbitraryOffset);
-    SkAutoTDelete<SkStream> bufferedStream(SkFrontBufferedStream::Create(memStream, bufferSize));
+    std::unique_ptr<SkStream> bufferedStream(SkFrontBufferedStream::Create(memStream, bufferSize));
 
     // Since SkMemoryStream has a length, bufferedStream must also.
     REPORTER_ASSERT(reporter, bufferedStream->hasLength());
@@ -231,7 +231,7 @@ static void test_initial_offset(skiatest::Reporter* reporter, size_t bufferSize)
     // Importantly, the end should not have been reached until currentPosition == bufferedLength.
     while (currentPosition < bufferedLength) {
         REPORTER_ASSERT(reporter, !bufferedStream->isAtEnd());
-        test_read(reporter, bufferedStream, gAbcs + arbitraryOffset + currentPosition,
+        test_read(reporter, bufferedStream.get(), gAbcs + arbitraryOffset + currentPosition,
                   amountToRead);
         currentPosition = SkTMin(currentPosition + amountToRead, bufferedLength);
         REPORTER_ASSERT(reporter, memStream->getPosition() - arbitraryOffset == currentPosition);
@@ -281,9 +281,9 @@ private:
 
 DEF_TEST(ShortFrontBufferedStream, reporter) {
     FailingStream* failingStream = new FailingStream;
-    SkAutoTDelete<SkStreamRewindable> stream(SkFrontBufferedStream::Create(failingStream, 64));
+    std::unique_ptr<SkStreamRewindable> stream(SkFrontBufferedStream::Create(failingStream, 64));
 
     // This will fail to create a codec.  However, what we really want to test is that we
     // won't read past the end of the stream.
-    SkAutoTDelete<SkCodec> codec(SkCodec::NewFromStream(stream.release()));
+    std::unique_ptr<SkCodec> codec(SkCodec::NewFromStream(stream.release()));
 }
diff --git a/tests/GifTest.cpp b/tests/GifTest.cpp
index 51cd85d138..4e8fa2bce5 100644
--- a/tests/GifTest.cpp
+++ b/tests/GifTest.cpp
@@ -191,14 +191,14 @@ DEF_TEST(Gif, reporter) {
 // Regression test for decoding a gif image with sampleSize of 4, which was
 // previously crashing.
 DEF_TEST(Gif_Sampled, r) {
-    SkAutoTDelete<SkFILEStream> stream(
+    std::unique_ptr<SkFILEStream> stream(
             new SkFILEStream(GetResourcePath("test640x479.gif").c_str()));
     REPORTER_ASSERT(r, stream->isValid());
     if (!stream->isValid()) {
         return;
     }
 
-    SkAutoTDelete<SkAndroidCodec> codec(SkAndroidCodec::NewFromStream(stream.release()));
+    std::unique_ptr<SkAndroidCodec> codec(SkAndroidCodec::NewFromStream(stream.release()));
     REPORTER_ASSERT(r, codec);
     if (!codec) {
         return;
diff --git a/tests/GpuSampleLocationsTest.cpp b/tests/GpuSampleLocationsTest.cpp
index 2a57ccbdcc..275951b932 100644
--- a/tests/GpuSampleLocationsTest.cpp
+++ b/tests/GpuSampleLocationsTest.cpp
@@ -199,7 +199,7 @@ public:
     }
 
 private:
-    SkAutoTDelete<sk_gpu_test::GLTestContext>   fTestContext;
+    std::unique_ptr<sk_gpu_test::GLTestContext> fTestContext;
     SamplePattern                               fSamplePattern;
 };
 
diff --git a/tests/GrMemoryPoolTest.cpp b/tests/GrMemoryPoolTest.cpp
index 4a0a4c6eca..863574a35f 100644
--- a/tests/GrMemoryPoolTest.cpp
+++ b/tests/GrMemoryPoolTest.cpp
@@ -55,11 +55,11 @@ public:
     }
 
 private:
-    static SkAutoTDelete<GrMemoryPool> gPool;
+    static std::unique_ptr<GrMemoryPool> gPool;
     char fChar;
 };
 
-SkAutoTDelete<GrMemoryPool> A::gPool;
+std::unique_ptr<GrMemoryPool> A::gPool;
 
 class B : public A {
 public:
diff --git a/tests/ImageTest.cpp b/tests/ImageTest.cpp
index 58576251fe..f348ac4fcd 100644
--- a/tests/ImageTest.cpp
+++ b/tests/ImageTest.cpp
@@ -295,8 +295,8 @@ DEF_TEST(Image_Serialize_Encoding_Failure, reporter) {
         picture->serialize(&wstream, serializers[i]);
         REPORTER_ASSERT(reporter, serializers[i]->didEncode());
 
-        SkAutoTDelete<SkStream> rstream(wstream.detachAsStream());
-        sk_sp<SkPicture> deserialized(SkPicture::MakeFromStream(rstream));
+        std::unique_ptr<SkStream> rstream(wstream.detachAsStream());
+        sk_sp<SkPicture> deserialized(SkPicture::MakeFromStream(rstream.get()));
         REPORTER_ASSERT(reporter, deserialized);
         REPORTER_ASSERT(reporter, deserialized->approximateOpCount() > 0);
     }
diff --git a/tests/Matrix44Test.cpp b/tests/Matrix44Test.cpp
index 75086b68ae..382cd2175f 100644
--- a/tests/Matrix44Test.cpp
+++ b/tests/Matrix44Test.cpp
@@ -78,7 +78,7 @@ static bool bits_isonly(int value, int mask) {
 static void test_constructor(skiatest::Reporter* reporter) {
     // Allocate a matrix on the heap
     SkMatrix44* placeholderMatrix = new SkMatrix44(SkMatrix44::kUninitialized_Constructor);
-    SkAutoTDelete<SkMatrix44> deleteMe(placeholderMatrix);
+    std::unique_ptr<SkMatrix44> deleteMe(placeholderMatrix);
 
     for (int row = 0; row < 4; ++row) {
         for (int col = 0; col < 4; ++col) {
diff --git a/tests/PDFDeflateWStreamTest.cpp b/tests/PDFDeflateWStreamTest.cpp
index eedcaaf0c5..11d237059a 100644
--- a/tests/PDFDeflateWStreamTest.cpp
+++ b/tests/PDFDeflateWStreamTest.cpp
@@ -125,9 +125,8 @@ DEF_TEST(SkPDF_DeflateWStream, r) {
             }
             REPORTER_ASSERT(r, deflateWStream.bytesWritten() == size);
         }
-        SkAutoTDelete<SkStreamAsset> compressed(
-                dynamicMemoryWStream.detachAsStream());
-        SkAutoTDelete<SkStreamAsset> decompressed(stream_inflate(r, compressed));
+        std::unique_ptr<SkStreamAsset> compressed(dynamicMemoryWStream.detachAsStream());
+        std::unique_ptr<SkStreamAsset> decompressed(stream_inflate(r, compressed.get()));
 
         if (!decompressed) {
             ERRORF(r, "Decompression failed.");
diff --git a/tests/PathOpsSkpClipTest.cpp b/tests/PathOpsSkpClipTest.cpp
index e16be4c8f3..3cbe7efdba 100644
--- a/tests/PathOpsSkpClipTest.cpp
+++ b/tests/PathOpsSkpClipTest.cpp
@@ -1074,7 +1074,7 @@ int tool_main(int argc, char** argv) {
     Iter iter;
     Test* test;
     while ((test = iter.next()) != nullptr) {
-        SkAutoTDelete<Test> owned(test);
+        std::unique_ptr<Test> owned(test);
         if (!SkCommandLineFlags::ShouldSkip(FLAGS_match, test->getName())) {
             test->run();
         }
diff --git a/tests/PictureTest.cpp b/tests/PictureTest.cpp
index 8c7312ef07..8fdf92a8e8 100644
--- a/tests/PictureTest.cpp
+++ b/tests/PictureTest.cpp
@@ -1087,8 +1087,8 @@ DEF_TEST(Picture_preserveCullRect, r) {
     SkDynamicMemoryWStream wstream;
     picture->serialize(&wstream);
 
-    SkAutoTDelete<SkStream> rstream(wstream.detachAsStream());
-    sk_sp<SkPicture> deserializedPicture(SkPicture::MakeFromStream(rstream));
+    std::unique_ptr<SkStream> rstream(wstream.detachAsStream());
+    sk_sp<SkPicture> deserializedPicture(SkPicture::MakeFromStream(rstream.get()));
 
     REPORTER_ASSERT(r, deserializedPicture != nullptr);
     REPORTER_ASSERT(r, deserializedPicture->cullRect().left() == 1);
diff --git a/tests/SerializationTest.cpp b/tests/SerializationTest.cpp
index 82db03ef1b..0e5e8ec4fa 100644
--- a/tests/SerializationTest.cpp
+++ b/tests/SerializationTest.cpp
@@ -357,7 +357,7 @@ static void serialize_and_compare_typeface(sk_sp<SkTypeface> typeface, const cha
     // Serlialize picture and create its clone from stream.
     SkDynamicMemoryWStream stream;
     picture->serialize(&stream);
-    SkAutoTDelete<SkStream> inputStream(stream.detachAsStream());
+    std::unique_ptr<SkStream> inputStream(stream.detachAsStream());
     sk_sp<SkPicture> loadedPicture(SkPicture::MakeFromStream(inputStream.get()));
 
     // Draw both original and clone picture and compare bitmaps -- they should be identical.
@@ -648,8 +648,8 @@ DEF_TEST(Serialization, reporter) {
 static sk_sp<SkPicture> copy_picture_via_serialization(SkPicture* src) {
     SkDynamicMemoryWStream wstream;
     src->serialize(&wstream);
-    SkAutoTDelete<SkStreamAsset> rstream(wstream.detachAsStream());
-    return SkPicture::MakeFromStream(rstream);
+    std::unique_ptr<SkStreamAsset> rstream(wstream.detachAsStream());
+    return SkPicture::MakeFromStream(rstream.get());
 }
 
 struct AnnotationRec {
diff --git a/tests/SkResourceCacheTest.cpp b/tests/SkResourceCacheTest.cpp
index f363fb7a44..615c7b4cd7 100644
--- a/tests/SkResourceCacheTest.cpp
+++ b/tests/SkResourceCacheTest.cpp
@@ -38,7 +38,7 @@ DEF_TEST(BitmapCache_add_rect, reporter) {
     SkResourceCache::DiscardableFactory factory = SkResourceCache::GetDiscardableFactory();
     SkBitmap::Allocator* allocator = SkBitmapCache::GetAllocator();
 
-    SkAutoTDelete<SkResourceCache> cache;
+    std::unique_ptr<SkResourceCache> cache;
     if (factory) {
         cache.reset(new SkResourceCache(factory));
     } else {
@@ -55,18 +55,18 @@ DEF_TEST(BitmapCache_add_rect, reporter) {
     SkPixelRef* cachedPR = cachedBitmap.pixelRef();
 
     // Wrong subset size
-    REPORTER_ASSERT(reporter, !SkBitmapCache::Add(cachedPR, SkIRect::MakeWH(4, 6), cachedBitmap, cache));
-    REPORTER_ASSERT(reporter, !SkBitmapCache::Find(cachedID, rect, &bm, cache));
+    REPORTER_ASSERT(reporter, !SkBitmapCache::Add(cachedPR, SkIRect::MakeWH(4, 6), cachedBitmap, cache.get()));
+    REPORTER_ASSERT(reporter, !SkBitmapCache::Find(cachedID, rect, &bm, cache.get()));
     // Wrong offset value
-    REPORTER_ASSERT(reporter, !SkBitmapCache::Add(cachedPR, SkIRect::MakeXYWH(-1, 0, 5, 5), cachedBitmap, cache));
-    REPORTER_ASSERT(reporter, !SkBitmapCache::Find(cachedID, rect, &bm, cache));
+    REPORTER_ASSERT(reporter, !SkBitmapCache::Add(cachedPR, SkIRect::MakeXYWH(-1, 0, 5, 5), cachedBitmap, cache.get()));
+    REPORTER_ASSERT(reporter, !SkBitmapCache::Find(cachedID, rect, &bm, cache.get()));
 
     // Should not be in the cache
-    REPORTER_ASSERT(reporter, !SkBitmapCache::Find(cachedID, rect, &bm, cache));
+    REPORTER_ASSERT(reporter, !SkBitmapCache::Find(cachedID, rect, &bm, cache.get()));
 
-    REPORTER_ASSERT(reporter, SkBitmapCache::Add(cachedPR, rect, cachedBitmap, cache));
+    REPORTER_ASSERT(reporter, SkBitmapCache::Add(cachedPR, rect, cachedBitmap, cache.get()));
     // Should be in the cache, we just added it
-    REPORTER_ASSERT(reporter, SkBitmapCache::Find(cachedID, rect, &bm, cache));
+    REPORTER_ASSERT(reporter, SkBitmapCache::Find(cachedID, rect, &bm, cache.get()));
 }
 
 #include "SkMipMap.h"
diff --git a/tests/StreamTest.cpp b/tests/StreamTest.cpp
index 74e60557d1..ca750d1566 100644
--- a/tests/StreamTest.cpp
+++ b/tests/StreamTest.cpp
@@ -61,7 +61,7 @@ static void test_filestreams(skiatest::Reporter* reporter, const char* tmpDir) {
         REPORTER_ASSERT(reporter, stream.isValid());
         test_loop_stream(reporter, &stream, s, 26, 100);
 
-        SkAutoTDelete<SkStreamAsset> stream2(stream.duplicate());
+        std::unique_ptr<SkStreamAsset> stream2(stream.duplicate());
         test_loop_stream(reporter, stream2.get(), s, 26, 100);
     }
 
@@ -71,7 +71,7 @@ static void test_filestreams(skiatest::Reporter* reporter, const char* tmpDir) {
         REPORTER_ASSERT(reporter, stream.isValid());
         test_loop_stream(reporter, &stream, s, 26, 100);
 
-        SkAutoTDelete<SkStreamAsset> stream2(stream.duplicate());
+        std::unique_ptr<SkStreamAsset> stream2(stream.duplicate());
         test_loop_stream(reporter, stream2.get(), s, 26, 100);
     }
 }
@@ -94,15 +94,15 @@ static void TestWStream(skiatest::Reporter* reporter) {
     }
 
     {
-        SkAutoTDelete<SkStreamAsset> stream(ds.detachAsStream());
+        std::unique_ptr<SkStreamAsset> stream(ds.detachAsStream());
         REPORTER_ASSERT(reporter, 100 * 26 == stream->getLength());
         REPORTER_ASSERT(reporter, ds.getOffset() == 0);
         test_loop_stream(reporter, stream.get(), s, 26, 100);
 
-        SkAutoTDelete<SkStreamAsset> stream2(stream->duplicate());
+        std::unique_ptr<SkStreamAsset> stream2(stream->duplicate());
         test_loop_stream(reporter, stream2.get(), s, 26, 100);
 
-        SkAutoTDelete<SkStreamAsset> stream3(stream->fork());
+        std::unique_ptr<SkStreamAsset> stream3(stream->fork());
         REPORTER_ASSERT(reporter, stream3->isAtEnd());
         char tmp;
         size_t bytes = stream->read(&tmp, 1);
@@ -124,11 +124,11 @@ static void TestWStream(skiatest::Reporter* reporter) {
 
     {
         // Test that this works after a snapshot.
-        SkAutoTDelete<SkStreamAsset> stream(ds.detachAsStream());
+        std::unique_ptr<SkStreamAsset> stream(ds.detachAsStream());
         REPORTER_ASSERT(reporter, ds.getOffset() == 0);
         test_loop_stream(reporter, stream.get(), s, 26, 100);
 
-        SkAutoTDelete<SkStreamAsset> stream2(stream->duplicate());
+        std::unique_ptr<SkStreamAsset> stream2(stream->duplicate());
         test_loop_stream(reporter, stream2.get(), s, 26, 100);
     }
     delete[] dst;
@@ -234,12 +234,12 @@ static void test_peeking_front_buffered_stream(skiatest::Reporter* r,
                                                size_t bufferSize) {
     SkStream* dupe = original.duplicate();
     REPORTER_ASSERT(r, dupe != nullptr);
-    SkAutoTDelete<SkStream> bufferedStream(SkFrontBufferedStream::Create(dupe, bufferSize));
+    std::unique_ptr<SkStream> bufferedStream(SkFrontBufferedStream::Create(dupe, bufferSize));
     REPORTER_ASSERT(r, bufferedStream != nullptr);
 
     size_t peeked = 0;
     for (size_t i = 1; !bufferedStream->isAtEnd(); i++) {
-        const size_t unpeekableBytes = compare_peek_to_read(r, bufferedStream, i);
+        const size_t unpeekableBytes = compare_peek_to_read(r, bufferedStream.get(), i);
         if (unpeekableBytes > 0) {
             // This could not have returned a number greater than i.
             REPORTER_ASSERT(r, unpeekableBytes <= i);
@@ -359,7 +359,7 @@ DEF_TEST(StreamPeek_BlockMemoryStream, rep) {
         }
         dynamicMemoryWStream.write(buffer, size);
     }
-    SkAutoTDelete<SkStreamAsset> asset(dynamicMemoryWStream.detachAsStream());
+    std::unique_ptr<SkStreamAsset> asset(dynamicMemoryWStream.detachAsStream());
     sk_sp<SkData> expected(SkData::MakeUninitialized(asset->getLength()));
     uint8_t* expectedPtr = static_cast<uint8_t*>(expected->writable_data());
     valueSource.setSeed(kSeed);  // reseed.
@@ -369,7 +369,7 @@ DEF_TEST(StreamPeek_BlockMemoryStream, rep) {
     for (size_t i = 0; i < asset->getLength(); ++i) {
         expectedPtr[i] = valueSource.nextU() & 0xFF;
     }
-    stream_peek_test(rep, asset, expected.get());
+    stream_peek_test(rep, asset.get(), expected.get());
 }
 
 namespace {
@@ -429,6 +429,6 @@ DEF_TEST(StreamCopy, reporter) {
 
 DEF_TEST(StreamEmptyStreamMemoryBase, r) {
     SkDynamicMemoryWStream tmp;
-    SkAutoTDelete<SkStreamAsset> asset(tmp.detachAsStream());
+    std::unique_ptr<SkStreamAsset> asset(tmp.detachAsStream());
     REPORTER_ASSERT(r, nullptr == asset->getMemoryBase());
 }
diff --git a/tests/YUVTest.cpp b/tests/YUVTest.cpp
index d3b9167843..913997b3c3 100644
--- a/tests/YUVTest.cpp
+++ b/tests/YUVTest.cpp
@@ -15,11 +15,11 @@
 static void codec_yuv(skiatest::Reporter* reporter,
                   const char path[],
                   SkISize expectedSizes[3]) {
-    SkAutoTDelete<SkStream> stream(GetResourceAsStream(path));
+    std::unique_ptr<SkStream> stream(GetResourceAsStream(path));
     if (!stream) {
         return;
     }
-    SkAutoTDelete<SkCodec> codec(SkCodec::NewFromStream(stream.release()));
+    std::unique_ptr<SkCodec> codec(SkCodec::NewFromStream(stream.release()));
     REPORTER_ASSERT(reporter, codec);
     if (!codec) {
         return;