Use GrResourceCache2 to service content key lookups

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"
@@ skipping 31 matching lines @@
           fKey(key),
           fResource(resource),
           fCachedSize(resource->gpuMemorySize()),
           fIsExclusive(false) {
     // we assume ownership of the resource, and will unref it when we die
     SkASSERT(resource);
     resource->ref();
 }
 
 GrResourceCacheEntry::~GrResourceCacheEntry() {
-    fResource->setCacheEntry(NULL);
+    // 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->gpuMemorySize() == fCachedSize);
     fResource->validate();
@@ skipping 115 matching lines @@
     // scratch texture reuse is turned off.
     SkASSERT(resource->getCacheEntry());
     if (resource->getCacheEntry()->key().getResourceType() == GrTexturePriv::ResourceType() &&
         resource->getCacheEntry()->key().isScratch() &&
         !fCaps->reuseScratchTextures() &&
         !(static_cast<const GrSurface*>(resource)->desc().fFlags & kRenderTarget_GrSurfaceFlag)) {
         this->deleteResource(resource->getCacheEntry());
     }
 }
 
-GrGpuResource* GrResourceCache::find(const GrResourceKey& key) {
-    // GrResourceCache2 is responsible for scratch resources.
-    SkASSERT(!key.isScratch());
-
-    GrAutoResourceCacheValidate atcv(this);
-
-    GrResourceCacheEntry* entry = fCache.find(key);
-    if (NULL == entry) {
-        return NULL;
+bool GrResourceCache::addResource(const GrResourceKey& key, GrGpuResource* resource) {
+    if (NULL != resource->getCacheEntry()) {
+        return false;
     }
 
-    // Make this resource MRU
-    this->internalDetach(entry);
-    this->attachToHead(entry);
-
-    return entry->fResource;
-}
-
-void GrResourceCache::addResource(const GrResourceKey& key, GrGpuResource* resource) {
-    SkASSERT(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).
     SkASSERT(!fPurging);
     GrAutoResourceCacheValidate atcv(this);
 
     GrResourceCacheEntry* entry = SkNEW_ARGS(GrResourceCacheEntry, (this, key, resource));
-    resource->setCacheEntry(entry);
+    if (!resource->setCacheEntry(entry)) {
+        SkDELETE(entry);
+        this->purgeAsNeeded();
+        return false;
+    }
 
     this->attachToHead(entry);
     fCache.insert(key, entry);
-
     this->purgeAsNeeded();
+    return true;
 }
 
 void GrResourceCache::didIncreaseResourceSize(const GrResourceCacheEntry* entry, size_t amountInc) {
     fEntryBytes += amountInc;
     this->purgeAsNeeded();
 }
 
 void GrResourceCache::didDecreaseResourceSize(const GrResourceCacheEntry* entry, size_t amountDec) {
     fEntryBytes -= amountDec;
 #ifdef SK_DEBUG
@@ skipping 192 matching lines @@
     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
 
 ///////////////////////////////////////////////////////////////////////////////