Make sp variants for 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"
@@ skipping 227 matching lines @@
         return new SkMemoryStream(fData);
     }
 
     if (!fName.isEmpty()) {
         SkAutoTDelete<SkFILEStream> that(new SkFILEStream(fName.c_str()));
         if (sk_fidentical(that->fFILE, this->fFILE)) {
             return that.detach();
         }
     }
 
-    fData.reset(SkData::NewFromFILE(fFILE));
-    if (nullptr == fData.get()) {
+    fData = SkData::MakeFromFILE(fFILE);
+    if (nullptr == fData) {
         return nullptr;
     }
     return new SkMemoryStream(fData);
 }
 
 size_t SkFILEStream::getPosition() const {
     return sk_ftell(fFILE);
 }
 
 bool SkFILEStream::seek(size_t position) {
@@ skipping 16 matching lines @@
 
 const void* SkFILEStream::getMemoryBase() {
     if (nullptr == fData.get()) {
         return nullptr;
     }
     return fData->data();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-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;
 }
 
 SkMemoryStream::SkMemoryStream(const void* src, size_t size, bool copyData) {
     fData = newFromParams(src, size, 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;
 }
 
 void SkMemoryStream::skipToAlign4() {
     // cast to remove unary-minus warning
     fOffset += -(int)fOffset & 0x03;
 }
 
@@ skipping 155 matching lines @@
     const void* append(const void* data, size_t size)
     {
         SkASSERT((size_t)(fStop - fCurr) >= size);
         memcpy(fCurr, data, size);
         fCurr += size;
         return (const void*)((const char*)data + size);
     }
 };
 
 SkDynamicMemoryWStream::SkDynamicMemoryWStream()
-    : fHead(nullptr), fTail(nullptr), fBytesWritten(0), fCopy(nullptr)
-{
-}
+    : fHead(nullptr), fTail(nullptr), fBytesWritten(0)
+{}
 
 SkDynamicMemoryWStream::~SkDynamicMemoryWStream()
 {
     reset();
 }
 
 void SkDynamicMemoryWStream::reset()
 {
     this->invalidateCopy();
 
@@ skipping 113 matching lines @@
     // 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 {
     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 {
 public:
     explicit SkBlockMemoryRefCnt(SkDynamicMemoryWStream::Block* head) : fHead(head) { }
 
     virtual ~SkBlockMemoryRefCnt() {
         SkDynamicMemoryWStream::Block* block = fHead;
         while (block != nullptr) {
             SkDynamicMemoryWStream::Block* next = block->fNext;
@@ skipping 166 matching lines @@
     delete[] s;
     fBytesWritten += size;
 #endif
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 
 
-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
     // file access.
     SkFILEStream* stream = new SkFILEStream(path);
     if (!stream->isValid()) {
         delete stream;
         stream = nullptr;
     }
     return stream;
 }
 
 // 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;
     const size_t bufferSize = 4096;
     char buffer[bufferSize];
     do {
         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) {
     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;
         }
     }
 }