Add GrGpuResource::CacheAccess

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.
  */
 
 #include "GrResourceCache.h"
 #include "GrGpuResource.h"
+#include "GrGpuResourceCacheAccess.h"
 #include "GrTexturePriv.h"
 
 DECLARE_SKMESSAGEBUS_MESSAGE(GrResourceInvalidatedMessage);
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void GrGpuResource::didChangeGpuMemorySize() const {
-    if (this->isInCache()) {
+    if (this->cacheAccess().isInCache()) {
         fCacheEntry->didChangeResourceSize();
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 GrResourceKey::ResourceType GrResourceKey::GenerateResourceType() {
     static int32_t gNextType = 0;
 
     int32_t type = sk_atomic_inc(&gNextType);
@@ skipping 18 matching lines @@
 GrResourceCacheEntry::~GrResourceCacheEntry() {
     // We're relying on having the cache entry to remove this from GrResourceCache2's content hash.
     // fResource->setCacheEntry(NULL);
     fResource->unref();
 }
 
 #ifdef SK_DEBUG
 void GrResourceCacheEntry::validate() const {
     SkASSERT(fResourceCache);
     SkASSERT(fResource);
-    SkASSERT(fResource->getCacheEntry() == this);
+    SkASSERT(fResource->cacheAccess().getCacheEntry() == this);
     SkASSERT(fResource->gpuMemorySize() == fCachedSize);
     fResource->validate();
 }
 #endif
 
 void GrResourceCacheEntry::didChangeResourceSize() {
     size_t oldSize = fCachedSize;
     fCachedSize = fResource->gpuMemorySize();
     if (fCachedSize > oldSize) {
         fResourceCache->didIncreaseResourceSize(this, fCachedSize - oldSize);
@@ skipping 75 matching lines @@
         fHighWaterEntryCount = fEntryCount;
     }
     if (fHighWaterEntryBytes < fEntryBytes) {
         fHighWaterEntryBytes = fEntryBytes;
     }
 #endif
 }
 
 
 void GrResourceCache::makeResourceMRU(GrGpuResource* resource) {
-    GrResourceCacheEntry* entry = resource->getCacheEntry();
+    GrResourceCacheEntry* entry = resource->cacheAccess().getCacheEntry();
     if (entry) {
         this->internalDetach(entry);
         this->attachToHead(entry);
     }
 }
 
 void GrResourceCache::notifyPurgable(const GrGpuResource* resource) {
     // Remove scratch textures from the cache the moment they become purgeable if
     // scratch texture reuse is turned off.
-    SkASSERT(resource->getCacheEntry());
-    if (resource->isScratch()) {
-        const GrResourceKey& key = resource->getScratchKey();
+    SkASSERT(resource->cacheAccess().getCacheEntry());
+    if (resource->cacheAccess().isScratch()) {
+        const GrResourceKey& key = resource->cacheAccess().getScratchKey();
         if (key.getResourceType() == GrTexturePriv::ResourceType() &&
             !fCaps->reuseScratchTextures() &&
             !(static_cast<const GrSurface*>(resource)->desc().fFlags & kRenderTarget_GrSurfaceFlag)) {
-            this->deleteResource(resource->getCacheEntry());
+            this->deleteResource(resource->cacheAccess().getCacheEntry());
         }
     }
 }
 
 bool GrResourceCache::addResource(const GrResourceKey& key, GrGpuResource* resource) {
-    if (NULL != resource->getCacheEntry()) {
+    if (NULL != resource->cacheAccess().getCacheEntry()) {
         return false;
     }
     
     if (key.isScratch()) {
-        SkASSERT(resource->isScratch() && key == resource->getScratchKey());
+        SkASSERT(resource->cacheAccess().isScratch());
+        SkASSERT(key == resource->cacheAccess().getScratchKey());
     } else {
-        if (!resource->setContentKey(key)) {
+        if (!resource->cacheAccess().setContentKey(key)) {
             return false;
         }
     }
 
     // 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).
     SkASSERT(!fPurging);
     GrAutoResourceCacheValidate atcv(this);
 
     GrResourceCacheEntry* entry = SkNEW_ARGS(GrResourceCacheEntry, (this, resource));
-    resource->setCacheEntry(entry);
+    resource->cacheAccess().setCacheEntry(entry);
 
     this->attachToHead(entry);
     this->purgeAsNeeded();
     return true;
 }
 
 void GrResourceCache::didIncreaseResourceSize(const GrResourceCacheEntry* entry, size_t amountInc) {
     fEntryBytes += amountInc;
     this->purgeAsNeeded();
 }
@@ skipping 157 matching lines @@
     int scratch = 0;
 
     EntryList::Iter iter;
 
     GrResourceCacheEntry* entry = iter.init(fList, EntryList::Iter::kTail_IterStart);
 
     for ( ; entry; entry = iter.prev()) {
         if (!entry->fResource->isPurgable()) {
             ++locked;
         }
-        if (entry->fResource->isScratch()) {
+        if (entry->fResource->cacheAccess().isScratch()) {
             ++scratch;
         }
     }
 
     float countUtilization = (100.f * fEntryCount) / fMaxCount;
     float byteUtilization = (100.f * fEntryBytes) / 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",
                 fEntryCount, locked, scratch, countUtilization, fHighWaterEntryCount);
     SkDebugf("\t\tEntry Bytes: current %d (%.2g%% full) high %d\n",
                 fEntryBytes, byteUtilization, fHighWaterEntryBytes);
 }
 
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////