SkDiscardableMemoryPool: modernize

  * Use unique_ptr, sk_sp, SkAutoFree, using.
  * Rely on thread-safe static global initializion.

Change-Id: I7c14e0e57622163b1b81b97a218b816fe6d02926
Reviewed-on: https://skia-review.googlesource.com/13818
Commit-Queue: Hal Canary <halcanary@google.com>
Reviewed-by: Herb Derby <herb@google.com>

2 files changed, 30 insertions, 41 deletions

diff --git a/src/lazy/SkDiscardableMemoryPool.cpp b/src/lazy/SkDiscardableMemoryPool.cpp
index 8a6cb526b3..aeba34bb04 100644
--- a/src/lazy/SkDiscardableMemoryPool.cpp
+++ b/src/lazy/SkDiscardableMemoryPool.cpp
@@ -5,13 +5,13 @@
  * found in the LICENSE file.
  */
 
-#include "SkDiscardableMemory.h"
 #include "SkDiscardableMemoryPool.h"
-#include "SkImageGenerator.h"
+#include "SkDiscardableMemory.h"
+#include "SkMakeUnique.h"
 #include "SkMalloc.h"
 #include "SkMutex.h"
-#include "SkOnce.h"
 #include "SkTInternalLList.h"
+#include "SkTemplates.h"
 
 // Note:
 // A PoolDiscardableMemory is memory that is counted in a pool.
@@ -33,7 +33,10 @@ public:
     DiscardableMemoryPool(size_t budget, SkBaseMutex* mutex = nullptr);
     ~DiscardableMemoryPool() override;
 
-    SkDiscardableMemory* create(size_t bytes) override;
+    std::unique_ptr<SkDiscardableMemory> make(size_t bytes);
+    SkDiscardableMemory* create(size_t bytes) override {
+        return this->make(bytes).release();  // TODO: change API
+    }
 
     size_t getRAMUsed() override;
     void setRAMBudget(size_t budget) override;
@@ -61,7 +64,7 @@ private:
     /** Function called to free memory if needed */
     void dumpDownTo(size_t budget);
     /** called by DiscardableMemoryPool upon destruction */
-    void free(PoolDiscardableMemory* dm);
+    void removeFromPool(PoolDiscardableMemory* dm);
     /** called by DiscardableMemoryPool::lock() */
     bool lock(PoolDiscardableMemory* dm);
     /** called by DiscardableMemoryPool::unlock() */
@@ -78,8 +81,7 @@ private:
  */
 class PoolDiscardableMemory : public SkDiscardableMemory {
 public:
-    PoolDiscardableMemory(DiscardableMemoryPool* pool,
-                            void* pointer, size_t bytes);
+    PoolDiscardableMemory(sk_sp<DiscardableMemoryPool> pool, SkAutoFree pointer, size_t bytes);
     ~PoolDiscardableMemory() override;
     bool lock() override;
     void* data() override;
@@ -87,29 +89,24 @@ public:
     friend class DiscardableMemoryPool;
 private:
     SK_DECLARE_INTERNAL_LLIST_INTERFACE(PoolDiscardableMemory);
-    DiscardableMemoryPool* const fPool;
+    sk_sp<DiscardableMemoryPool> fPool;
     bool                         fLocked;
-    void*                        fPointer;
+    SkAutoFree                   fPointer;
     const size_t                 fBytes;
 };
 
