Add purgeAsNeeded calls before addResource calls

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 258 matching lines @@
 
 /**
  * Destroying a resource may potentially trigger the unlock of additional
  * resources which in turn will trigger a nested purge. We block the nested
  * purge using the fPurging variable. However, the initial purge will keep
  * looping until either all resources in the cache are unlocked or we've met
  * the budget. There is an assertion in createAndLock to check against a
  * resource's destructor inserting new resources into the cache. If these
  * new resources were unlocked before purgeAsNeeded completed it could
  * potentially make purgeAsNeeded loop infinitely.
+ *
+ * extraCount and extraBytes are added to the current resource totals to account
+ * for incoming resources (e.g., GrContext is about to add 10MB split between
+ * 10 textures).
  */
-void GrResourceCache::purgeAsNeeded() {
+void GrResourceCache::purgeAsNeeded(int extraCount, size_t extraBytes) {
     if (fPurging) {
         return;
     }
 
     fPurging = true;
 
-    this->internalPurge();
-    if ((fEntryCount > fMaxCount || fEntryBytes > fMaxBytes) &&
+    this->internalPurge(extraCount, extraBytes);
+    if (((fEntryCount+extraCount) > fMaxCount || 
+        (fEntryBytes+extraBytes) > fMaxBytes) &&
         NULL != fOverbudgetCB) {
         // Despite the purge we're still over budget. See if Ganesh can
         // release some resources and purge again.
         if ((*fOverbudgetCB)(fOverbudgetData)) {
-            this->internalPurge();
+            this->internalPurge(extraCount, extraBytes);
         }
     }
 
     fPurging = false;
 }
 
-void GrResourceCache::internalPurge() {
+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;
 
         changed = false;
 
         // Note: the following code relies on the fact that the
         // doubly linked list doesn't invalidate its data/pointers
         // outside of the specific area where a deletion occurs (e.g.,
         // in internalDetach)
         GrResourceEntry* entry = iter.init(fList, EntryList::Iter::kTail_IterStart);
 
         while (NULL != entry) {
             GrAutoResourceCacheValidate atcv(this);
 
-            if (fEntryCount <= fMaxCount && fEntryBytes <= fMaxBytes) {
+            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);
@@ skipping 125 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
 
 ///////////////////////////////////////////////////////////////////////////////