One allocation for an SkData which makes a copy.

include/core/SkData.h

-
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
-
-
 #ifndef SkData_DEFINED
 #define SkData_DEFINED
 
 #include "SkFlattenable.h"
 
 struct SkFILE;
 
 /**
  *  SkData holds an immutable data buffer. Not only is the data immutable,
  *  but the actual ptr that is returned (by data() or bytes()) is guaranteed
@@ skipping 31 matching lines @@
      */
     size_t copyRange(size_t offset, size_t length, void* buffer) const;
 
     /**
      *  Returns true if these two objects have the same length and contents,
      *  effectively returning 0 == memcmp(...)
      */
     bool equals(const SkData* other) const;
 
     /**
-     *  Function that, if provided, will be called when the SkData goes out
-     *  of scope, allowing for custom allocation/freeing of the data.
-     */
-    typedef void (*ReleaseProc)(const void* ptr, size_t length, void* context);
-
-    /**
      *  Create a new dataref by copying the specified data
      */
     static SkData* NewWithCopy(const void* data, size_t length);
 
     /**
      *  Create a new dataref by copying the specified c-string
      *  (a null-terminated array of bytes). The returned SkData will have size()
      *  equal to strlen(cstr) + 1. If cstr is NULL, it will be treated the same
      *  as "".
      */
     static SkData* NewWithCString(const char cstr[]);
 
     /**
-     *  Create a new dataref, taking the data ptr as is, and using the
-     *  releaseproc to free it. The proc may be NULL.
+     *  Creates a new SkData which takes ownership of the data, using the
+     *  releaseProc to free it.
+     *
+     *  The releaseProc must be of a type where
+     *  releaseProc(const void* ptr, size_t length);
+     *  is valid.
      */
-    static SkData* NewWithProc(const void* data, size_t length,
-                               ReleaseProc proc, void* context);
+    template <typename T>
+    static SkData* NewWithProc(const void* data, size_t length, T releaseProc);
 
     /**
      *  Create a new dataref from a pointer allocated by malloc. The Data object
      *  takes ownership of that allocation, and will handling calling sk_free.
      */
     static SkData* NewFromMalloc(const void* data, size_t length);
 
     /**
      *  Create a new dataref the file with the specified path.
      *  If the file cannot be opened, this returns NULL.
@@ skipping 23 matching lines @@
      *  src dataref.
      */
     static SkData* NewSubset(const SkData* src, size_t offset, size_t length);
 
     /**
      *  Returns a new empty dataref (or a reference to a shared empty dataref).
      *  New or shared, the caller must see that unref() is eventually called.
      */
     static SkData* NewEmpty();
 
-    SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkData)
+    /**
+     *  Creates an SkData which does not delete the data.
+     *  Such an SkData is just a pointer and length.

[reed1, 2013/06/21 19:00:36]

Not sure what this 2nd sentence means.

"The caller must ensure that the data pointer remains valid for the lifetime of
the returned SkData object. Since SkData is reference countable, this can be
hard to know in the general case. One safe example would be if the pointer was
to global read-only data."

+     */
+    static SkData* NewUnowned(const void* data, size_t length);

[reed1, 2013/06/21 19:00:36]

NewUnmanaged() ?
maybe unowned is better.

I presume the reason this is public at all is for SkStream?

+
+    //SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkData)
+    virtual Factory getFactory() SK_OVERRIDE { return CreateProc; }
+    static SkFlattenable* CreateProc(SkFlattenableReadBuffer& buffer);
 
 protected:
     SkData(SkFlattenableReadBuffer&);
     virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
 
 private:
-    ReleaseProc fReleaseProc;
-    void*       fReleaseProcContext;
+    size_t const fSize;
+    void const * const fPtr;
 
-    const void* fPtr;
-    size_t      fSize;
+    SkData(const void* ptr, size_t size);
 
-    SkData(const void* ptr, size_t size, ReleaseProc, void* context);
-    virtual ~SkData();
-
+    template <typename Release, typename Deleter> friend class SkManagedData;
     typedef SkFlattenable INHERITED;
 };
 
+namespace SkManagedDataProcs {
+    typedef void (*ReleaseProc)(const void* ptr, size_t length);
+    typedef void (*DeleterProc)(const void* obj);
+}
+
+/**
+ *  The Release and Deleter types must allow
+ *
+ *  release(const void* data, size_t length);
+ *  deleter(const void* obj);
+ *
+ *  to be valid, respectively. If these are function pointers,
+ *  Release and Deleter should be specified to have one of the types in
+ *  SkManagedDataProcs.
+ */
+template <typename Release, typename Deleter>
+class SkManagedData : public SkData {
+public:
+    /**
+     *  Constructs an SkManagedData at the given memory.
+     *  When destroyed, release(ptr, size) will be called.
+     *  When the reference count goes to zero, deleter(memory) will be called.
+     */
+    static SkData* Place(void* memory, const void* data, size_t length,
+                         Release release, Deleter deleter) {
+        return SkNEW_PLACEMENT_ARGS(memory, SkManagedData, (
+            data, length, release, deleter));
+    }
+
+private:
+    SkManagedData(const void* p, size_t size, Release release, Deleter deleter)
+        : SkData(p, size), fRelease(release), fDeleter(deleter)
+    { }
+
+    virtual ~SkManagedData() {
+        fRelease(fPtr, fSize);
+    }
+
+    /** Called when the reference count goes to zero. */
+    virtual void internal_dispose() const SK_OVERRIDE {
+        Deleter deleter = fDeleter;
+        this->internal_dispose_restore_refcnt_to_1();
+        this->~SkData();
+        deleter(this);
+        return;
+    }
+
+    Release const fRelease;
+    Deleter const fDeleter;
+
+    typedef SkData INHERITED;
+};
+
+template <typename Deleter> class SkManagedData<void, Deleter> : public SkData {
+public:
+    /**
+     *  Constructs an SkManagedData at the given memory.
+     *  When the reference count goes to zero, deleter(memory) will be called.
+     */
+    static SkData* Place(void* memory, const void* data, size_t length,
+                         Deleter deleter)
+    {
+        return SkNEW_PLACEMENT_ARGS(memory, SkManagedData, (
+            data, length, deleter));
+    }
+
+private:
+    SkManagedData(const void* ptr, size_t size, Deleter deleter)
+        : SkData(ptr, size), fDeleter(deleter)
+    { }
+
+    /** Called when the reference count goes to zero. */
+    virtual void internal_dispose() const SK_OVERRIDE {
+        Deleter deleter = fDeleter;
+        this->internal_dispose_restore_refcnt_to_1();
+        this->~SkData();
+        deleter(this);
+        return;
+    }
+
+    Deleter const fDeleter;
+
+    typedef SkData INHERITED;
+};
+
+template <typename Release> class SkManagedData<Release, void> : public SkData {
+    /** When destroyed, release(ptr, size) will be called. */
+    SkManagedData(const void* ptr, size_t size, Release release)
+        : SkData(ptr, size), fRelease(release)
+    { }
+
+    virtual ~SkManagedData() {
+        fRelease(fPtr, fSize);
+    }
+
+    Release const fRelease;
+
+    typedef SkData INHERITED;
+    friend class SkData;
+};
+
+template <typename T>
+SkData* SkData::NewWithProc(const void* data, size_t length, T releaseProc) {
+    return new SkManagedData<T, void>(data, length, releaseProc);
+}
+
 /** Typedef of SkAutoTUnref<SkData> for automatically unref-ing a SkData. */
 typedef SkAutoTUnref<SkData> SkAutoDataUnref;
 
 #endif