Add SkCachedData and use it for SkMipMap

src/core/SkCachedData.h

Index: src/core/SkCachedData.h
diff --git a/src/core/SkCachedData.h b/src/core/SkCachedData.h
new file mode 100644
index 0000000000000000000000000000000000000000..03dfc3c20dd656b51f3c88516c2b439bdcca1d2c
--- /dev/null
+++ b/src/core/SkCachedData.h
@@ -0,0 +1,102 @@
+/*
+ * Copyright 2014 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkCachedData_DEFINED
+#define SkCachedData_DEFINED
+
+#include "SkThread.h"
+
+class SkDiscardableMemory;
+
+class SkCachedData : ::SkNoncopyable {
+public:
+    SkCachedData(void* mallocData, size_t size);
+    SkCachedData(size_t size, SkDiscardableMemory*);
+    virtual ~SkCachedData();
+
+    size_t size() const { return fSize; }
+    const void* data() const { return fData; }
+
+    void* writable_data() { return fData; }
+
+    void ref() const { this->internalRef(false); }
+    void unref() const { this->internalUnref(false); }
+
+    int testing_only_getRefCnt() const { return fRefCnt >> 1; }
+    bool testing_only_isInCache() const { return fRefCnt & 1; }
+
+protected:
+    // called when fData changes. could be NULL.
+    virtual void onDataChange(void* oldData, void* newData) {}
+
+private:
+    SkMutex fMutex;     // could use a pool of these...
+
+    enum StorageType {
+        kDiscardableMemory_StorageType,
+        kMalloc_StorageType
+    };
+
+    union {
+        SkDiscardableMemory*    fDM;
+        void*                   fMalloc;
+    } fStorage;
+    void*                   fData;
+    size_t                  fSize;
+    int32_t                 fRefCnt;    // low-bit means we're owned by the cache

[mtklein, 2014/09/26 19:06:33]

Now that you've got a mutex, why don't we go back to something basic, e.g.
  bool fInCache;
  int  fActiveClientCount;
?

[reed1, 2014/09/26 21:33:51]

Done.

+    StorageType             fStorageType;
+
+    void internalRef(bool fromCache) const;
+    void internalUnref(bool fromCache) const;
+    bool doInternalUnref(bool fromCache) const;
+
+    SkMutex& get_mutex() { return fMutex; }
+    void in_mutex_lock();
+    void in_mutex_unlock();
+    void in_mutex_prepareToDelete();
+
+    void assert_in_mutex() {
+        fMutex.assertHeld();
+    }
+    
+    // called whenever our fData might change (lock or unlock)
+    void setData(void* newData) {
+        if (newData != fData) {
+            // notify our subclasses of the change
+            this->onDataChange(fData, newData);
+            fData = newData;
+        }
+    }
+    
+
+public:
+    /*
+     *  Attaching a data to to a SkResourceCache (only one at a time) enables the data to be
+     *  unlocked when the cache is the only owner, thus freeing it to be purged (assuming the
+     *  data is backed by a SkDiscardableMemory).
+     *
+     *  When attached, it also automatically attempts to "lock" the data when the first client
+     *  ref's the data (typically from a find(key, visitor) call).
+     *
+     *  Thus the data will always be "locked" when a non-cache has a ref on it (whether or not
+     *  the lock succeeded to recover the memory -- check data() to see if it is NULL).
+     */
+
+    /*
+     *  Call when adding this instance to a SkResourceCache::Rec subclass
+     *  (typically in the Rec's constructor).
+     */
+    void attachToCacheAndRef() const { this->internalRef(true); }
+
+    /*
+     *  Call when removing this instance from a SkResourceCache::Rec subclass
+     *  (typically in the Rec's destructor).
+     */
+    void detachFromCacheAndUnref() const { this->internalUnref(true); }
+};
+
+#endif