One allocation for an SkData which makes a copy.

src/core/SkData.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkData.h"
 #include "SkFlattenableBuffers.h"
 #include "SkOSFile.h"
 
 SK_DEFINE_INST_COUNT(SkData)
 
-SkData::SkData(const void* ptr, size_t size, ReleaseProc proc, void* context) {
-    fPtr = ptr;
-    fSize = size;
-    fReleaseProc = proc;
-    fReleaseProcContext = context;
-}
+SkData::SkData(const void* ptr, size_t size, ReleaseProc proc, void* context)
+    : fSize(size)
+    , fPtr(ptr)
+    , fReleaseProc(proc)
+    , fReleaseProcContext(context)
+    { }
 
 SkData::~SkData() {
     if (fReleaseProc) {
         fReleaseProc(fPtr, fSize, fReleaseProcContext);
     }
 }
 
 bool SkData::equals(const SkData* other) const {
     if (NULL == other) {
         return false;
@@ skipping 21 matching lines @@
 
 SkData* SkData::NewEmpty() {
     static SkData* gEmptyRef;
     if (NULL == gEmptyRef) {
         gEmptyRef = new SkData(NULL, 0, NULL, NULL);
     }
     gEmptyRef->ref();
     return gEmptyRef;
 }
 
-// assumes fPtr was allocated via sk_malloc
+/** Assumes ptr was allocated via sk_malloc, ignores the size and context. */
 static void sk_free_releaseproc(const void* ptr, size_t, void*) {
     sk_free((void*)ptr);
 }
 
 SkData* SkData::NewFromMalloc(const void* data, size_t length) {
     return new SkData(data, length, sk_free_releaseproc, NULL);
 }
 
+void SkData::internal_dispose() const {
+    if (this == this->fReleaseProcContext) {
+        this->internal_dispose_restore_refcnt_to_1();
+        this->~SkData();
+        sk_free(const_cast<SkData*>(this));
+        return;
+    }
+    this->INHERITED::internal_dispose();
+}
+
 SkData* SkData::NewWithCopy(const void* data, size_t length) {
     if (0 == length) {
         return SkData::NewEmpty();
     }
 

[reed1, 2013/06/12 13:39:31]

The code is good, but lets add a comment block describing what we're doing at a
high-level. e.g. "for speed, combine the SkData and the caller's data into a
single malloc. Our internal_dispose detects this (by seeing that
fReleaseProcContext == this) and will cleanup properly."

-    void* copy = sk_malloc_throw(length); // balanced in sk_free_releaseproc
+    size_t total_size = sizeof(SkData) + length;
+    char* self = reinterpret_cast<char*>(sk_malloc_throw(total_size));
+    char* copy = self + sizeof(SkData);
     memcpy(copy, data, length);
-    return new SkData(copy, length, sk_free_releaseproc, NULL);
+    return SkNEW_PLACEMENT_ARGS(self, SkData, (copy, length, NULL, self));
 }
 
 SkData* SkData::NewWithProc(const void* data, size_t length,
                             ReleaseProc proc, void* context) {
     return new SkData(data, length, proc, context);
 }
 
 // assumes fPtr was allocated with sk_fmmap
 static void sk_mmap_releaseproc(const void* addr, size_t length, void*) {
     sk_fmunmap(addr, length);
@@ skipping 67 matching lines @@
     }
     return NewWithCopy(cstr, size);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkData::flatten(SkFlattenableWriteBuffer& buffer) const {
     buffer.writeByteArray(fPtr, fSize);
 }
 
-SkData::SkData(SkFlattenableReadBuffer& buffer) {
-    fSize = buffer.getArrayCount();
-    fReleaseProcContext = NULL;
-
-    if (fSize > 0) {
-        fPtr = sk_malloc_throw(fSize);
-        fReleaseProc = sk_free_releaseproc;
-    } else {
-        fPtr = NULL;
-        fReleaseProc = NULL;
-    }
-
+SkData::SkData(SkFlattenableReadBuffer& buffer)
+    : fSize(buffer.getArrayCount())
+    , fPtr(fSize > 0 ? sk_malloc_throw(fSize) : NULL)
+    , fReleaseProc(fSize > 0 ? sk_free_releaseproc : NULL)
+    , fReleaseProcContext(NULL)
+{
     buffer.readByteArray(const_cast<void*>(fPtr));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "SkDataSet.h"
 #include "SkFlattenable.h"
 #include "SkStream.h"
 
@@ skipping 142 matching lines @@
 }
 
 SkDataSet* SkDataSet::NewEmpty() {
     static SkDataSet* gEmptySet;
     if (NULL == gEmptySet) {
         gEmptySet = SkNEW_ARGS(SkDataSet, (NULL, 0));
     }
     gEmptySet->ref();
     return gEmptySet;
 }