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 "SkMipMap.h"
 #include "SkPixelRef.h"
 
 #include <stddef.h>
 
 // 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 kHashedLocal32s = (sizeof(fSharedID) + 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 = sharedID;
     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) {
     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;
         }
     }
@@ skipping 74 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) {
+            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) {
@@ skipping 137 matching lines @@
     if (NULL == fDiscardableFactory) {
         if (0 == limit) {
             limit = fTotalByteLimit;
         } else {
             limit = SkTMin(limit, fTotalByteLimit);
         }
     }
     return limit;
 }
 
+void SkResourceCache::checkMessages() {
+    SkTDArray<uint64_t>* msgs = DetachPurgeMessages();
+    if (msgs) {
+        for (int i = 0; i < msgs->count(); ++i) {
+            this->purgeSharedID(msgs->getAt(i));
+        }
+        delete msgs;
+    }
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
 #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 38 matching lines @@
     return get_cache()->discardableFactory();
 }
 
 SkBitmap::Allocator* SkResourceCache::GetAllocator() {
     SkAutoMutexAcquire am(gMutex);
     return get_cache()->allocator();
 }
 
 SkCachedData* SkResourceCache::NewCachedData(size_t bytes) {
     SkAutoMutexAcquire am(gMutex);
+    get_cache()->checkMessages();
     return get_cache()->newCachedData(bytes);
 }
 
 void SkResourceCache::Dump() {
     SkAutoMutexAcquire am(gMutex);
     get_cache()->dump();
 }
 
 size_t SkResourceCache::SetSingleAllocationByteLimit(size_t size) {
     SkAutoMutexAcquire am(gMutex);
     return get_cache()->setSingleAllocationByteLimit(size);
 }
 
 size_t SkResourceCache::GetSingleAllocationByteLimit() {
     SkAutoMutexAcquire am(gMutex);
     return get_cache()->getSingleAllocationByteLimit();
 }
 
 size_t SkResourceCache::GetEffectiveSingleAllocationByteLimit() {
     SkAutoMutexAcquire am(gMutex);
     return get_cache()->getEffectiveSingleAllocationByteLimit();
 }
 
+void SkResourceCache::PurgeSharedID(uint64_t sharedID) {
+    if (sharedID) {
+        SkAutoMutexAcquire am(gMutex);
+        return get_cache()->purgeSharedID(sharedID);
+    }
+}
+
 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);
+    get_cache()->checkMessages();
     return get_cache()->find(key, visitor, context);
 }
 
 void SkResourceCache::Add(Rec* rec) {
     SkAutoMutexAcquire am(gMutex);
+    get_cache()->checkMessages();
     get_cache()->add(rec);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
+static SkTDArray<uint64_t>* gPurgePayloads;
+static SkMutex gPuragePayloadMutex;
+
+void SkResourceCache::PostPurgeSharedID(uint64_t sharedID) {
+    if (sharedID) {
+        SkAutoMutexAcquire am(gPuragePayloadMutex);
+        if (NULL == gPurgePayloads) {
+            gPurgePayloads = new SkTDArray<uint64_t>;
+        }
+        *gPurgePayloads->append() = sharedID;
+    }
+}
+
+SkTDArray<uint64_t>* SkResourceCache::DetachPurgeMessages() {
+    SkAutoMutexAcquire am(gPuragePayloadMutex);
+    SkTDArray<uint64_t>* payloads = gPurgePayloads;
+    gPurgePayloads = NULL;
+    return payloads;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
 #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();
 }