Make GrResourceCache2 responsible for calling release, abandon, and ~.

src/gpu/GrResourceCache2.cpp

 
 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "GrResourceCache2.h"
@@ skipping 75 matching lines @@
 }
 
 void GrResourceCache2::insertResource(GrGpuResource* resource) {
     AutoValidate av(this);
 
     SkASSERT(resource);
     SkASSERT(!resource->wasDestroyed());
     SkASSERT(!this->isInCache(resource));
     SkASSERT(!fPurging);
     fResources.addToHead(resource);
-    resource->ref();
 
     ++fCount;
     SkDEBUGCODE(fHighWaterCount = SkTMax(fCount, fHighWaterCount));
     fBytes += resource->gpuMemorySize();
     SkDEBUGCODE(fHighWaterBytes = SkTMax(fBytes, fHighWaterBytes));
     if (!resource->cacheAccess().getScratchKey().isNullScratch()) {
         // TODO(bsalomon): Make this assertion possible.
         // SkASSERT(!resource->isWrapped());
         fScratchMap.insert(resource->cacheAccess().getScratchKey(), resource);
     }
@@ skipping 15 matching lines @@
         fContentHash.remove(*contentKey);
     }
 }
 
 void GrResourceCache2::abandonAll() {
     AutoValidate av(this);
 
     SkASSERT(!fPurging);
     while (GrGpuResource* head = fResources.head()) {
         SkASSERT(!head->wasDestroyed());
-        head->abandon();
-        head->unref();
+        head->cacheAccess().abandon();
         // abandon should have already removed this from the list.
         SkASSERT(head != fResources.head());
     }
     SkASSERT(!fScratchMap.count());
     SkASSERT(!fContentHash.count());
     SkASSERT(!fCount);
 }
 
 void GrResourceCache2::releaseAll() {
     AutoValidate av(this);
 
     SkASSERT(!fPurging);
     while (GrGpuResource* head = fResources.head()) {
         SkASSERT(!head->wasDestroyed());
-        head->release();
-        head->unref();
+        head->cacheAccess().release();
         // release should have already removed this from the list.
         SkASSERT(head != fResources.head());
     }
     SkASSERT(!fScratchMap.count());
     SkASSERT(!fCount);
 }
 
 class GrResourceCache2::AvailableForScratchUse {
 public:
     AvailableForScratchUse(bool rejectPendingIO) : fRejectPendingIO(rejectPendingIO) { }
 
     bool operator()(const GrGpuResource* resource) const {
-        if (!resource->reffedOnlyByCache() || !resource->cacheAccess().isScratch()) {
+        if (resource->internalHasRef() || !resource->cacheAccess().isScratch()) {
             return false;
         }
 
         return !fRejectPendingIO || !resource->internalHasPendingIO();
     }
 
 private:
     bool fRejectPendingIO;
 };
 
@@ skipping 44 matching lines @@
 void GrResourceCache2::makeResourceMRU(GrGpuResource* resource) {
     AutoValidate av(this);
 
     SkASSERT(!fPurging);
     SkASSERT(resource);
     SkASSERT(this->isInCache(resource));
     fResources.remove(resource);    
     fResources.addToHead(resource);    
 }
 
-void GrResourceCache2::notifyPurgable(const GrGpuResource* resource) {
+void GrResourceCache2::notifyPurgable(GrGpuResource* resource) {
     SkASSERT(resource);
     SkASSERT(this->isInCache(resource));
     SkASSERT(resource->isPurgable());
 
     // We can't purge if in the middle of purging because purge is iterating. Instead record
     // that additional resources became purgable.
     if (fPurging) {
         fNewlyPurgableResourceWhilePurging = true;
         return;
     }
 
     // Purge the resource if we're over budget
     bool overBudget = fCount > fMaxCount || fBytes > fMaxBytes;
 
-    // We should not be over budget here unless all resources are unpuragble.
-#ifdef SK_DEBUG
-    if (overBudget) {
-        ResourceList::Iter iter;
-        GrGpuResource* r = iter.init(fResources, ResourceList::Iter::kHead_IterStart);
-        for ( ; r; r = iter.next()) {
-            SkASSERT(r == resource || !r->isPurgable());
-        }
-    }
-#endif
-
     // Also purge if the resource has neither a valid scratch key nor a content key.
     bool noKey = !resource->cacheAccess().isScratch() &&
                  (NULL == resource->cacheAccess().getContentKey());
 
     if (overBudget || noKey) {
         SkDEBUGCODE(int beforeCount = fCount;)
-        resource->unref();
-        // We should at least have freed resource. It may have in turn freed other resources.
+        resource->cacheAccess().release();
+        // We should at least free this resource, perhaps dependent resources as well.
         SkASSERT(fCount < beforeCount);
     }
 
     this->validate();
 }
 
 void GrResourceCache2::didChangeGpuMemorySize(const GrGpuResource* resource, size_t oldSize) {
     // SkASSERT(!fPurging); GrPathRange increases size during flush. :(
     SkASSERT(resource);
     SkASSERT(this->isInCache(resource));
@@ skipping 17 matching lines @@
     bool overBudget = true;
     do {
         fNewlyPurgableResourceWhilePurging = false;
         ResourceList::Iter resourceIter;
         GrGpuResource* resource = resourceIter.init(fResources,
                                                     ResourceList::Iter::kTail_IterStart);
 
         while (resource) {
             GrGpuResource* prev = resourceIter.prev();
             if (resource->isPurgable()) {
-                resource->unref();
+                resource->cacheAccess().release();
             }
             resource = prev;
             if (fCount <= fMaxCount && fBytes <= fMaxBytes) {
                 overBudget = false;
                 resource = NULL;
             }
         }
 
         if (!fNewlyPurgableResourceWhilePurging && overBudget && fOverBudgetCB) {
             // Despite the purge we're still over budget. Call our over budget callback.
@@ skipping 15 matching lines @@
 
     do {
         fNewlyPurgableResourceWhilePurging = false;
         ResourceList::Iter resourceIter;
         GrGpuResource* resource =
             resourceIter.init(fResources, ResourceList::Iter::kTail_IterStart);
 
         while (resource) {
             GrGpuResource* prev = resourceIter.prev();
             if (resource->isPurgable()) {
-                resource->unref();
-            } 
+                resource->cacheAccess().release();
+            }
             resource = prev;
         }
 
         if (!fNewlyPurgableResourceWhilePurging && fCount && fOverBudgetCB) {
             (*fOverBudgetCB)(fOverBudgetData);
         }
     } while (fNewlyPurgableResourceWhilePurging);
     fPurging = false;
 }
 
@@ skipping 34 matching lines @@
 
     SkASSERT(bytes == fBytes);
     SkASSERT(count == fCount);
 #if GR_CACHE_STATS
     SkASSERT(bytes <= fHighWaterBytes);
     SkASSERT(count <= fHighWaterCount);
 #endif
     SkASSERT(content == fContentHash.count());
     SkASSERT(scratch + couldBeScratch == fScratchMap.count());
 
-    bool overBudget = bytes > fMaxBytes || count > fMaxCount;
-    SkASSERT(!overBudget || locked == count || fPurging);
+    // This assertion is not currently valid because we can be in recursive notifyIsPurgable()
+    // calls. This will be fixed when subresource registration is explicit.
+    // bool overBudget = bytes > fMaxBytes || count > fMaxCount;
+    // SkASSERT(!overBudget || locked == count || fPurging);
 }
 #endif
 
 #if GR_CACHE_STATS
 void GrResourceCache2::printStats() const {
     this->validate();
 
     int locked = 0;
     int scratch = 0;
 
@@ skipping 13 matching lines @@
     float byteUtilization = (100.f * fBytes) / fMaxBytes;
 
     SkDebugf("Budget: %d items %d bytes\n", fMaxCount, fMaxBytes);
     SkDebugf("\t\tEntry Count: current %d (%d locked, %d scratch %.2g%% full), high %d\n",
                 fCount, locked, scratch, countUtilization, fHighWaterCount);
     SkDebugf("\t\tEntry Bytes: current %d (%.2g%% full) high %d\n",
                 fBytes, byteUtilization, fHighWaterBytes);
 }
 
 #endif