Improvements/additions to SkImageCache/SkLazyPixelRef.

src/ports/SkAshmemImageCache.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 "SkAshmemImageCache.h"
 #include "SkThread.h"
 
@@ skipping 16 matching lines @@
     return &gCache;
 }
 
 #ifdef SK_DEBUG
 SkAshmemImageCache::~SkAshmemImageCache() {
     SkASSERT(fRecs.count() == 0);
 }
 #endif
 
 // ashmem likes lengths on page boundaries.
-static size_t roundToPageSize(size_t size) {
+static size_t round_to_page_size(size_t size) {
     const size_t mask = getpagesize() - 1;
     size_t newSize = (size + mask) & ~mask;
     return newSize;
 }
 
 void* SkAshmemImageCache::allocAndPinCache(size_t bytes, intptr_t* ID) {
     SkASSERT(ID != NULL);
 
     SkAutoMutexAcquire ac(&gAshmemMutex);
 
-    if (*ID != SkImageCache::UNINITIALIZED_ID) {
-        // This rec was previously allocated, but pinCache subsequently
-        // failed.
-        AshmemRec* pRec = reinterpret_cast<AshmemRec*>(*ID);
-        SkASSERT(roundToPageSize(bytes) == pRec->fSize);
-        SkASSERT(pRec->fFD != -1);
-        (void) ashmem_pin_region(pRec->fFD, 0, 0);
-#ifdef SK_DEBUG
-        pRec->fPinned = true;
-#endif
-        return pRec->fAddr;
-    }
-
     AshmemRec rec;
-    rec.fSize = roundToPageSize(bytes);
+    rec.fSize = round_to_page_size(bytes);
 
     rec.fFD = ashmem_create_region(NULL, rec.fSize);
     if (-1 == rec.fFD) {
         SkDebugf("ashmem_create_region failed\n");
         return NULL;
     }
     int err = ashmem_set_prot_region(rec.fFD, PROT_READ | PROT_WRITE);
     if (err != 0) {
         SkDebugf("ashmem_set_prot_region failed\n");
         close(rec.fFD);
@@ skipping 12 matching lines @@
     // In release mode, we do not keep a pointer to this object. It will be destroyed
     // either when pinCache returns NULL or when throwAwayCache is called.
     AshmemRec* pRec = SkNEW_ARGS(AshmemRec, (rec));
     *ID = reinterpret_cast<intptr_t>(pRec);
 #ifdef SK_DEBUG
     this->appendRec(pRec);
 #endif
     return rec.fAddr;
 }
 
-void* SkAshmemImageCache::pinCache(intptr_t ID) {
+void* SkAshmemImageCache::pinCache(intptr_t ID, PurgeStatus* status) {
+    SkASSERT(ID != SkImageCache::UNINITIALIZED_ID);
+    SkASSERT(status != NULL);
     SkAutoMutexAcquire ac(&gAshmemMutex);
     AshmemRec* rec = reinterpret_cast<AshmemRec*>(ID);
     const int fd = rec->fFD;
     int pin = ashmem_pin_region(fd, 0, 0);
     if (ASHMEM_NOT_PURGED == pin) {
+        *status = SkImageCache::kNotPurged_PurgeStatus;
+    } else if (ASHMEM_WAS_PURGED == pin) {
+        *status = SkImageCache::kPurged_PurgeStatus;
+    } else {
+        this->throwAwayCacheInternal(ID);
+        return NULL;
+    }
 #ifdef SK_DEBUG
-        rec->fPinned = true;
+    rec->fPinned = true;
 #endif
-        return rec->fAddr;
-    }
-    ashmem_unpin_region(fd, 0, 0);
-    return NULL;
+    return rec->fAddr;
 }
 
 void SkAshmemImageCache::releaseCache(intptr_t ID) {
     SkAutoMutexAcquire ac(&gAshmemMutex);
     AshmemRec* rec = reinterpret_cast<AshmemRec*>(ID);
     ashmem_unpin_region(rec->fFD, 0, 0);
 #ifdef SK_DEBUG
     rec->fPinned = false;
 #endif
 }
 
 void SkAshmemImageCache::throwAwayCache(intptr_t ID) {
     SkAutoMutexAcquire ac(&gAshmemMutex);
+    this->throwAwayCacheInternal(ID);
+}
+
+void SkAshmemImageCache::throwAwayCacheInternal(intptr_t ID) {
+    if (SkImageCache::UNINITIALIZED_ID == ID) {
+        return;
+    }
     AshmemRec* rec = reinterpret_cast<AshmemRec*>(ID);
-    munmap(rec->fAddr, rec->fSize);
-    close(rec->fFD);
+    if (rec->fFD != -1) {
+        munmap(rec->fAddr, rec->fSize);
+        close(rec->fFD);
+    }
 #ifdef SK_DEBUG
     SkASSERT(!rec->fPinned);
     int index = this->findRec(rec);
     SkASSERT(index >= 0);
     fRecs.remove(index);
 #endif
     SkDELETE(rec);
 }
 
 #ifdef SK_DEBUG
 void SkAshmemImageCache::appendRec(SkAshmemImageCache::AshmemRec* rec) {
     int index = this->findRec(rec);
     // Should not already exist.
     SkASSERT(index < 0);
     fRecs.insert(~index, 1, &rec);
 }
 
 int SkAshmemImageCache::AshmemRec::Compare(const SkAshmemImageCache::AshmemRec* a,
                                            const SkAshmemImageCache::AshmemRec* b) {
     return reinterpret_cast<intptr_t>(a) - reinterpret_cast<intptr_t>(b);
 }
 
 int SkAshmemImageCache::findRec(const SkAshmemImageCache::AshmemRec* rec) const {
     return SkTSearch<AshmemRec>((const AshmemRec**)fRecs.begin(), fRecs.count(), rec,
                                 sizeof(intptr_t), AshmemRec::Compare);
 }
 
-SkImageCache::CacheStatus SkAshmemImageCache::getCacheStatus(intptr_t ID) const {
+SkImageCache::PinStatus SkAshmemImageCache::getPinStatus(intptr_t ID) const {
     SkAutoMutexAcquire ac(&gAshmemMutex);
     AshmemRec* rec = reinterpret_cast<AshmemRec*>(ID);
+    // findRec searches purely based on the value of ID. If rec has already been deleted, it will
+    // not be in the array. rec will only be accessed if it has not been deleted.
     int index = this->findRec(rec);
     if (index < 0) {
-        return SkImageCache::kThrownAway_CacheStatus;
+        return SkImageCache::kThrownAway_PinStatus;
     }
-    return rec->fPinned ? SkImageCache::kPinned_CacheStatus
-                        : SkImageCache::kUnpinned_CacheStatus;
+    return rec->fPinned ? SkImageCache::kPinned_PinStatus
+                        : SkImageCache::kNeedsPin_PinStatus;
+}
+
+void SkAshmemImageCache::purgeAllCaches() {
+    SkAutoMutexAcquire ac(&gAshmemMutex);
+    // FIXME: How to use the ashmem API to do this?
+    for (int i = 0; i < fRecs.count(); i++) {
+        AshmemRec* rec = fRecs.getAt(i);
+        if (!rec->fPinned) {
+            munmap(rec->fAddr, rec->fSize);
+            close(rec->fFD);
+            rec->fFD = -1;
+            rec->fAddr = NULL;
+            rec->fSize = 0;
+        }
+    }
 }
 #endif