Make sp variants for SkData

Review URL: https://codereview.chromium.org/1779263003

25 files changed, 107 insertions, 116 deletions

diff --git a/src/c/sk_surface.cpp b/src/c/sk_surface.cpp
index 6bd62a9aa9..8dd7a6c503 100644
--- a/src/c/sk_surface.cpp
+++ b/src/c/sk_surface.cpp
@@ -677,15 +677,15 @@ sk_maskfilter_t* sk_maskfilter_new_blur(sk_blurstyle_t cstyle, float sigma) {
 ///////////////////////////////////////////////////////////////////////////////////////////
 
 sk_data_t* sk_data_new_with_copy(const void* src, size_t length) {
-    return ToData(SkData::NewWithCopy(src, length));
+    return ToData(SkData::MakeWithCopy(src, length).release());
 }
 
 sk_data_t* sk_data_new_from_malloc(const void* memory, size_t length) {
-    return ToData(SkData::NewFromMalloc(memory, length));
+    return ToData(SkData::MakeFromMalloc(memory, length).release());
 }
 
 sk_data_t* sk_data_new_subset(const sk_data_t* csrc, size_t offset, size_t length) {
-    return ToData(SkData::NewSubset(AsData(csrc), offset, length));
+    return ToData(SkData::MakeSubset(AsData(csrc), offset, length).release());
 }
 
 void sk_data_ref(const sk_data_t* cdata) {
diff --git a/src/core/SkBitmap.cpp b/src/core/SkBitmap.cpp
index fdb66b378b..7e8e62e88b 100644
--- a/src/core/SkBitmap.cpp
+++ b/src/core/SkBitmap.cpp
@@ -1163,7 +1163,7 @@ bool SkBitmap::ReadRawPixels(SkReadBuffer* buffer, SkBitmap* bitmap) {
         return false;
     }
 
-    SkAutoDataUnref data(SkData::NewUninitialized(SkToSizeT(ramSize)));
+    sk_sp<SkData> data(SkData::MakeUninitialized(SkToSizeT(ramSize)));
     unsigned char* dst = (unsigned char*)data->writable_data();
     buffer->readByteArray(dst, SkToSizeT(snugSize));
 
diff --git a/src/core/SkData.cpp b/src/core/SkData.cpp
index 5bf833e1f3..4b2194973b 100644
--- a/src/core/SkData.cpp
+++ b/src/core/SkData.cpp
@@ -59,9 +59,9 @@ size_t SkData::copyRange(size_t offset, size_t length, void* buffer) const {
     return length;
 }
 
-SkData* SkData::PrivateNewWithCopy(const void* srcOrNull, size_t length) {
+sk_sp<SkData> SkData::PrivateNewWithCopy(const void* srcOrNull, size_t length) {
     if (0 == length) {
-        return SkData::NewEmpty();
+        return SkData::MakeEmpty();
     }
 
     const size_t actualLength = length + sizeof(SkData);
@@ -75,14 +75,15 @@ SkData* SkData::PrivateNewWithCopy(const void* srcOrNull, size_t length) {
     if (srcOrNull) {
         memcpy(data->writable_data(), srcOrNull, length);
     }
-    return data;
+    return sk_sp<SkData>(data);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SK_DECLARE_STATIC_ONCE_PTR(SkData, gEmpty);
-SkData* SkData::NewEmpty() {
-    return SkRef(gEmpty.get([]{return new SkData(nullptr, 0, nullptr, nullptr); }));
+sk_sp<SkData> SkData::MakeEmpty() {
+    SkData* data = SkRef(gEmpty.get([]{return new SkData(nullptr, 0, nullptr, nullptr); }));
+    return sk_sp<SkData>(data);
 }
 
 // assumes fPtr was allocated via sk_malloc
@@ -90,21 +91,21 @@ static void sk_free_releaseproc(const void* ptr, void*) {
     sk_free((void*)ptr);
 }
 
-SkData* SkData::NewFromMalloc(const void* data, size_t length) {
-    return new SkData(data, length, sk_free_releaseproc, nullptr);
+sk_sp<SkData> SkData::MakeFromMalloc(const void* data, size_t length) {
+    return sk_sp<SkData>(new SkData(data, length, sk_free_releaseproc, nullptr));
 }
 
-SkData* SkData::NewWithCopy(const void* src, size_t length) {
+sk_sp<SkData> SkData::MakeWithCopy(const void* src, size_t length) {
     SkASSERT(src);
     return PrivateNewWithCopy(src, length);
 }
 
-SkData* SkData::NewUninitialized(size_t length) {
+sk_sp<SkData> SkData::MakeUninitialized(size_t length) {
     return PrivateNewWithCopy(nullptr, length);
 }
 
-SkData* SkData::NewWithProc(const void* ptr, size_t length, ReleaseProc proc, void* context) {
-    return new SkData(ptr, length, proc, context);
+sk_sp<SkData> SkData::MakeWithProc(const void* ptr, size_t length, ReleaseProc proc, void* ctx) {
+    return sk_sp<SkData>(new SkData(ptr, length, proc, ctx));
 }
 
 // assumes fPtr was allocated with sk_fmmap
@@ -113,34 +114,34 @@ static void sk_mmap_releaseproc(const void* addr, void* ctx) {
     sk_fmunmap(addr, length);
 }
 
-SkData* SkData::NewFromFILE(FILE* f) {
+sk_sp<SkData> SkData::MakeFromFILE(FILE* f) {
     size_t size;
     void* addr = sk_fmmap(f, &size);
     if (nullptr == addr) {
         return nullptr;
     }
 
-    return SkData::NewWithProc(addr, size, sk_mmap_releaseproc, reinterpret_cast<void*>(size));
+    return SkData::MakeWithProc(addr, size, sk_mmap_releaseproc, reinterpret_cast<void*>(size));
 }
 
-SkData* SkData::NewFromFileName(const char path[]) {
+sk_sp<SkData> SkData::MakeFromFileName(const char path[]) {
     FILE* f = path ? sk_fopen(path, kRead_SkFILE_Flag) : nullptr;
     if (nullptr == f) {
         return nullptr;
     }
-    SkData* data = NewFromFILE(f);
+    auto data = MakeFromFILE(f);
     sk_fclose(f);
     return data;
 }
 
-SkData* SkData::NewFromFD(int fd) {
+sk_sp<SkData> SkData::MakeFromFD(int fd) {
     size_t size;
     void* addr = sk_fdmmap(fd, &size);
     if (nullptr == addr) {
         return nullptr;
     }
 
-    return SkData::NewWithProc(addr, size, sk_mmap_releaseproc, nullptr);
+    return SkData::MakeWithProc(addr, size, sk_mmap_releaseproc, nullptr);
 }
 
 // assumes context is a SkData
@@ -149,7 +150,7 @@ static void sk_dataref_releaseproc(const void*, void* context) {
     src->unref();
 }
 
-SkData* SkData::NewSubset(const SkData* src, size_t offset, size_t length) {
+sk_sp<SkData> SkData::MakeSubset(const SkData* src, size_t offset, size_t length) {
     /*
         We could, if we wanted/need to, just make a deep copy of src's data,
         rather than referencing it. This would duplicate the storage (of the
@@ -158,7 +159,7 @@ SkData* SkData::NewSubset(const SkData* src, size_t offset, size_t length) {
 
     size_t available = src->size();
     if (offset >= available || 0 == length) {
-        return SkData::NewEmpty();
+        return SkData::MakeEmpty();
     }
     available -= offset;
     if (length > available) {
@@ -167,11 +168,11 @@ SkData* SkData::NewSubset(const SkData* src, size_t offset, size_t length) {
     SkASSERT(length > 0);
 
     src->ref(); // this will be balanced in sk_dataref_releaseproc
-    return new SkData(src->bytes() + offset, length, sk_dataref_releaseproc,
-                         const_cast<SkData*>(src));
+    return sk_sp<SkData>(new SkData(src->bytes() + offset, length, sk_dataref_releaseproc,
+                                    const_cast<SkData*>(src)));
 }
 
-SkData* SkData::NewWithCString(const char cstr[]) {
+sk_sp<SkData> SkData::MakeWithCString(const char cstr[]) {
     size_t size;
     if (nullptr == cstr) {
         cstr = "";
@@ -179,16 +180,16 @@ SkData* SkData::NewWithCString(const char cstr[]) {
     } else {
         size = strlen(cstr) + 1;
     }
-    return NewWithCopy(cstr, size);
+    return MakeWithCopy(cstr, size);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-SkData* SkData::NewFromStream(SkStream* stream, size_t size) {
-    SkAutoDataUnref data(SkData::NewUninitialized(size));
+sk_sp<SkData> SkData::MakeFromStream(SkStream* stream, size_t size) {
+    sk_sp<SkData> data(SkData::MakeUninitialized(size));
     if (stream->read(data->writable_data(), size) != size) {
         return nullptr;
     }
-    return data.detach();
+    return data;
 }
 
diff --git a/src/core/SkFlattenableSerialization.cpp b/src/core/SkFlattenableSerialization.cpp
index 31602079a3..e9ce09ff1f 100644
--- a/src/core/SkFlattenableSerialization.cpp
+++ b/src/core/SkFlattenableSerialization.cpp
@@ -15,9 +15,9 @@ SkData* SkValidatingSerializeFlattenable(SkFlattenable* flattenable) {
     SkWriteBuffer writer(SkWriteBuffer::kValidation_Flag);
     writer.writeFlattenable(flattenable);
     size_t size = writer.bytesWritten();
-    SkData* data = SkData::NewUninitialized(size);
+    auto data = SkData::MakeUninitialized(size);
     writer.writeToMemory(data->writable_data());
-    return data;
+    return data.release();
 }
 
 SkFlattenable* SkValidatingDeserializeFlattenable(const void* data, size_t size,
diff --git a/src/core/SkFontDescriptor.cpp b/src/core/SkFontDescriptor.cpp
index f477a2d695..69fdc15432 100644
--- a/src/core/SkFontDescriptor.cpp
+++ b/src/core/SkFontDescriptor.cpp
@@ -96,7 +96,7 @@ bool SkFontDescriptor::Deserialize(SkStream* stream, SkFontDescriptor* result) {
 
     size_t length = stream->readPackedUInt();
     if (length > 0) {
-        SkAutoTUnref<SkData> data(SkData::NewUninitialized(length));
+        sk_sp<SkData> data(SkData::MakeUninitialized(length));
         if (stream->read(data->writable_data(), length) == length) {
             result->fFontData.reset(new SkFontData(new SkMemoryStream(data),
                                                    index, axis, axisCount));
diff --git a/src/core/SkPaint.cpp b/src/core/SkPaint.cpp
index 678b1a1102..f7959429a7 100644
--- a/src/core/SkPaint.cpp
+++ b/src/core/SkPaint.cpp
@@ -1943,7 +1943,7 @@ void SkPaint::unflatten(SkReadBuffer& buffer) {
                 // Annotations have moved to drawAnnotation, so we just drop this one on the floor.
                 SkString key;
                 buffer.readString(&key);
-                SkSafeUnref(buffer.readByteArrayAsData());
+                (void)buffer.readByteArrayAsData();
             }
         }
     } else {
diff --git a/src/core/SkPicture.cpp b/src/core/SkPicture.cpp
index 04f2f93ba7..f2b199d317 100644
--- a/src/core/SkPicture.cpp
+++ b/src/core/SkPicture.cpp
@@ -140,9 +140,9 @@ SkPicture* SkPicture::Forwardport(const SkPictInfo& info, const SkPictureData* d
 }
 
 static bool default_install(const void* src, size_t length, SkBitmap* dst) {
-    SkAutoTUnref<SkData> encoded(SkData::NewWithCopy(src, length));
+    sk_sp<SkData> encoded(SkData::MakeWithCopy(src, length));
     return encoded && SkDEPRECATED_InstallDiscardablePixelRef(
-            SkImageGenerator::NewFromEncoded(encoded), dst);
+            SkImageGenerator::NewFromEncoded(encoded.get()), dst);
 }
 
 SkPicture* SkPicture::CreateFromStream(SkStream* stream) {
diff --git a/src/core/SkPictureData.cpp b/src/core/SkPictureData.cpp
index fcc9706565..0ba28b97e3 100644
--- a/src/core/SkPictureData.cpp
+++ b/src/core/SkPictureData.cpp
@@ -93,13 +93,10 @@ void SkPictureData::init() {
     fTextBlobCount = 0;
     fImageRefs = nullptr;
     fImageCount = 0;
-    fOpData = nullptr;
     fFactoryPlayback = nullptr;
 }
 
 SkPictureData::~SkPictureData() {
-    SkSafeUnref(fOpData);
-
     for (int i = 0; i < fPictureCount; i++) {
         fPictureRefs[i]->unref();
     }
@@ -358,7 +355,7 @@ bool SkPictureData::parseStreamTag(SkStream* stream,
     switch (tag) {
         case SK_PICT_READER_TAG:
             SkASSERT(nullptr == fOpData);
-            fOpData = SkData::NewFromStream(stream, size);
+            fOpData = SkData::MakeFromStream(stream, size);
             if (!fOpData) {
                 return false;
             }
@@ -529,13 +526,13 @@ bool SkPictureData::parseBufferTag(SkReadBuffer& buffer, uint32_t tag, uint32_t
             }
             break;
         case SK_PICT_READER_TAG: {
-            SkAutoDataUnref data(SkData::NewUninitialized(size));
+            auto data(SkData::MakeUninitialized(size));
             if (!buffer.readByteArray(data->writable_data(), size) ||
                 !buffer.validate(nullptr == fOpData)) {
                 return false;
             }
             SkASSERT(nullptr == fOpData);
-            fOpData = data.detach();
+            fOpData = std::move(data);
         } break;
         case SK_PICT_PICTURE_TAG:
             if (!new_array_from_buffer(buffer, size, &fPictureRefs, &fPictureCount,
diff --git a/src/core/SkPictureData.h b/src/core/SkPictureData.h
index 4e4deef55a..3acaf579bc 100644
--- a/src/core/SkPictureData.h
+++ b/src/core/SkPictureData.h
@@ -77,7 +77,7 @@ public:
 
     int opCount() const { return fContentInfo.numOperations(); }
 
-    const SkData* opData() const { return fOpData; }
+    const sk_sp<SkData>& opData() const { return fOpData; }
 
 protected:
     explicit SkPictureData(const SkPictInfo& info);
@@ -158,7 +158,7 @@ private:
     SkTArray<SkPaint>  fPaints;
     SkTArray<SkPath>   fPaths;
 
-    SkData* fOpData;    // opcodes and parameters
+    sk_sp<SkData>   fOpData;    // opcodes and parameters
 
     const SkPicture** fPictureRefs;
     int fPictureCount;
diff --git a/src/core/SkPicturePlayback.cpp b/src/core/SkPicturePlayback.cpp
index e8497daca1..ae3c3f20af 100644
--- a/src/core/SkPicturePlayback.cpp
+++ b/src/core/SkPicturePlayback.cpp
@@ -178,8 +178,7 @@ void SkPicturePlayback::handleOp(SkReader32* reader,
         case DRAW_ANNOTATION: {
             const SkRect& rect = reader->skipT<SkRect>();
             const char* key = reader->readString();
-            SkAutoTUnref<SkData> value(reader->readData());
-            canvas->drawAnnotation(rect, key, value);
+            canvas->drawAnnotation(rect, key, reader->readData().get());
         } break;
         case DRAW_ATLAS: {
             const SkPaint* paint = fPictureData->getPaint(reader);
diff --git a/src/core/SkPictureRecord.h b/src/core/SkPictureRecord.h
index 607f6f10f7..089bc81ee5 100644
--- a/src/core/SkPictureRecord.h
+++ b/src/core/SkPictureRecord.h
@@ -43,15 +43,15 @@ public:
         return fImageRefs;
     }
 
-    SkData* opData(bool deepCopy) const {
+    sk_sp<SkData> opData(bool deepCopy) const {
         this->validate(fWriter.bytesWritten(), 0);
 
         if (fWriter.bytesWritten() == 0) {
-            return SkData::NewEmpty();
+            return SkData::MakeEmpty();
         }
 
         if (deepCopy) {
-            return SkData::NewWithCopy(fWriter.contiguousArray(), fWriter.bytesWritten());
+            return SkData::MakeWithCopy(fWriter.contiguousArray(), fWriter.bytesWritten());
         }
 
         return fWriter.snapshotAsData();
diff --git a/src/core/SkPixmap.cpp b/src/core/SkPixmap.cpp
index d7c4cffb7e..f7672d082f 100644
--- a/src/core/SkPixmap.cpp
+++ b/src/core/SkPixmap.cpp
@@ -323,9 +323,9 @@ const SkData* SkAutoPixmapStorage::detachPixelsAsData() {
         return nullptr;
     }
 
-    const SkData* data = SkData::NewFromMalloc(fStorage, this->getSafeSize());
+    auto data = SkData::MakeFromMalloc(fStorage, this->getSafeSize());
     fStorage = nullptr;
     this->INHERITED::reset();
 
-    return data;
+    return data.release();
 }
diff --git a/src/core/SkReadBuffer.h b/src/core/SkReadBuffer.h
index 5db9f4644d..7ce6d048e9 100644
--- a/src/core/SkReadBuffer.h
+++ b/src/core/SkReadBuffer.h
@@ -152,14 +152,14 @@ public:
     virtual bool readPointArray(SkPoint* points, size_t size);
     virtual bool readScalarArray(SkScalar* values, size_t size);
 
-    SkData* readByteArrayAsData() {
+    sk_sp<SkData> readByteArrayAsData() {
         size_t len = this->getArrayCount();
         if (!this->validateAvailable(len)) {
-            return SkData::NewEmpty();
+            return SkData::MakeEmpty();
         }
         void* buffer = sk_malloc_throw(len);
         this->readByteArray(buffer, len);
-        return SkData::NewFromMalloc(buffer, len);
+        return SkData::MakeFromMalloc(buffer, len);
     }
 
     // helpers to get info about arrays and binary data
diff --git a/src/core/SkReader32.h b/src/core/SkReader32.h
index 645d64cc24..7e31fb9e23 100644
--- a/src/core/SkReader32.h
+++ b/src/core/SkReader32.h
@@ -135,12 +135,12 @@ public:
      */
     size_t readIntoString(SkString* copy);
 
-    SkData* readData() {
+    sk_sp<SkData> readData() {
         uint32_t byteLength = this->readU32();
         if (0 == byteLength) {
-            return SkData::NewEmpty();
+            return SkData::MakeEmpty();
         }
-        return SkData::NewWithCopy(this->skip(byteLength), byteLength);
+        return SkData::MakeWithCopy(this->skip(byteLength), byteLength);
     }
 
 private:
diff --git a/src/core/SkStream.cpp b/src/core/SkStream.cpp
index 9529308e86..b6d0a2bb33 100644
--- a/src/core/SkStream.cpp
+++ b/src/core/SkStream.cpp
@@ -245,8 +245,8 @@ SkStreamAsset* SkFILEStream::duplicate() const {
         }
     }
 
-    fData.reset(SkData::NewFromFILE(fFILE));
-    if (nullptr == fData.get()) {
+    fData = SkData::MakeFromFILE(fFILE);
+    if (nullptr == fData) {
         return nullptr;
     }
     return new SkMemoryStream(fData);
@@ -283,21 +283,21 @@ const void* SkFILEStream::getMemoryBase() {
 
 ///////////////////////////////////////////////////////////////////////////////
 
-static SkData* newFromParams(const void* src, size_t size, bool copyData) {
+static sk_sp<SkData> newFromParams(const void* src, size_t size, bool copyData) {
     if (copyData) {
-        return SkData::NewWithCopy(src, size);
+        return SkData::MakeWithCopy(src, size);
     } else {
-        return SkData::NewWithoutCopy(src, size);
+        return SkData::MakeWithoutCopy(src, size);
     }
 }
 
 SkMemoryStream::SkMemoryStream() {
-    fData = SkData::NewEmpty();
+    fData = SkData::MakeEmpty();
     fOffset = 0;
 }
 
 SkMemoryStream::SkMemoryStream(size_t size) {
-    fData = SkData::NewUninitialized(size);
+    fData = SkData::MakeUninitialized(size);
     fOffset = 0;
 }
 
@@ -306,44 +306,41 @@ SkMemoryStream::SkMemoryStream(const void* src, size_t size, bool copyData) {
     fOffset = 0;
 }
 
+SkMemoryStream::SkMemoryStream(sk_sp<SkData> data) : fData(std::move(data)) {
+    if (nullptr == fData) {
+        fData = SkData::MakeEmpty();
+    }
+    fOffset = 0;
+}
+
 SkMemoryStream::SkMemoryStream(SkData* data) {
     if (nullptr == data) {
-        fData = SkData::NewEmpty();
+        fData = SkData::MakeEmpty();
     } else {
-        fData = data;
-        fData->ref();
+        fData = sk_ref_sp(data);
     }
     fOffset = 0;
 }
 
-SkMemoryStream::~SkMemoryStream() {
-    fData->unref();
-}
-
 void SkMemoryStream::setMemoryOwned(const void* src, size_t size) {
-    fData->unref();
-    fData = SkData::NewFromMalloc(src, size);
+    fData = SkData::MakeFromMalloc(src, size);
     fOffset = 0;
 }
 
 void SkMemoryStream::setMemory(const void* src, size_t size, bool copyData) {
-    fData->unref();
     fData = newFromParams(src, size, copyData);
     fOffset = 0;
 }
 
 SkData* SkMemoryStream::copyToData() const {
-    fData->ref();
-    return fData;
+    return SkSafeRef(fData.get());
 }
 
 SkData* SkMemoryStream::setData(SkData* data) {
-    fData->unref();
     if (nullptr == data) {
-        fData = SkData::NewEmpty();
+        fData = SkData::MakeEmpty();
     } else {
-        fData = data;
-        fData->ref();
+        fData = sk_ref_sp(data);
     }
     fOffset = 0;
     return data;
@@ -519,9 +516,8 @@ struct SkDynamicMemoryWStream::Block {
 };
 
 SkDynamicMemoryWStream::SkDynamicMemoryWStream()
-    : fHead(nullptr), fTail(nullptr), fBytesWritten(0), fCopy(nullptr)
-{
-}
+    : fHead(nullptr), fTail(nullptr), fBytesWritten(0)
+{}
 
 SkDynamicMemoryWStream::~SkDynamicMemoryWStream()
 {
@@ -655,19 +651,16 @@ void SkDynamicMemoryWStream::padToAlign4()
 
 SkData* SkDynamicMemoryWStream::copyToData() const {
     if (nullptr == fCopy) {
-        SkData* data = SkData::NewUninitialized(fBytesWritten);
+        auto data = SkData::MakeUninitialized(fBytesWritten);
         // be sure to call copyTo() before we assign to fCopy
         this->copyTo(data->writable_data());
-        fCopy = data;
+        fCopy = std::move(data);
     }
-    return SkRef(fCopy);
+    return SkRef(fCopy.get());
 }
 
 void SkDynamicMemoryWStream::invalidateCopy() {
-    if (fCopy) {
-        fCopy->unref();
-        fCopy = nullptr;
-    }
+    fCopy = nullptr;
 }
 
 class SkBlockMemoryRefCnt : public SkRefCnt {
@@ -854,21 +847,21 @@ bool SkDebugWStream::write(const void* buffer, size_t size)
 ///////////////////////////////////////////////////////////////////////////////
 
 
-static SkData* mmap_filename(const char path[]) {
+static sk_sp<SkData> mmap_filename(const char path[]) {
     FILE* file = sk_fopen(path, kRead_SkFILE_Flag);
     if (nullptr == file) {
         return nullptr;
     }
 
-    SkData* data = SkData::NewFromFILE(file);
+    auto data = SkData::MakeFromFILE(file);
     sk_fclose(file);
     return data;
 }
 
 SkStreamAsset* SkStream::NewFromFile(const char path[]) {
-    SkAutoTUnref<SkData> data(mmap_filename(path));
-    if (data.get()) {
-        return new SkMemoryStream(data.get());
+    auto data(mmap_filename(path));
+    if (data) {
+        return new SkMemoryStream(std::move(data));
     }
 
     // If we get here, then our attempt at using mmap failed, so try normal
@@ -882,11 +875,11 @@ SkStreamAsset* SkStream::NewFromFile(const char path[]) {
 }
 
 // Declared in SkStreamPriv.h:
-SkData* SkCopyStreamToData(SkStream* stream) {
+sk_sp<SkData> SkCopyStreamToData(SkStream* stream) {
     SkASSERT(stream != nullptr);
 
     if (stream->hasLength()) {
-        return SkData::NewFromStream(stream, stream->getLength());
+        return SkData::MakeFromStream(stream, stream->getLength());
     }
 
     SkDynamicMemoryWStream tempStream;
@@ -896,7 +889,7 @@ SkData* SkCopyStreamToData(SkStream* stream) {
         size_t bytesRead = stream->read(buffer, bufferSize);
         tempStream.write(buffer, bytesRead);
     } while (!stream->isAtEnd());
-    return tempStream.copyToData();
+    return sk_sp<SkData>(tempStream.copyToData());
 }
 
 bool SkStreamCopy(SkWStream* out, SkStream* input) {
diff --git a/src/core/SkStreamPriv.h b/src/core/SkStreamPriv.h
index 75f7cce8df..ac822c1110 100644
--- a/src/core/SkStreamPriv.h
+++ b/src/core/SkStreamPriv.h
@@ -8,6 +8,8 @@
 #ifndef SkStreamPriv_DEFINED
 #define SkStreamPriv_DEFINED
 
+#include "SkRefCnt.h"
+
 class SkData;
 class SkStream;
 class SkWStream;
@@ -23,7 +25,7 @@ class SkWStream;
  *      will have a ref count of one upon return and belongs to the
  *      caller. Returns nullptr on failure.
  */
-SkData* SkCopyStreamToData(SkStream* stream);
+sk_sp<SkData> SkCopyStreamToData(SkStream* stream);
 
 /**
  *  Copies the input stream from the current position to the end.
diff --git a/src/core/SkWriter32.cpp b/src/core/SkWriter32.cpp
index 457cff49ab..d328644f6b 100644
--- a/src/core/SkWriter32.cpp
+++ b/src/core/SkWriter32.cpp
@@ -76,6 +76,6 @@ void SkWriter32::growToAtLeast(size_t size) {
     }
 }
 
-SkData* SkWriter32::snapshotAsData() const {
-    return SkData::NewWithCopy(fData, fUsed);
+sk_sp<SkData> SkWriter32::snapshotAsData() const {
+    return SkData::MakeWithCopy(fData, fUsed);
 }
diff --git a/src/effects/SkColorCubeFilter.cpp b/src/effects/SkColorCubeFilter.cpp
index 44aaf8b830..d59f123a80 100644
--- a/src/effects/SkColorCubeFilter.cpp
+++ b/src/effects/SkColorCubeFilter.cpp
@@ -138,17 +138,17 @@ void SkColorCubeFilter::filterSpan(const SkPMColor src[], int count, SkPMColor d
 
 SkFlattenable* SkColorCubeFilter::CreateProc(SkReadBuffer& buffer) {
     int cubeDimension = buffer.readInt();
-    SkAutoDataUnref cubeData(buffer.readByteArrayAsData());
-    if (!buffer.validate(is_valid_3D_lut(cubeData, cubeDimension))) {
+    auto cubeData(buffer.readByteArrayAsData());
+    if (!buffer.validate(is_valid_3D_lut(cubeData.get(), cubeDimension))) {
         return nullptr;
     }
-    return Create(cubeData, cubeDimension);
+    return Create(cubeData.get(), cubeDimension);
 }
 
 void SkColorCubeFilter::flatten(SkWriteBuffer& buffer) const {
     this->INHERITED::flatten(buffer);
     buffer.writeInt(fCache.cubeDimension());
-    buffer.writeDataAsByteArray(fCubeData);
+    buffer.writeDataAsByteArray(fCubeData.get());
 }
 
 #ifndef SK_IGNORE_TO_STRING
diff --git a/src/images/SkImageDecoder_astc.cpp b/src/images/SkImageDecoder_astc.cpp
index 8989464f3b..30d65f1f0f 100644
--- a/src/images/SkImageDecoder_astc.cpp
+++ b/src/images/SkImageDecoder_astc.cpp
@@ -44,7 +44,7 @@ static inline int read_24bit(const uint8_t* buf) {
 }
 
 SkImageDecoder::Result SkASTCImageDecoder::onDecode(SkStream* stream, SkBitmap* bm, Mode mode) {
-    SkAutoTUnref<SkData> data(SkCopyStreamToData(stream));
+    auto data = SkCopyStreamToData(stream);
     if (!data || !data->size()) {
         return kFailure;
     }
diff --git a/src/images/SkImageDecoder_ktx.cpp b/src/images/SkImageDecoder_ktx.cpp
index 539795ad9b..156674565c 100644
--- a/src/images/SkImageDecoder_ktx.cpp
+++ b/src/images/SkImageDecoder_ktx.cpp
@@ -50,12 +50,12 @@ private:
 
 SkImageDecoder::Result SkKTXImageDecoder::onDecode(SkStream* stream, SkBitmap* bm, Mode mode) {
     // TODO: Implement SkStream::copyToData() that's cheap for memory and file streams
-    SkAutoDataUnref data(SkCopyStreamToData(stream));
+    auto data = SkCopyStreamToData(stream);
     if (nullptr == data) {
         return kFailure;
     }
 
-    SkKTXFile ktxFile(data);
+    SkKTXFile ktxFile(data.get());
     if (!ktxFile.valid()) {
         return kFailure;
     }
diff --git a/src/images/SkImageDecoder_libbmp.cpp b/src/images/SkImageDecoder_libbmp.cpp
index 4a6f71c82d..b9359bea7a 100644
--- a/src/images/SkImageDecoder_libbmp.cpp
+++ b/src/images/SkImageDecoder_libbmp.cpp
@@ -97,7 +97,7 @@ SkImageDecoder::Result SkBMPImageDecoder::onDecode(SkStream* stream, SkBitmap* b
     // First read the entire stream, so that all of the data can be passed to
     // the BmpDecoderHelper.
 
-    SkAutoTUnref<SkData> data(SkCopyStreamToData(stream));
+    auto data = SkCopyStreamToData(stream);
     if (!data) {
         return kFailure;
     }
diff --git a/src/images/SkImageDecoder_libico.cpp b/src/images/SkImageDecoder_libico.cpp
index 93a875d4cb..ff04d74d06 100644
--- a/src/images/SkImageDecoder_libico.cpp
+++ b/src/images/SkImageDecoder_libico.cpp
@@ -73,9 +73,8 @@ static int calculateRowBytesFor8888(int w, int bitCount)
     return 0;
 }
 
-SkImageDecoder::Result SkICOImageDecoder::onDecode(SkStream* stream, SkBitmap* bm, Mode mode)
-{
-    SkAutoTUnref<SkData> data(SkCopyStreamToData(stream));
+SkImageDecoder::Result SkICOImageDecoder::onDecode(SkStream* stream, SkBitmap* bm, Mode mode) {
+    auto data = SkCopyStreamToData(stream);
     if (!data) {
         return kFailure;
     }
diff --git a/src/images/SkImageDecoder_pkm.cpp b/src/images/SkImageDecoder_pkm.cpp
index 098a4ee0ae..af68f20d97 100644
--- a/src/images/SkImageDecoder_pkm.cpp
+++ b/src/images/SkImageDecoder_pkm.cpp
@@ -34,7 +34,7 @@ private:
 /////////////////////////////////////////////////////////////////////////////////////////
 
 SkImageDecoder::Result SkPKMImageDecoder::onDecode(SkStream* stream, SkBitmap* bm, Mode mode) {
-    SkAutoTUnref<SkData> data(SkCopyStreamToData(stream));
+    sk_sp<SkData> data(SkCopyStreamToData(stream));
     if (!data || !data->size()) {
         return kFailure;
     }
diff --git a/src/ports/SkImageDecoder_CG.cpp b/src/ports/SkImageDecoder_CG.cpp
index 2deaf21d76..c4446ae16d 100644
--- a/src/ports/SkImageDecoder_CG.cpp
+++ b/src/ports/SkImageDecoder_CG.cpp
@@ -36,7 +36,7 @@ static void data_unref_proc(void* skdata, const void*, size_t) {
 
 static CGDataProviderRef SkStreamToDataProvider(SkStream* stream) {
     // TODO: use callbacks, so we don't have to load all the data into RAM
-    SkData* skdata = SkCopyStreamToData(stream);
+    SkData* skdata = SkCopyStreamToData(stream).release();
     if (!skdata) {
         return nullptr;
     }
diff --git a/src/sfnt/SkOTUtils.cpp b/src/sfnt/SkOTUtils.cpp
index 52d996fbc5..683d750bda 100644
--- a/src/sfnt/SkOTUtils.cpp
+++ b/src/sfnt/SkOTUtils.cpp
@@ -83,7 +83,7 @@ SkData* SkOTUtils::RenameFont(SkStreamAsset* fontData, const char* fontName, int
     size_t originalDataSize = fontData->getLength() - oldNameTablePhysicalSize;
     size_t newDataSize = originalDataSize + nameTablePhysicalSize;
 
-    SkAutoTUnref<SkData> rewrittenFontData(SkData::NewUninitialized(newDataSize));
+    auto rewrittenFontData = SkData::MakeUninitialized(newDataSize);
     SK_OT_BYTE* data = static_cast<SK_OT_BYTE*>(rewrittenFontData->writable_data());
 
     if (fontData->read(data, oldNameTableOffset) < oldNameTableOffset) {
@@ -157,7 +157,7 @@ SkData* SkOTUtils::RenameFont(SkStreamAsset* fontData, const char* fontName, int
         }
     }
 
-    return rewrittenFontData.detach();
+    return rewrittenFontData.release();
 }