Alter resource cache and GrContext to (optionally) never reuse a scratch texture

src/gpu/GrResourceCache.cpp

 
 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 
@@ skipping 70 matching lines @@
         fCache.remove(entry->fKey, entry);
 
         // remove from our llist
         this->internalDetach(entry);
 
         delete entry;
     }
 }
 
 void GrResourceCache::getLimits(int* maxResources, size_t* maxResourceBytes) const{
-    if (maxResources) {
+    if (NULL != maxResources) {
         *maxResources = fMaxCount;
     }
-    if (maxResourceBytes) {
+    if (NULL != maxResourceBytes) {
         *maxResourceBytes = fMaxBytes;
     }
 }
 
 void GrResourceCache::setLimits(int maxResources, size_t maxResourceBytes) {
     bool smaller = (maxResources < fMaxCount) || (maxResourceBytes < fMaxBytes);
 
     fMaxCount = maxResources;
     fMaxBytes = maxResourceBytes;
 
@@ skipping 84 matching lines @@
         this->makeExclusive(entry);
     } else {
         // Make this resource MRU
         this->internalDetach(entry);
         this->attachToHead(entry);
     }
 
     return entry->fResource;
 }
 
-bool GrResourceCache::hasKey(const GrResourceKey& key) const {
-    return NULL != fCache.find(key);
-}
-
 void GrResourceCache::addResource(const GrResourceKey& key,
                                   GrResource* resource,
                                   uint32_t ownershipFlags) {
     GrAssert(NULL == resource->getCacheEntry());
     // we don't expect to create new resources during a purge. In theory
     // this could cause purgeAsNeeded() into an infinite loop (e.g.
     // each resource destroyed creates and locks 2 resources and
     // unlocks 1 thereby causing a new purge).
     GrAssert(!fPurging);
     GrAutoResourceCacheValidate atcv(this);
@@ skipping 82 matching lines @@
         // Despite the purge we're still over budget. See if Ganesh can
         // release some resources and purge again.
         if ((*fOverbudgetCB)(fOverbudgetData)) {
             this->internalPurge(extraCount, extraBytes);
         }
     }
 
     fPurging = false;
 }
 
+void GrResourceCache::deleteResource(GrResourceEntry* entry) {
+    GrAssert(1 == entry->fResource->getRefCnt());
+
+    // remove from our cache
+    fCache.remove(entry->key(), entry);
+
+    // remove from our llist
+    this->internalDetach(entry);
+    delete entry;
+}
+
 void GrResourceCache::internalPurge(int extraCount, size_t extraBytes) {
     SkASSERT(fPurging);
 
     bool withinBudget = false;
     bool changed = false;
 
     // The purging process is repeated several times since one pass
     // may free up other resources
     do {
         EntryList::Iter iter;
@@ skipping 11 matching lines @@
 
             if ((fEntryCount+extraCount) <= fMaxCount &&
                 (fEntryBytes+extraBytes) <= fMaxBytes) {
                 withinBudget = true;
                 break;
             }
 
             GrResourceEntry* prev = iter.prev();
             if (1 == entry->fResource->getRefCnt()) {
                 changed = true;
-
-                // remove from our cache
-                fCache.remove(entry->key(), entry);
-
-                // remove from our llist
-                this->internalDetach(entry);
-                delete entry;
+                this->deleteResource(entry);
             }
             entry = prev;
         }
     } while (!withinBudget && changed);
 }
 
 void GrResourceCache::purgeAllUnlocked() {
     GrAutoResourceCacheValidate atcv(this);
 
     // we can have one GrResource holding a lock on another
@@ skipping 111 matching lines @@
                 fEntryBytes, fHighWaterEntryBytes);
     SkDebugf("\t\tDetached Entry Count: current %d high %d\n",
                 fClientDetachedCount, fHighWaterClientDetachedCount);
     SkDebugf("\t\tDetached Bytes: current %d high %d\n",
                 fClientDetachedBytes, fHighWaterClientDetachedBytes);
 }
 
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////