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() {
-    if (fReleaseProc) {
-        fReleaseProc(fPtr, fSize, fReleaseProcContext);
-    }
-}
+SkData::SkData(const void* ptr, size_t size)
+    : fSize(size)
+    , fPtr(ptr)
+{ }
 
 bool SkData::equals(const SkData* other) const {
     if (NULL == other) {
         return false;
     }
 
     return fSize == other->fSize && !memcmp(fPtr, other->fPtr, fSize);
 }
 
 size_t SkData::copyRange(size_t offset, size_t length, void* buffer) const {
     size_t available = fSize;
     if (offset >= available || 0 == length) {
         return 0;
     }
     available -= offset;
     if (length > available) {
         length = available;
     }
     SkASSERT(length > 0);
 
     memcpy(buffer, this->bytes() + offset, length);
     return length;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkData* SkData::NewEmpty() {
     static SkData* gEmptyRef;
     if (NULL == gEmptyRef) {
-        gEmptyRef = new SkData(NULL, 0, NULL, NULL);
+        gEmptyRef = new SkData(NULL, 0);
     }
     gEmptyRef->ref();
     return gEmptyRef;
 }
 
-// assumes fPtr was allocated via sk_malloc
-static void sk_free_releaseproc(const void* ptr, size_t, void*) {
+/** Assumes ptr was allocated via sk_malloc, ignores the size and context. */
+static void sk_free_releaseproc(const void* ptr, size_t) {
     sk_free((void*)ptr);
 }
 
 SkData* SkData::NewFromMalloc(const void* data, size_t length) {
-    return new SkData(data, length, sk_free_releaseproc, NULL);
+    typedef SkManagedData<SkManagedDataProcs::ReleaseProc, void> SelfType;
+    return new SelfType(data, length, sk_free_releaseproc);
+}
+
+/** Assumes obj was allocated via sk_malloc, ignores context. */
+static void sk_free_deleteproc(const void* obj) {
+    sk_free((void*)obj);
 }
 
 SkData* SkData::NewWithCopy(const void* data, size_t length) {
     if (0 == length) {
         return SkData::NewEmpty();
     }
 
-    void* copy = sk_malloc_throw(length); // balanced in sk_free_releaseproc
+    typedef SkManagedData<void, SkManagedDataProcs::DeleterProc> SelfType;
+    size_t total_size = sizeof(SelfType) + length;
+    char* self = reinterpret_cast<char*>(sk_malloc_throw(total_size));
+    char* copy = self + sizeof(SelfType);
     memcpy(copy, data, length);
-    return new SkData(copy, length, sk_free_releaseproc, NULL);
-}
-
-SkData* SkData::NewWithProc(const void* data, size_t length,
-                            ReleaseProc proc, void* context) {
-    return new SkData(data, length, proc, context);
+    return SelfType::Place(self, copy, length, sk_free_deleteproc);
 }
 
 // assumes fPtr was allocated with sk_fmmap
-static void sk_mmap_releaseproc(const void* addr, size_t length, void*) {
+static void sk_mmap_releaseproc(const void* addr, size_t length) {
     sk_fmunmap(addr, length);
 }
 
 SkData* SkData::NewFromFILE(SkFILE* f) {
     size_t size;
     void* addr = sk_fmmap(f, &size);
     if (NULL == addr) {
         return NULL;
     }
 
-    return SkData::NewWithProc(addr, size, sk_mmap_releaseproc, NULL);
+    return SkData::NewWithProc(addr, size, sk_mmap_releaseproc);
 }
 
 SkData* SkData::NewFromFileName(const char path[]) {
     SkFILE* f = path ? sk_fopen(path, kRead_SkFILE_Flag) : NULL;
     if (NULL == f) {
         return NULL;
     }
     SkData* data = NewFromFILE(f);
     sk_fclose(f);
     return data;
 }
 
 SkData* SkData::NewFromFD(int fd) {
     size_t size;
     void* addr = sk_fdmmap(fd, &size);
     if (NULL == addr) {
         return NULL;
     }
 
-    return SkData::NewWithProc(addr, size, sk_mmap_releaseproc, NULL);
+    return SkData::NewWithProc(addr, size, sk_mmap_releaseproc);
 }
 
-// assumes context is a SkData
-static void sk_dataref_releaseproc(const void*, size_t, void* context) {
-    SkData* src = reinterpret_cast<SkData*>(context);
-    src->unref();
-}
+struct SkAutoUnrefFunctor {
+public:
+    explicit SkAutoUnrefFunctor(SkRefCnt const * ptr) : fPtr(ptr) { }
+    void operator()(const void* ptr, size_t length) const {
+        fPtr->unref();
+    }
+private:
+    SkRefCnt const * fPtr;
+};
 
 SkData* SkData::NewSubset(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
         subset amount) but would possibly allow src to go out of scope sooner.
      */
 
     size_t available = src->size();
     if (offset >= available || 0 == length) {
         return SkData::NewEmpty();
     }
     available -= offset;
     if (length > available) {
         length = available;
     }
     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));
+    src->ref(); // this will be balanced in SkAutoUnrefFunctor
+    typedef SkManagedData<SkAutoUnrefFunctor, void> SelfType;
+    return new SelfType(src->bytes() + offset, length, SkAutoUnrefFunctor(src));
 }
 
 SkData* SkData::NewWithCString(const char cstr[]) {
     size_t size;
     if (NULL == cstr) {
         cstr = "";
         size = 1;
     } else {
         size = strlen(cstr) + 1;
     }
     return NewWithCopy(cstr, size);
 }
 
+SkData* SkData::NewUnowned(const void* data, size_t length) {
+    return new SkData(data, length);
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
 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;
+SkFlattenable* SkData::CreateProc(SkFlattenableReadBuffer& buffer) {
+    uint32_t length = buffer.getArrayCount();
+    if (0 == length) {
+        return SkData::NewEmpty();
     }
 
-    buffer.readByteArray(const_cast<void*>(fPtr));
+    typedef SkManagedData<void, SkManagedDataProcs::DeleterProc> SelfType;
+    size_t total_size = sizeof(SelfType) + length;
+    char* self = reinterpret_cast<char*>(sk_malloc_throw(total_size));
+    char* copy = self + sizeof(SelfType);
+    buffer.readByteArray(copy);
+    return SelfType::Place(self, copy, length, sk_free_deleteproc);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "SkDataSet.h"
 #include "SkFlattenable.h"
 #include "SkStream.h"
 
 static SkData* dupdata(SkData* data) {
@@ skipping 141 matching lines @@
 }
 
 SkDataSet* SkDataSet::NewEmpty() {
     static SkDataSet* gEmptySet;
     if (NULL == gEmptySet) {
         gEmptySet = SkNEW_ARGS(SkDataSet, (NULL, 0));
     }
     gEmptySet->ref();
     return gEmptySet;
 }