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"
@@ skipping 40 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);
 }
 
+/** This is a global marker function which does nothing itself.
+ *  When set as the release proc and the ref count goes to zero,
+ *  the destructor will be called, followed by sk_free(context).
+ */
+static void sk_free_after_destructor_releaseproc(const void*, size_t, void*) {
+    // This function intentionally left blank.

[reed1, 2013/06/11 21:28:15]

SkASSERT(!"don't call me");

[bungeman-skia, 2013/06/11 22:25:32]

Removed this function.

+}
+
+void SkData::internal_dispose() const {
+    if (sk_free_after_destructor_releaseproc == this->fReleaseProc) {
+        this->internal_dispose_restore_refcnt_to_1();
+        void* context = this->fReleaseProcContext;

[reed1, 2013/06/11 21:28:15]

Isn't context always == this? can we call free on that instead?

[bungeman-skia, 2013/06/11 22:25:32]

Hmmmm... yes, we do magically know that. In fact, no one else should be able to
set our fReleaseProcContext to 'this' (without being crazy) because we don't
allow changing fReleaseProcContext and 'this' isn't known until after the user
creates the object. Using this allows removal of the proc as well.

+        this->~SkData();
+        sk_free(context);
+        return;
+    }
+    this->INHERITED::internal_dispose();
+}
+
 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
+    char* everything = reinterpret_cast<char*>(sk_malloc_throw(sizeof(SkData) + length));

[reed1, 2013/06/11 21:28:15]

This is an 80-col file...

[bungeman-skia, 2013/06/11 22:25:32]

Done.

+    char* copy = everything + sizeof(SkData);
     memcpy(copy, data, length);
-    return new SkData(copy, length, sk_free_releaseproc, NULL);
+    return SkNEW_PLACEMENT_ARGS(everything, SkData, (copy, length, sk_free_after_destructor_releaseproc, everything));
 }
 
 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 241 matching lines @@
 }
 
 SkDataSet* SkDataSet::NewEmpty() {
     static SkDataSet* gEmptySet;
     if (NULL == gEmptySet) {
         gEmptySet = SkNEW_ARGS(SkDataSet, (NULL, 0));
     }
     gEmptySet->ref();
     return gEmptySet;
 }