SkData can allocate room for its contents in the same block

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 51 matching lines @@
     } else {
         return byte;
     }
 }
 
 SkData* SkStream::readData() {
     size_t size = this->readU32();
     if (0 == size) {
         return SkData::NewEmpty();
     } else {
-        void* buffer = sk_malloc_throw(size);
-        this->read(buffer, size);
-        return SkData::NewFromMalloc(buffer, size);
+        SkData* data = SkData::NewUninitialized(size);
+        this->read(data->writable_data(), size);
+        return data;
     }
 }
 
 //////////////////////////////////////////////////////////////////////////////////////
 
 SkWStream::~SkWStream()
 {
 }
 
 void SkWStream::newline()
@@ skipping 216 matching lines @@
     }
     return fData->data();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static SkData* newFromParams(const void* src, size_t size, bool copyData) {
     if (copyData) {
         return SkData::NewWithCopy(src, size);
     } else {
-        return SkData::NewWithProc(src, size, NULL, NULL);
+        return SkData::NewWithoutCopy(src, size);
     }
 }
 
 SkMemoryStream::SkMemoryStream() {
     fData = SkData::NewEmpty();
     fOffset = 0;
 }
 
 SkMemoryStream::SkMemoryStream(size_t size) {
-    fData = SkData::NewFromMalloc(sk_malloc_throw(size), size);
+    fData = SkData::NewUninitialized(size);
     fOffset = 0;
 }
 
 SkMemoryStream::SkMemoryStream(const void* src, size_t size, bool copyData) {
     fData = newFromParams(src, size, copyData);
     fOffset = 0;
 }
 
 SkMemoryStream::SkMemoryStream(SkData* data) {
     if (NULL == data) {
@@ skipping 315 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 (NULL == fCopy) {
-        void* buffer = sk_malloc_throw(fBytesWritten);
-        this->copyTo(buffer);
-        fCopy = SkData::NewFromMalloc(buffer, fBytesWritten);
+        SkData* data = SkData::NewUninitialized(fBytesWritten);
+        // be sure to call copyTo() before we assign to fCopy
+        this->copyTo(data->writable_data());
+        fCopy = data;
     }
-    fCopy->ref();
-    return fCopy;
+    return SkRef(fCopy);
 }
 
 void SkDynamicMemoryWStream::invalidateCopy() {
     if (fCopy) {
         fCopy->unref();
         fCopy = NULL;
     }
 }
 
 class SkBlockMemoryRefCnt : public SkRefCnt {
@@ skipping 211 matching lines @@
     tempStream.copyTo(dst);
     return length;
 }
 
 // Declared in SkStreamPriv.h:
 SkData* SkCopyStreamToData(SkStream* stream) {
     SkASSERT(stream != NULL);
 
     if (stream->hasLength()) {
         const size_t length = stream->getLength();
-        SkAutoMalloc dst(length);
-        if (stream->read(dst.get(), length) != length) {
-            return NULL;
+        SkData* data = SkData::NewUninitialized(length);
+        if (stream->read(data->writable_data(), length) != length) {
+            data->unref();
+            data = NULL;
         }
-        return SkData::NewFromMalloc(dst.detach(), length);
+        return data;
     }
 
     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();
 }
 
 SkStreamRewindable* SkStreamRewindableFromSkStream(SkStream* stream) {
     if (!stream) {
         return NULL;
     }
     SkAutoTUnref<SkStreamRewindable> dupStream(stream->duplicate());
     if (dupStream) {
         return dupStream.detach();
     }
     stream->rewind();
     if (stream->hasLength()) {
         size_t length = stream->getLength();
         if (stream->hasPosition()) {  // If stream has length, but can't rewind.
             length -= stream->getPosition();
         }
-        SkAutoMalloc allocMemory(length);
-        SkDEBUGCODE(size_t read =) stream->read(allocMemory.get(), length);
+        SkAutoTUnref<SkData> data(SkData::NewUninitialized(length));
+        SkDEBUGCODE(size_t read =) stream->read(data->writable_data(), length);
         SkASSERT(length == read);
-        SkAutoTUnref<SkData> data(
-                SkData::NewFromMalloc(allocMemory.detach(), length));
         return SkNEW_ARGS(SkMemoryStream, (data.get()));
     }
     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.detachAsStream();  // returns a SkBlockMemoryStream,
                                          // cheaper than copying to SkData
 }