Make SkBitmapCache remove invalid bitmaps from the SkResourceCache.

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"
@@ skipping 268 matching lines @@
     // We're under our lock, and we're the only possible mutator, so unconsting is fine.
     const_cast<Rec*>(rec)->fLockCount -= 1;
 
     // we may have been over-budget, but now have released something, so check
     // if we should purge.
     if (0 == rec->fLockCount) {
         this->purgeAsNeeded();
     }
 }
 
+void SkResourceCache::remove(SkResourceCache::ID id) {

[reed1, 2014/09/11 13:40:30]

I think we can just have remove(), and move the impl into there.

[reed1, 2014/09/11 14:33:32]

Additionally, we probably need to actually check that the lock-count is 0,
rather than assert.

Since this can be called arbitrarily by the client, they may decide to remove
it, but its possible another client could also have a "lock" on the record at
the time.

[danakj, 2014/09/11 14:42:29]

IIUC you're suggesting that Remove() do the cast from ID to Rec* and it call
remove() with the Rec*. Sure I will do that.

[danakj, 2014/09/11 14:42:30]

I considered that, but then I ended up with "marking it for delete" and then
every time purgeIfNeeded() ran it would have to look through the whole list
looking for the marked one (or keep a secondary list).

It seemed like a lot of complication with no existing use case?

+    SkASSERT(id);
+
+#ifdef SK_DEBUG
+    {
+        bool found = false;
+        Rec* rec = fHead;
+        while (rec != NULL) {
+            if (rec == id) {
+                found = true;
+                break;
+            }
+            rec = rec->fNext;
+        }
+        SkASSERT(found);
+    }
+#endif
+    const Rec* rec = id;
+    SkASSERT(0 == rec->fLockCount);
+    this->purgeRec(const_cast<Rec*>(rec));
+}
+
+void SkResourceCache::purgeRec(Rec* rec) {
+    SkASSERT(0 == rec->fLockCount);
+
+    size_t used = rec->bytesUsed();
+    SkASSERT(used <= fTotalBytesUsed);
+
+    this->detach(rec);
+#ifdef USE_HASH
+    fHash->remove(rec->getKey());
+#endif
+
+    SkDELETE(rec);
+
+    fTotalBytesUsed -= used;
+    fCount -= 1;
+}
+
 void SkResourceCache::purgeAsNeeded() {
     size_t byteLimit;
     int    countLimit;
 
     if (fDiscardableFactory) {
         countLimit = SK_DISCARDABLEMEMORY_SCALEDIMAGECACHE_COUNT_LIMIT;
         byteLimit = SK_MaxU32;  // no limit based on bytes
     } else {
         countLimit = SK_MaxS32; // no limit based on count
         byteLimit = fTotalByteLimit;
     }
 
-    size_t bytesUsed = fTotalBytesUsed;
-    int    countUsed = fCount;
-
     Rec* rec = fTail;
     while (rec) {
-        if (bytesUsed < byteLimit && countUsed < countLimit) {
+        if (fTotalBytesUsed < byteLimit && fCount < countLimit) {
             break;
         }
 
         Rec* prev = rec->fPrev;
         if (0 == rec->fLockCount) {
-            size_t used = rec->bytesUsed();
-            SkASSERT(used <= bytesUsed);
-            this->detach(rec);
-#ifdef USE_HASH
-            fHash->remove(rec->getKey());
-#endif
-
-            SkDELETE(rec);
-
-            bytesUsed -= used;
-            countUsed -= 1;
+            purgeRec(rec);
         }
         rec = prev;
     }
-
-    fTotalBytesUsed = bytesUsed;
-    fCount = countUsed;
 }
 
 size_t SkResourceCache::setTotalByteLimit(size_t newLimit) {
     size_t prevLimit = fTotalByteLimit;
     fTotalByteLimit = newLimit;
     if (newLimit < prevLimit) {
         this->purgeAsNeeded();
     }
     return prevLimit;
 }
@@ skipping 160 matching lines @@
     return gResourceCache;
 }
 
 void SkResourceCache::Unlock(SkResourceCache::ID id) {
     SkAutoMutexAcquire am(gMutex);
     get_cache()->unlock(id);
 
 //    get_cache()->dump();
 }
 
+void SkResourceCache::Remove(SkResourceCache::ID id) {
+    SkAutoMutexAcquire am(gMutex);
+    get_cache()->remove(id);
+}
+
 size_t SkResourceCache::GetTotalBytesUsed() {
     SkAutoMutexAcquire am(gMutex);
     return get_cache()->getTotalBytesUsed();
 }
 
 size_t SkResourceCache::GetTotalByteLimit() {
     SkAutoMutexAcquire am(gMutex);
     return get_cache()->getTotalByteLimit();
 }
 
@@ skipping 54 matching lines @@
 }
 
 size_t SkGraphics::GetResourceCacheSingleAllocationByteLimit() {
     return SkResourceCache::GetSingleAllocationByteLimit();
 }
 
 size_t SkGraphics::SetResourceCacheSingleAllocationByteLimit(size_t newLimit) {
     return SkResourceCache::SetSingleAllocationByteLimit(newLimit);
 }