Split out methods in GrGpuResource::CacheAccess that can be called outside of the cache.

src/gpu/GrResourceCache.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 "GrResourceCache.h"
-#include "GrGpuResource.h"  
-
+#include "GrGpuResourceCacheAccess.h"
 #include "SkChecksum.h"
 #include "SkGr.h"
 #include "SkMessageBus.h"
 
 DECLARE_SKMESSAGEBUS_MESSAGE(GrContentKeyInvalidatedMessage);
 
 //////////////////////////////////////////////////////////////////////////////
 
 GrScratchKey::ResourceType GrScratchKey::GenerateResourceType() {
     static int32_t gType = INHERITED::kInvalidDomain + 1;
@@ skipping 71 matching lines @@
     SkASSERT(!fPurging);
     fResources.addToHead(resource);
 
     size_t size = resource->gpuMemorySize();
     ++fCount;
     fBytes += size;
 #if GR_CACHE_STATS
     fHighWaterCount = SkTMax(fCount, fHighWaterCount);
     fHighWaterBytes = SkTMax(fBytes, fHighWaterBytes);
 #endif
-    if (resource->cacheAccess().isBudgeted()) {
+    if (resource->resourcePriv().isBudgeted()) {
         ++fBudgetedCount;
         fBudgetedBytes += size;
 #if GR_CACHE_STATS
         fBudgetedHighWaterCount = SkTMax(fBudgetedCount, fBudgetedHighWaterCount);
         fBudgetedHighWaterBytes = SkTMax(fBudgetedBytes, fBudgetedHighWaterBytes);
 #endif
     }
-    if (resource->cacheAccess().getScratchKey().isValid()) {
+    if (resource->resourcePriv().getScratchKey().isValid()) {
         SkASSERT(!resource->cacheAccess().isWrapped());
-        fScratchMap.insert(resource->cacheAccess().getScratchKey(), resource);
+        fScratchMap.insert(resource->resourcePriv().getScratchKey(), resource);
     }
     
     this->purgeAsNeeded();
 }
 
 void GrResourceCache::removeResource(GrGpuResource* resource) {
     SkASSERT(this->isInCache(resource));
 
     size_t size = resource->gpuMemorySize();
     --fCount;
     fBytes -= size;
-    if (resource->cacheAccess().isBudgeted()) {
+    if (resource->resourcePriv().isBudgeted()) {
         --fBudgetedCount;
         fBudgetedBytes -= size;
     }
 
     fResources.remove(resource);
-    if (resource->cacheAccess().getScratchKey().isValid()) {
-        fScratchMap.remove(resource->cacheAccess().getScratchKey(), resource);
+    if (resource->resourcePriv().getScratchKey().isValid()) {
+        fScratchMap.remove(resource->resourcePriv().getScratchKey(), resource);
     }
     if (resource->getContentKey().isValid()) {
         fContentHash.remove(resource->getContentKey());
     }
     this->validate();
 }
 
 void GrResourceCache::abandonAll() {
     AutoValidate av(this);
 
@@ skipping 66 matching lines @@
     resource = fScratchMap.find(scratchKey, AvailableForScratchUse(false));
     if (resource) {
         resource->ref();
         this->makeResourceMRU(resource);
         this->validate();
     }
     return resource;
 }
 
 void GrResourceCache::willRemoveScratchKey(const GrGpuResource* resource) {
-    SkASSERT(resource->cacheAccess().getScratchKey().isValid());
-    fScratchMap.remove(resource->cacheAccess().getScratchKey(), resource);
+    SkASSERT(resource->resourcePriv().getScratchKey().isValid());
+    fScratchMap.remove(resource->resourcePriv().getScratchKey(), resource);
 }
 
 void GrResourceCache::willRemoveContentKey(const GrGpuResource* resource) {
     // Someone has a ref to this resource in order to invalidate it. When the ref count reaches
     // zero we will get a notifyPurgable() and figure out what to do with it.
     SkASSERT(resource->getContentKey().isValid());
     fContentHash.remove(resource->getContentKey());
 }
 
 bool GrResourceCache::didSetContentKey(GrGpuResource* resource) {
@@ skipping 29 matching lines @@
     // that additional resources became purgeable.
     if (fPurging) {
         fNewlyPurgeableResourceWhilePurging = true;
         return;
     }
 
     bool release = false;
 
     if (resource->cacheAccess().isWrapped()) {
         release = true;
-    } else if (!resource->cacheAccess().isBudgeted()) {
+    } else if (!resource->resourcePriv().isBudgeted()) {
         // Check whether this resource could still be used as a scratch resource.
-        if (resource->cacheAccess().getScratchKey().isValid()) {
+        if (resource->resourcePriv().getScratchKey().isValid()) {
             // We won't purge an existing resource to make room for this one.
             bool underBudget = fBudgetedCount < fMaxCount &&
                                fBudgetedBytes + resource->gpuMemorySize() <= fMaxBytes;
             if (underBudget) {
-                resource->cacheAccess().makeBudgeted();
+                resource->resourcePriv().makeBudgeted();
             } else {
                 release = true;
             }
         } else {
             release = true;
         }
     } else {
         // Purge the resource if we're over budget
         bool overBudget = fBudgetedCount > fMaxCount || fBudgetedBytes > fMaxBytes;
 
         // Also purge if the resource has neither a valid scratch key nor a content key.
-        bool noKey = !resource->cacheAccess().getScratchKey().isValid() &&
+        bool noKey = !resource->resourcePriv().getScratchKey().isValid() &&
                      !resource->getContentKey().isValid();
         if (overBudget || noKey) {
             release = true;
         }
     }
 
     if (release) {
         SkDEBUGCODE(int beforeCount = fCount;)
         resource->cacheAccess().release();
         // We should at least free this resource, perhaps dependent resources as well.
         SkASSERT(fCount < beforeCount);
     }
     this->validate();
 }
 
 void GrResourceCache::didChangeGpuMemorySize(const GrGpuResource* resource, size_t oldSize) {
     // SkASSERT(!fPurging); GrPathRange increases size during flush. :(
     SkASSERT(resource);
     SkASSERT(this->isInCache(resource));
 
     ptrdiff_t delta = resource->gpuMemorySize() - oldSize;
 
     fBytes += delta;
 #if GR_CACHE_STATS
     fHighWaterBytes = SkTMax(fBytes, fHighWaterBytes);
 #endif
-    if (resource->cacheAccess().isBudgeted()) {
+    if (resource->resourcePriv().isBudgeted()) {
         fBudgetedBytes += delta;
 #if GR_CACHE_STATS
         fBudgetedHighWaterBytes = SkTMax(fBudgetedBytes, fBudgetedHighWaterBytes);
 #endif
     }
 
     this->purgeAsNeeded();
     this->validate();
 }
 
 void GrResourceCache::didChangeBudgetStatus(GrGpuResource* resource) {
     SkASSERT(!fPurging);
     SkASSERT(resource);
     SkASSERT(this->isInCache(resource));
 
     size_t size = resource->gpuMemorySize();
 
-    if (resource->cacheAccess().isBudgeted()) {
+    if (resource->resourcePriv().isBudgeted()) {
         ++fBudgetedCount;
         fBudgetedBytes += size;
 #if GR_CACHE_STATS
         fBudgetedHighWaterBytes = SkTMax(fBudgetedBytes, fBudgetedHighWaterBytes);
         fBudgetedHighWaterCount = SkTMax(fBudgetedCount, fBudgetedHighWaterCount);
 #endif
         this->purgeAsNeeded();
     } else {
         --fBudgetedCount;
         fBudgetedBytes -= size;
@@ skipping 65 matching lines @@
     } while (fNewlyPurgeableResourceWhilePurging);
     fPurging = false;
     this->validate();
 }
 
 void GrResourceCache::processInvalidContentKeys(
     const SkTArray<GrContentKeyInvalidatedMessage>& msgs) {
     for (int i = 0; i < msgs.count(); ++i) {
         GrGpuResource* resource = this->findAndRefContentResource(msgs[i].key());
         if (resource) {
-            resource->cacheAccess().removeContentKey();
+            resource->resourcePriv().removeContentKey();
             resource->unref(); // will call notifyPurgeable, if it is indeed now purgeable.
         }
     }
 }
 
 #ifdef SK_DEBUG
 void GrResourceCache::validate() const {
     // Reduce the frequency of validations for large resource counts.
     static SkRandom gRandom;
     int mask = (SkNextPow2(fCount + 1) >> 5) - 1;
@@ skipping 16 matching lines @@
         bytes += resource->gpuMemorySize();
         ++count;
 
         if (!resource->isPurgeable()) {
             ++locked;
         }
 
         if (resource->cacheAccess().isScratch()) {
             SkASSERT(!resource->getContentKey().isValid());
             ++scratch;
-            SkASSERT(fScratchMap.countForKey(resource->cacheAccess().getScratchKey()));
+            SkASSERT(fScratchMap.countForKey(resource->resourcePriv().getScratchKey()));
             SkASSERT(!resource->cacheAccess().isWrapped());
-        } else if (resource->cacheAccess().getScratchKey().isValid()) {
-            SkASSERT(!resource->cacheAccess().isBudgeted() ||
+        } else if (resource->resourcePriv().getScratchKey().isValid()) {
+            SkASSERT(!resource->resourcePriv().isBudgeted() ||
                      resource->getContentKey().isValid());
             ++couldBeScratch;
-            SkASSERT(fScratchMap.countForKey(resource->cacheAccess().getScratchKey()));
+            SkASSERT(fScratchMap.countForKey(resource->resourcePriv().getScratchKey()));
             SkASSERT(!resource->cacheAccess().isWrapped());
         }
         const GrContentKey& contentKey = resource->getContentKey();
         if (contentKey.isValid()) {
             ++content;
             SkASSERT(fContentHash.find(contentKey) == resource);
             SkASSERT(!resource->cacheAccess().isWrapped());
-            SkASSERT(resource->cacheAccess().isBudgeted());
+            SkASSERT(resource->resourcePriv().isBudgeted());
         }
 
-        if (resource->cacheAccess().isBudgeted()) {
+        if (resource->resourcePriv().isBudgeted()) {
             ++budgetedCount;
             budgetedBytes += resource->gpuMemorySize();
         }
     }
 
     SkASSERT(fBudgetedCount <= fCount);
     SkASSERT(fBudgetedBytes <= fBudgetedBytes);
     SkASSERT(bytes == fBytes);
     SkASSERT(count == fCount);
     SkASSERT(budgetedBytes == fBudgetedBytes);
     SkASSERT(budgetedCount == fBudgetedCount);
 #if GR_CACHE_STATS
     SkASSERT(fBudgetedHighWaterCount <= fHighWaterCount);
     SkASSERT(fBudgetedHighWaterBytes <= fHighWaterBytes);
     SkASSERT(bytes <= fHighWaterBytes);
     SkASSERT(count <= fHighWaterCount);
     SkASSERT(budgetedBytes <= fBudgetedHighWaterBytes);
     SkASSERT(budgetedCount <= fBudgetedHighWaterCount);
 #endif
     SkASSERT(content == fContentHash.count());
     SkASSERT(scratch + couldBeScratch == fScratchMap.count());
 
     // This assertion is not currently valid because we can be in recursive notifyIsPurgeable()
     // calls. This will be fixed when subresource registration is explicit.
     // bool overBudget = budgetedBytes > fMaxBytes || budgetedCount > fMaxCount;
     // SkASSERT(!overBudget || locked == count || fPurging);
 }
 #endif