Improvements/additions to SkImageCache/SkLazyPixelRef.

src/lazy/SkLruImageCache.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 "SkLruImageCache.h"
 
 static intptr_t NextGenerationID() {
@@ skipping 56 matching lines @@
 #endif
         SkDELETE(pixels);
         pixels = prev;
     }
 #ifdef SK_DEBUG
     SkASSERT(fRamUsed == 0);
 #endif
 }
 
 #ifdef SK_DEBUG
-SkImageCache::CacheStatus SkLruImageCache::getCacheStatus(intptr_t ID) const {
+SkImageCache::PinStatus SkLruImageCache::getPinStatus(intptr_t ID) const {
     SkAutoMutexAcquire ac(&fMutex);
     CachedPixels* pixels = this->findByID(ID);
     if (NULL == pixels) {
-        return SkImageCache::kThrownAway_CacheStatus;
+        return SkImageCache::kThrownAway_PinStatus;
     }
     if (pixels->isLocked()) {
-        return SkImageCache::kPinned_CacheStatus;
+        return SkImageCache::kPinned_PinStatus;
     }
-    return SkImageCache::kUnpinned_CacheStatus;
+    return SkImageCache::kNeedsPin_PinStatus;
+}
+
+void SkLruImageCache::purgeAllCaches() {
+    SkAutoMutexAcquire ac(&fMutex);
+    this->purgeTilAtOrBelow(0);
 }
 #endif
 
 size_t SkLruImageCache::setImageCacheLimit(size_t newLimit) {
     size_t oldLimit = fRamBudget;
     SkAutoMutexAcquire ac(&fMutex);
     fRamBudget = newLimit;
     this->purgeIfNeeded();
     return oldLimit;
 }
 
 void* SkLruImageCache::allocAndPinCache(size_t bytes, intptr_t* ID) {
     SkAutoMutexAcquire ac(&fMutex);
     CachedPixels* pixels = SkNEW_ARGS(CachedPixels, (bytes));
     if (ID != NULL) {
         *ID = pixels->getID();
     }
     pixels->lock();
     fRamUsed += bytes;
     fLRU.addToHead(pixels);
     this->purgeIfNeeded();
     return pixels->getData();
 }
 
-void* SkLruImageCache::pinCache(intptr_t ID) {
+void* SkLruImageCache::pinCache(intptr_t ID, SkImageCache::PurgeStatus* status) {
     SkASSERT(ID != SkImageCache::UNINITIALIZED_ID);
     SkAutoMutexAcquire ac(&fMutex);
     CachedPixels* pixels = this->findByID(ID);
     if (NULL == pixels) {
         return NULL;
     }
     if (pixels != fLRU.head()) {
         fLRU.remove(pixels);
         fLRU.addToHead(pixels);
     }
+    SkASSERT(status != NULL);
+    // This cache will never return pinned memory whose data has been overwritten.
+    *status = SkImageCache::kNotPurged_PurgeStatus;
     pixels->lock();
     return pixels->getData();
 }
 
 void SkLruImageCache::releaseCache(intptr_t ID) {
     SkASSERT(ID != SkImageCache::UNINITIALIZED_ID);
     SkAutoMutexAcquire ac(&fMutex);
     CachedPixels* pixels = this->findByID(ID);
     SkASSERT(pixels != NULL);
     pixels->unlock();
@@ skipping 53 matching lines @@
         CachedPixels* pixels = iter.init(fLRU, Iter::kTail_IterStart);
         while (pixels != NULL && fRamUsed > limit) {
             CachedPixels* prev = iter.prev();
             if (!pixels->isLocked()) {
                 this->removePixels(pixels);
             }
             pixels = prev;
         }
     }
 }