Rename GrContentKey to GrUniqueKey

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 "GrGpuResourceCacheAccess.h"
 #include "SkChecksum.h"
 #include "SkGr.h"
 #include "SkMessageBus.h"
 
-DECLARE_SKMESSAGEBUS_MESSAGE(GrContentKeyInvalidatedMessage);
+DECLARE_SKMESSAGEBUS_MESSAGE(GrUniqueKeyInvalidatedMessage);
 
 //////////////////////////////////////////////////////////////////////////////
 
 GrScratchKey::ResourceType GrScratchKey::GenerateResourceType() {
     static int32_t gType = INHERITED::kInvalidDomain + 1;
 
     int32_t type = sk_atomic_inc(&gType);
     if (type > SK_MaxU16) {
         SkFAIL("Too many Resource Types");
     }
 
     return static_cast<ResourceType>(type);
 }
 
-GrContentKey::Domain GrContentKey::GenerateDomain() {
+GrUniqueKey::Domain GrUniqueKey::GenerateDomain() {
     static int32_t gDomain = INHERITED::kInvalidDomain + 1;
 
     int32_t domain = sk_atomic_inc(&gDomain);
     if (domain > SK_MaxU16) {
-        SkFAIL("Too many Content Key Domains");
+        SkFAIL("Too many GrUniqueKey Domains");
     }
 
     return static_cast<Domain>(domain);
 }
 uint32_t GrResourceKeyHash(const uint32_t* data, size_t size) {
     return SkChecksum::Compute(data, size);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
@@ skipping 84 matching lines @@
     SkDEBUGCODE(--fCount;)
     fBytes -= size;
     if (resource->resourcePriv().isBudgeted()) {
         --fBudgetedCount;
         fBudgetedBytes -= size;
     }
 
     if (resource->resourcePriv().getScratchKey().isValid()) {
         fScratchMap.remove(resource->resourcePriv().getScratchKey(), resource);
     }
-    if (resource->getContentKey().isValid()) {
-        fContentHash.remove(resource->getContentKey());
+    if (resource->getUniqueKey().isValid()) {
+        fUniqueHash.remove(resource->getUniqueKey());
     }
     this->validate();
 }
 
 void GrResourceCache::abandonAll() {
     AutoValidate av(this);
 
     while (fNonpurgeableResources.count()) {
         GrGpuResource* back = *(fNonpurgeableResources.end() - 1);
         SkASSERT(!back->wasDestroyed());
         back->cacheAccess().abandon();
     }
 
     while (fPurgeableQueue.count()) {
         GrGpuResource* top = fPurgeableQueue.peek();
         SkASSERT(!top->wasDestroyed());
         top->cacheAccess().abandon();
     }
 
     SkASSERT(!fScratchMap.count());
-    SkASSERT(!fContentHash.count());
+    SkASSERT(!fUniqueHash.count());
     SkASSERT(!fCount);
     SkASSERT(!this->getResourceCount());
     SkASSERT(!fBytes);
     SkASSERT(!fBudgetedCount);
     SkASSERT(!fBudgetedBytes);
 }
 
 void GrResourceCache::releaseAll() {
     AutoValidate av(this);
 
     while(fNonpurgeableResources.count()) {
         GrGpuResource* back = *(fNonpurgeableResources.end() - 1);
         SkASSERT(!back->wasDestroyed());
         back->cacheAccess().release();
     }
 
     while (fPurgeableQueue.count()) {
         GrGpuResource* top = fPurgeableQueue.peek();
         SkASSERT(!top->wasDestroyed());
         top->cacheAccess().release();
     }
 
     SkASSERT(!fScratchMap.count());
-    SkASSERT(!fContentHash.count());
+    SkASSERT(!fUniqueHash.count());
     SkASSERT(!fCount);
     SkASSERT(!this->getResourceCount());
     SkASSERT(!fBytes);
     SkASSERT(!fBudgetedCount);
     SkASSERT(!fBudgetedBytes);
 }
 
 class GrResourceCache::AvailableForScratchUse {
 public:
     AvailableForScratchUse(bool rejectPendingIO) : fRejectPendingIO(rejectPendingIO) { }
@@ skipping 32 matching lines @@
         this->validate();
     }
     return resource;
 }
 
 void GrResourceCache::willRemoveScratchKey(const GrGpuResource* resource) {
     SkASSERT(resource->resourcePriv().getScratchKey().isValid());
     fScratchMap.remove(resource->resourcePriv().getScratchKey(), resource);
 }
 
-void GrResourceCache::willRemoveContentKey(const GrGpuResource* resource) {
+void GrResourceCache::willRemoveUniqueKey(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());
+    SkASSERT(resource->getUniqueKey().isValid());
+    fUniqueHash.remove(resource->getUniqueKey());
 }
 
-bool GrResourceCache::didSetContentKey(GrGpuResource* resource) {
+bool GrResourceCache::didSetUniqueKey(GrGpuResource* resource) {
     SkASSERT(resource);
     SkASSERT(this->isInCache(resource));
-    SkASSERT(resource->getContentKey().isValid());
+    SkASSERT(resource->getUniqueKey().isValid());
 
-    GrGpuResource* res = fContentHash.find(resource->getContentKey());
+    GrGpuResource* res = fUniqueHash.find(resource->getUniqueKey());
     if (NULL != res) {
         return false;
     }
 
-    fContentHash.add(resource);
+    fUniqueHash.add(resource);
     this->validate();
     return true;
 }
 
 void GrResourceCache::refAndMakeResourceMRU(GrGpuResource* resource) {
     SkASSERT(resource);
     SkASSERT(this->isInCache(resource));
     if (resource->isPurgeable()) {
         // It's about to become unpurgeable.
         fPurgeableQueue.remove(resource);
@@ skipping 18 matching lines @@
             resource->resourcePriv().getScratchKey().isValid()) {
             // We won't purge an existing resource to make room for this one.
             if (fBudgetedCount < fMaxCount &&
                 fBudgetedBytes + resource->gpuMemorySize() <= fMaxBytes) {
                 resource->resourcePriv().makeBudgeted();
                 return;
             }
         }
     } else {
         // Purge the resource immediately if we're over budget
-        // Also purge if the resource has neither a valid scratch key nor a content key.
+        // Also purge if the resource has neither a valid scratch key nor a unique key.
         bool noKey = !resource->resourcePriv().getScratchKey().isValid() &&
-                     !resource->getContentKey().isValid();
+                     !resource->getUniqueKey().isValid();
         if (!this->overBudget() && !noKey) {
             return;
         }
     }
 
     SkDEBUGCODE(int beforeCount = this->getResourceCount();)
     resource->cacheAccess().release();
     // We should at least free this resource, perhaps dependent resources as well.
     SkASSERT(this->getResourceCount() < beforeCount);
     this->validate();
@@ skipping 72 matching lines @@
     // Moreover, this is rarely called.
     while (fPurgeableQueue.count()) {
         GrGpuResource* resource = fPurgeableQueue.peek();
         SkASSERT(resource->isPurgeable());
         resource->cacheAccess().release();
     }
 
     this->validate();
 }
 
-void GrResourceCache::processInvalidContentKeys(
-    const SkTArray<GrContentKeyInvalidatedMessage>& msgs) {
+void GrResourceCache::processInvalidUniqueKeys(
+    const SkTArray<GrUniqueKeyInvalidatedMessage>& msgs) {
     for (int i = 0; i < msgs.count(); ++i) {
-        GrGpuResource* resource = this->findAndRefContentResource(msgs[i].key());
+        GrGpuResource* resource = this->findAndRefUniqueResource(msgs[i].key());
         if (resource) {
-            resource->resourcePriv().removeContentKey();
+            resource->resourcePriv().removeUniqueKey();
             resource->unref(); // will call notifyPurgeable, if it is indeed now purgeable.
         }
     }
 }
 
 void GrResourceCache::addToNonpurgeableArray(GrGpuResource* resource) {
     int index = fNonpurgeableResources.count();
     *fNonpurgeableResources.append() = resource;
     *resource->cacheAccess().accessCacheIndex() = index;
 }
@@ skipping 21 matching lines @@
 
     struct Stats {
         size_t fBytes;
         int fBudgetedCount;
         size_t fBudgetedBytes;
         int fLocked;
         int fScratch;
         int fCouldBeScratch;
         int fContent;
         const ScratchMap* fScratchMap;
-        const ContentHash* fContentHash;
+        const UniqueHash* fUniqueHash;
 
         Stats(const GrResourceCache* cache) {
             memset(this, 0, sizeof(*this));
             fScratchMap = &cache->fScratchMap;
-            fContentHash = &cache->fContentHash;
+            fUniqueHash = &cache->fUniqueHash;
         }
 
         void update(GrGpuResource* resource) {
             fBytes += resource->gpuMemorySize();
 
             if (!resource->isPurgeable()) {
                 ++fLocked;
             }
 
             if (resource->cacheAccess().isScratch()) {
-                SkASSERT(!resource->getContentKey().isValid());
+                SkASSERT(!resource->getUniqueKey().isValid());
                 ++fScratch;
                 SkASSERT(fScratchMap->countForKey(resource->resourcePriv().getScratchKey()));
                 SkASSERT(!resource->cacheAccess().isWrapped());
             } else if (resource->resourcePriv().getScratchKey().isValid()) {
                 SkASSERT(!resource->resourcePriv().isBudgeted() ||
-                         resource->getContentKey().isValid());
+                         resource->getUniqueKey().isValid());
                 ++fCouldBeScratch;
                 SkASSERT(fScratchMap->countForKey(resource->resourcePriv().getScratchKey()));
                 SkASSERT(!resource->cacheAccess().isWrapped());
             }
-            const GrContentKey& contentKey = resource->getContentKey();
-            if (contentKey.isValid()) {
+            const GrUniqueKey& uniqueKey = resource->getUniqueKey();
+            if (uniqueKey.isValid()) {
                 ++fContent;
-                SkASSERT(fContentHash->find(contentKey) == resource);
+                SkASSERT(fUniqueHash->find(uniqueKey) == resource);
                 SkASSERT(!resource->cacheAccess().isWrapped());
                 SkASSERT(resource->resourcePriv().isBudgeted());
             }
 
             if (resource->resourcePriv().isBudgeted()) {
                 ++fBudgetedCount;
                 fBudgetedBytes += resource->gpuMemorySize();
             }
         }
     };
@@ skipping 20 matching lines @@
     SkASSERT(stats.fBudgetedBytes == fBudgetedBytes);
     SkASSERT(stats.fBudgetedCount == fBudgetedCount);
 #if GR_CACHE_STATS
     SkASSERT(fBudgetedHighWaterCount <= fHighWaterCount);
     SkASSERT(fBudgetedHighWaterBytes <= fHighWaterBytes);
     SkASSERT(fBytes <= fHighWaterBytes);
     SkASSERT(fCount <= fHighWaterCount);
     SkASSERT(fBudgetedBytes <= fBudgetedHighWaterBytes);
     SkASSERT(fBudgetedCount <= fBudgetedHighWaterCount);
 #endif
-    SkASSERT(stats.fContent == fContentHash.count());
+    SkASSERT(stats.fContent == fUniqueHash.count());
     SkASSERT(stats.fScratch + stats.fCouldBeScratch == 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);
 }
 
 bool GrResourceCache::isInCache(const GrGpuResource* resource) const {
     int index = *resource->cacheAccess().accessCacheIndex();
     if (index < 0) {
         return false;
     }
     if (index < fPurgeableQueue.count() && fPurgeableQueue.at(index) == resource) {
         return true;
     }
     if (index < fNonpurgeableResources.count() && fNonpurgeableResources[index] == resource) {
         return true;
     }
     SkDEBUGFAIL("Resource index should be -1 or the resource should be in the cache.");
     return false;
 }
 
 #endif