-PoolDiscardableMemory::PoolDiscardableMemory(DiscardableMemoryPool* pool,
-                                             void* pointer,
+PoolDiscardableMemory::PoolDiscardableMemory(sk_sp<DiscardableMemoryPool> pool,
+                                             SkAutoFree pointer,
                                              size_t bytes)
-    : fPool(pool)
-    , fLocked(true)
-    , fPointer(pointer)
-    , fBytes(bytes) {
+        : fPool(std::move(pool)), fLocked(true), fPointer(std::move(pointer)), fBytes(bytes) {
     SkASSERT(fPool != nullptr);
     SkASSERT(fPointer != nullptr);
     SkASSERT(fBytes > 0);
-    fPool->ref();
 }
 
 PoolDiscardableMemory::~PoolDiscardableMemory() {
     SkASSERT(!fLocked); // contract for SkDiscardableMemory
-    fPool->free(this);
-    fPool->unref();
+    fPool->removeFromPool(this);
 }
 
 bool PoolDiscardableMemory::lock() {
@@ -119,7 +116,7 @@ bool PoolDiscardableMemory::lock() {
 
 void* PoolDiscardableMemory::data() {
     SkASSERT(fLocked); // contract for SkDiscardableMemory
-    return fPointer;
+    return fPointer.get();
 }
 
 void PoolDiscardableMemory::unlock() {
@@ -153,14 +150,13 @@ void DiscardableMemoryPool::dumpDownTo(size_t budget) {
     if (fUsed <= budget) {
         return;
     }
-    typedef SkTInternalLList<PoolDiscardableMemory>::Iter Iter;
+    using Iter = SkTInternalLList<PoolDiscardableMemory>::Iter;
     Iter iter;
     PoolDiscardableMemory* cur = iter.init(fList, Iter::kTail_IterStart);
     while ((fUsed > budget) && (cur)) {
         if (!cur->fLocked) {
             PoolDiscardableMemory* dm = cur;
             SkASSERT(dm->fPointer != nullptr);
-            sk_free(dm->fPointer);
             dm->fPointer = nullptr;
             SkASSERT(fUsed >= dm->fBytes);
             fUsed -= dm->fBytes;
@@ -174,25 +170,23 @@ void DiscardableMemoryPool::dumpDownTo(size_t budget) {
     }
 }
 
-SkDiscardableMemory* DiscardableMemoryPool::create(size_t bytes) {
-    void* addr = sk_malloc_flags(bytes, 0);
+std::unique_ptr<SkDiscardableMemory> DiscardableMemoryPool::make(size_t bytes) {
+    SkAutoFree addr(sk_malloc_flags(bytes, 0));
     if (nullptr == addr) {
         return nullptr;
     }
-    PoolDiscardableMemory* dm = new PoolDiscardableMemory(this, addr, bytes);
+    auto dm = skstd::make_unique<PoolDiscardableMemory>(sk_ref_sp(this), std::move(addr), bytes);
     SkAutoMutexAcquire autoMutexAcquire(fMutex);
-    fList.addToHead(dm);
+    fList.addToHead(dm.get());
     fUsed += bytes;
     this->dumpDownTo(fBudget);
-    return dm;
+    return std::move(dm);
 }
 
-void DiscardableMemoryPool::free(PoolDiscardableMemory* dm) {
+void DiscardableMemoryPool::removeFromPool(PoolDiscardableMemory* dm) {
     SkAutoMutexAcquire autoMutexAcquire(fMutex);
     // This is called by dm's destructor.
     if (dm->fPointer != nullptr) {
-        sk_free(dm->fPointer);
-        dm->fPointer = nullptr;
         SkASSERT(fUsed >= dm->fBytes);
         fUsed -= dm->fBytes;
         fList.remove(dm);
@@ -242,18 +236,14 @@ void DiscardableMemoryPool::dumpPool() {
 
 }  // namespace
 
-SkDiscardableMemoryPool* SkDiscardableMemoryPool::Create(size_t size, SkBaseMutex* mutex) {
-    return new DiscardableMemoryPool(size, mutex);
+sk_sp<SkDiscardableMemoryPool> SkDiscardableMemoryPool::Make(size_t size, SkBaseMutex* mutex) {
+    return sk_make_sp<DiscardableMemoryPool>(size, mutex);
 }
 
-SK_DECLARE_STATIC_MUTEX(gMutex);
-
 SkDiscardableMemoryPool* SkGetGlobalDiscardableMemoryPool() {
-    static SkOnce once;
-    static SkDiscardableMemoryPool* global;
-    once([]{
-        global = SkDiscardableMemoryPool::Create(SK_DEFAULT_GLOBAL_DISCARDABLE_MEMORY_POOL_SIZE,
-                                                 &gMutex);
-    });
+    static SkBaseMutex gMutex;
+    // Intentionally leak this global pool.
+    static SkDiscardableMemoryPool* global =
+            new DiscardableMemoryPool(SK_DEFAULT_GLOBAL_DISCARDABLE_MEMORY_POOL_SIZE, &gMutex);
     return global;
 }
diff --git a/src/lazy/SkDiscardableMemoryPool.h b/src/lazy/SkDiscardableMemoryPool.h
index 92ba48bcb4..f7beaad581 100644
--- a/src/lazy/SkDiscardableMemoryPool.h
+++ b/src/lazy/SkDiscardableMemoryPool.h
@@ -52,8 +52,7 @@ public:
      *  the pool works.
      *  Without mutex, will be not be thread safe.
      */
-    static SkDiscardableMemoryPool* Create(
-            size_t size, SkBaseMutex* mutex = nullptr);
+    static sk_sp<SkDiscardableMemoryPool> Make(size_t size, SkBaseMutex* mutex = nullptr);
 };
 
 /**