change SkStreams to work with sk_sp<SkData> instead of SkData*

src/core/SkStream.cpp

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkStream.h"
 #include "SkStreamPriv.h"
@@ skipping 288 matching lines @@
     fOffset = 0;
 }
 
 SkMemoryStream::SkMemoryStream(sk_sp<SkData> data) : fData(std::move(data)) {
     if (nullptr == fData) {
         fData = SkData::MakeEmpty();
     }
     fOffset = 0;
 }
 
+#ifdef SK_SUPPORT_LEGACY_STREAM_DATA
 SkMemoryStream::SkMemoryStream(SkData* data) {
     if (nullptr == data) {
         fData = SkData::MakeEmpty();
     } else {
         fData = sk_ref_sp(data);
     }
     fOffset = 0;
 }
+#endif
 
 void SkMemoryStream::setMemoryOwned(const void* src, size_t size) {
     fData = SkData::MakeFromMalloc(src, size);
     fOffset = 0;
 }
 
 void SkMemoryStream::setMemory(const void* src, size_t size, bool copyData) {
     fData = newFromParams(src, size, copyData);
     fOffset = 0;
 }
 
-SkData* SkMemoryStream::copyToData() const {
-    return SkSafeRef(fData.get());
-}
-
-SkData* SkMemoryStream::setData(SkData* data) {
+void SkMemoryStream::setData(sk_sp<SkData> data) {
     if (nullptr == data) {
         fData = SkData::MakeEmpty();
     } else {
-        fData = sk_ref_sp(data);
+        fData = data;
     }
     fOffset = 0;
-    return data;
 }
 
 void SkMemoryStream::skipToAlign4() {
     // cast to remove unary-minus warning
     fOffset += -(int)fOffset & 0x03;
 }
 
 size_t SkMemoryStream::read(void* buffer, size_t size) {
     size_t dataSize = fData->size();
 
@@ skipping 285 matching lines @@
 void SkDynamicMemoryWStream::padToAlign4()
 {
     // cast to remove unary-minus warning
     int padBytes = -(int)fBytesWritten & 0x03;
     if (padBytes == 0)
         return;
     int zero = 0;
     write(&zero, padBytes);
 }
 
-SkData* SkDynamicMemoryWStream::copyToData() const {
+sk_sp<SkData> SkDynamicMemoryWStream::snapshotAsData() const {
     if (nullptr == fCopy) {
         auto data = SkData::MakeUninitialized(fBytesWritten);
         // be sure to call copyTo() before we assign to fCopy
         this->copyTo(data->writable_data());
         fCopy = std::move(data);
     }
-    return SkRef(fCopy.get());
+    return fCopy;
+}
+
+sk_sp<SkData> SkDynamicMemoryWStream::detachAsData() {
+    sk_sp<SkData> data = this->snapshotAsData();
+    this->reset();
+    return data;
 }
 
 void SkDynamicMemoryWStream::invalidateCopy() {
     fCopy = nullptr;
 }
 
 class SkBlockMemoryRefCnt : public SkRefCnt {
 public:
     explicit SkBlockMemoryRefCnt(SkDynamicMemoryWStream::Block* head) : fHead(head) { }
 
@@ skipping 212 matching lines @@
         return SkData::MakeFromStream(stream, stream->getLength());
     }
 
     SkDynamicMemoryWStream tempStream;
     const size_t bufferSize = 4096;
     char buffer[bufferSize];
     do {
         size_t bytesRead = stream->read(buffer, bufferSize);
         tempStream.write(buffer, bytesRead);
     } while (!stream->isAtEnd());
-    return sk_sp<SkData>(tempStream.copyToData());
+    return tempStream.detachAsData();
 }
 
 bool SkStreamCopy(SkWStream* out, SkStream* input) {
     const char* base = static_cast<const char*>(input->getMemoryBase());
     if (base && input->hasPosition() && input->hasLength()) {
         // Shortcut that avoids the while loop.
         size_t position = input->getPosition();
         size_t length = input->getLength();
         SkASSERT(length >= position);
         return out->write(&base[position], length - position);
     }
     char scratch[4096];
     size_t count;
     while (true) {
         count = input->read(scratch, sizeof(scratch));
         if (0 == count) {
             return true;
         }
         if (!out->write(scratch, count)) {
             return false;
         }
     }
 }