Notify resource caches when pixelref genID goes stale

src/core/SkResourceCache.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkChecksum.h"
-#include "SkResourceCache.h"
+#include "SkMessageBus.h"
 #include "SkMipMap.h"
 #include "SkPixelRef.h"
+#include "SkResourceCache.h"
 
 #include <stddef.h>
 
+DECLARE_SKMESSAGEBUS_MESSAGE(SkResourceCache::PurgeSharedIDMessage)
+
 // This can be defined by the caller's build system
 //#define SK_USE_DISCARDABLE_SCALEDIMAGECACHE
 
 #ifndef SK_DISCARDABLEMEMORY_SCALEDIMAGECACHE_COUNT_LIMIT
 #   define SK_DISCARDABLEMEMORY_SCALEDIMAGECACHE_COUNT_LIMIT   1024
 #endif
 
 #ifndef SK_DEFAULT_IMAGE_CACHE_LIMIT
     #define SK_DEFAULT_IMAGE_CACHE_LIMIT     (2 * 1024 * 1024)
 #endif
 
-void SkResourceCache::Key::init(void* nameSpace, size_t length) {
+void SkResourceCache::Key::init(void* nameSpace, uint64_t sharedID, size_t length) {
     SkASSERT(SkAlign4(length) == length);
 
     // fCount32 and fHash are not hashed
-    static const int kUnhashedLocal32s = 2;
-    static const int kLocal32s = kUnhashedLocal32s + (sizeof(fNamespace) >> 2);
+    static const int kUnhashedLocal32s = 2; // fCache32 + fHash
+    static const int kSharedIDLocal32s = 2; // fSharedID_lo + fSharedID_hi
+    static const int kHashedLocal32s = kSharedIDLocal32s + (sizeof(fNamespace) >> 2);
+    static const int kLocal32s = kUnhashedLocal32s + kHashedLocal32s;
 
     SK_COMPILE_ASSERT(sizeof(Key) == (kLocal32s << 2), unaccounted_key_locals);
     SK_COMPILE_ASSERT(sizeof(Key) == offsetof(Key, fNamespace) + sizeof(fNamespace),
                       namespace_field_must_be_last);
 
     fCount32 = SkToS32(kLocal32s + (length >> 2));
+    fSharedID_lo = (uint32_t)sharedID;
+    fSharedID_hi = (uint32_t)(sharedID >> 32);
     fNamespace = nameSpace;
     // skip unhashed fields when computing the murmur
     fHash = SkChecksum::Murmur3(this->as32() + kUnhashedLocal32s,
                                 (fCount32 - kUnhashedLocal32s) << 2);
 }
 
 #include "SkTDynamicHash.h"
 
 class SkResourceCache::Hash :
     public SkTDynamicHash<SkResourceCache::Rec, SkResourceCache::Key> {};
@@ skipping 144 matching lines @@
     while (rec) {
         Rec* next = rec->fNext;
         SkDELETE(rec);
         rec = next;
     }
     delete fHash;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
-bool SkResourceCache::find(const Key& key, VisitorProc visitor, void* context) {
+bool SkResourceCache::find(const Key& key, FindVisitor visitor, void* context) {
+    this->checkMessages();
+
     Rec* rec = fHash->find(key);
     if (rec) {
         if (visitor(*rec, context)) {
             this->moveToHead(rec);  // for our LRU
             return true;
         } else {
             this->remove(rec);  // stale
             return false;
         }
     }
     return false;
 }
 
 static void make_size_str(size_t size, SkString* str) {
     const char suffix[] = { 'b', 'k', 'm', 'g', 't', 0 };
     int i = 0;
     while (suffix[i] && (size > 1024)) {
         i += 1;
         size >>= 10;
     }
     str->printf("%zu%c", size, suffix[i]);
 }
 
 static bool gDumpCacheTransactions;
 
 void SkResourceCache::add(Rec* rec) {
+    this->checkMessages();
+    
     SkASSERT(rec);
     // See if we already have this key (racy inserts, etc.)
     Rec* existing = fHash->find(rec->getKey());
     if (existing) {
         SkDELETE(rec);
         return;
     }
     
     this->addToHead(rec);
     fHash->add(rec);
@@ skipping 48 matching lines @@
         if (!forcePurge && fTotalBytesUsed < byteLimit && fCount < countLimit) {
             break;
         }
 
         Rec* prev = rec->fPrev;
         this->remove(rec);
         rec = prev;
     }
 }
 
+void SkResourceCache::purgeSharedID(uint64_t sharedID) {
+    if (0 == sharedID) {
+        return;
+    }
+
+    // go backwards, just like purgeAsNeeded, just to make the code similar.
+    // could iterate either direction and still be correct.
+    Rec* rec = fTail;
+    while (rec) {
+        Rec* prev = rec->fPrev;
+        if (rec->getKey().getSharedID() == sharedID) {
+//            SkDebugf("purgeSharedID id=%llx rec=%p\n", sharedID, rec);
+            this->remove(rec);
+        }
+        rec = prev;
+    }
+}
+
 size_t SkResourceCache::setTotalByteLimit(size_t newLimit) {
     size_t prevLimit = fTotalByteLimit;
     fTotalByteLimit = newLimit;
     if (newLimit < prevLimit) {
         this->purgeAsNeeded();
     }
     return prevLimit;
 }
 
 SkCachedData* SkResourceCache::newCachedData(size_t bytes) {
+    this->checkMessages();
+    
     if (fDiscardableFactory) {
         SkDiscardableMemory* dm = fDiscardableFactory(bytes);
         return dm ? SkNEW_ARGS(SkCachedData, (bytes, dm)) : NULL;
     } else {
         return SkNEW_ARGS(SkCachedData, (sk_malloc_throw(bytes), bytes));
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ skipping 127 matching lines @@
     if (NULL == fDiscardableFactory) {
         if (0 == limit) {
             limit = fTotalByteLimit;
         } else {
             limit = SkTMin(limit, fTotalByteLimit);
         }
     }
     return limit;
 }
 
+void SkResourceCache::checkMessages() {
+    SkTArray<PurgeSharedIDMessage> msgs;
+    fPurgeSharedIDInbox.poll(&msgs);
+    for (int i = 0; i < msgs.count(); ++i) {
+        this->purgeSharedID(msgs[i].fSharedID);
+    }
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "SkThread.h"
 
 SK_DECLARE_STATIC_MUTEX(gMutex);
 static SkResourceCache* gResourceCache = NULL;
 static void cleanup_gResourceCache() {
     // We'll clean this up in our own tests, but disable for clients.
     // Chrome seems to have funky multi-process things going on in unit tests that
     // makes this unsafe to delete when the main process atexit()s.
@@ skipping 66 matching lines @@
 size_t SkResourceCache::GetEffectiveSingleAllocationByteLimit() {
     SkAutoMutexAcquire am(gMutex);
     return get_cache()->getEffectiveSingleAllocationByteLimit();
 }
 
 void SkResourceCache::PurgeAll() {
     SkAutoMutexAcquire am(gMutex);
     return get_cache()->purgeAll();
 }
 
-bool SkResourceCache::Find(const Key& key, VisitorProc visitor, void* context) {
+bool SkResourceCache::Find(const Key& key, FindVisitor visitor, void* context) {
     SkAutoMutexAcquire am(gMutex);
     return get_cache()->find(key, visitor, context);
 }
 
 void SkResourceCache::Add(Rec* rec) {
     SkAutoMutexAcquire am(gMutex);
     get_cache()->add(rec);
 }
 
+void SkResourceCache::PostPurgeSharedID(uint64_t sharedID) {
+    if (sharedID) {
+        SkMessageBus<PurgeSharedIDMessage>::Post(PurgeSharedIDMessage(sharedID));
+    }
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "SkGraphics.h"
 
 size_t SkGraphics::GetResourceCacheTotalBytesUsed() {
     return SkResourceCache::GetTotalBytesUsed();
 }
 
 size_t SkGraphics::GetResourceCacheTotalByteLimit() {
     return SkResourceCache::GetTotalByteLimit();
 }
 
 size_t SkGraphics::SetResourceCacheTotalByteLimit(size_t newLimit) {
     return SkResourceCache::SetTotalByteLimit(newLimit);
 }
 
 size_t SkGraphics::GetResourceCacheSingleAllocationByteLimit() {
     return SkResourceCache::GetSingleAllocationByteLimit();
 }
 
 size_t SkGraphics::SetResourceCacheSingleAllocationByteLimit(size_t newLimit) {
     return SkResourceCache::SetSingleAllocationByteLimit(newLimit);
 }
 
 void SkGraphics::PurgeResourceCache() {
     return SkResourceCache::PurgeAll();
 }