detect if the scaledimagecache returns a purged bitmap

src/core/SkScaledImageCache.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 "SkScaledImageCache.h"
 #include "SkMipMap.h"
 #include "SkOnce.h"
@@ skipping 221 matching lines @@
     SkDELETE(fDM);
 }
 
 void* SkOneShotDiscardablePixelRef::onLockPixels(SkColorTable** ctable) {
     if (fFirstTime) {
         // we're already locked
         fFirstTime = false;
         return fDM->data();
     }
 
-    SkASSERT(!fIsLocked);
-    fIsLocked = fDM->lock();
-    return fIsLocked ? fDM->data() : NULL;
+    // A previous call to onUnlock may have deleted our DM, so check for that
+    if (NULL == fDM) {
+        return NULL;
+    }
+
+    if (!fDM->lock()) {
+        // since it failed, we delete it now, to free-up the resource
+        delete fDM;
+        fDM = NULL;
+        return NULL;
+    }
+    return fDM->data();
 }
 
 void SkOneShotDiscardablePixelRef::onUnlockPixels() {
     SkASSERT(!fFirstTime);
     if (fIsLocked) {
         fIsLocked = false;
         fDM->unlock();
     }
 }
 
@@ skipping 351 matching lines @@
     fHead = rec;
     if (!fTail) {
         fTail = rec;
     }
     fBytesUsed += rec->bytesUsed();
     fCount += 1;
 
     this->validate();
 }
 
+///////////////////////////////////////////////////////////////////////////////
+
 #ifdef SK_DEBUG
 void SkScaledImageCache::validate() const {
     if (NULL == fHead) {
         SkASSERT(NULL == fTail);
         SkASSERT(0 == fBytesUsed);
         return;
     }
 
     if (fHead == fTail) {
         SkASSERT(NULL == fHead->fPrev);
@@ skipping 25 matching lines @@
         SkASSERT(used >= rec->bytesUsed());
         used -= rec->bytesUsed();
         rec = rec->fPrev;
     }
 
     SkASSERT(0 == count);
     SkASSERT(0 == used);
 }
 #endif
 
+void SkScaledImageCache::dump() const {
+    this->validate();
+
+    const Rec* rec = fHead;
+    int locked = 0;
+    while (rec) {
+        locked += rec->fLockCount > 0;
+        rec = rec->fNext;
+    }
+
+    SkDebugf("SkScaledImageCache: count=%d bytes=%d locked=%d %s\n",
+             fCount, fBytesUsed, locked,
+             fDiscardableFactory ? "discardable" : "malloc");
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "SkThread.h"
 
 SK_DECLARE_STATIC_MUTEX(gMutex);
 
 static void create_cache(SkScaledImageCache** cache) {
 #ifdef SK_USE_DISCARDABLE_SCALEDIMAGECACHE
     *cache = SkNEW_ARGS(SkScaledImageCache, (SkDiscardableMemory::Create));
 #else
@@ skipping 52 matching lines @@
 }
 
 SkScaledImageCache::ID* SkScaledImageCache::AddAndLockMip(const SkBitmap& orig,
                                                           const SkMipMap* mip) {
     SkAutoMutexAcquire am(gMutex);
     return get_cache()->addAndLockMip(orig, mip);
 }
 
 void SkScaledImageCache::Unlock(SkScaledImageCache::ID* id) {
     SkAutoMutexAcquire am(gMutex);
-    return get_cache()->unlock(id);
+    get_cache()->unlock(id);
+
+//    get_cache()->dump();
 }
 
 size_t SkScaledImageCache::GetBytesUsed() {
     SkAutoMutexAcquire am(gMutex);
     return get_cache()->getBytesUsed();
 }
 
 size_t SkScaledImageCache::GetByteLimit() {
     SkAutoMutexAcquire am(gMutex);
     return get_cache()->getByteLimit();
 }
 
 size_t SkScaledImageCache::SetByteLimit(size_t newLimit) {
     SkAutoMutexAcquire am(gMutex);
     return get_cache()->setByteLimit(newLimit);
 }
 
 SkBitmap::Allocator* SkScaledImageCache::GetAllocator() {
     SkAutoMutexAcquire am(gMutex);
     return get_cache()->allocator();
 }
 
+void SkScaledImageCache::Dump() {
+    SkAutoMutexAcquire am(gMutex);
+    get_cache()->dump();
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "SkGraphics.h"
 
 size_t SkGraphics::GetImageCacheBytesUsed() {
     return SkScaledImageCache::GetBytesUsed();
 }
 
 size_t SkGraphics::GetImageCacheByteLimit() {
     return SkScaledImageCache::GetByteLimit();
 }
 
 size_t SkGraphics::SetImageCacheByteLimit(size_t newLimit) {
     return SkScaledImageCache::SetByteLimit(newLimit);
 }