Add specialized content key class for resources.

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"
 #include "GrGpuResource.h"  
 
 #include "SkChecksum.h"
 #include "SkGr.h"
 #include "SkMessageBus.h"
 
 DECLARE_SKMESSAGEBUS_MESSAGE(GrResourceInvalidatedMessage);
 
 //////////////////////////////////////////////////////////////////////////////
 
 GrScratchKey::ResourceType GrScratchKey::GenerateResourceType() {
-    static int32_t gType = kInvalidResourceType + 1;
+    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() {
+    static int32_t gDomain = INHERITED::kInvalidDomain + 1;
 
-void GrScratchKey::Builder::finish() {
-    if (NULL == fKey) {
-        return;
+    int32_t domain = sk_atomic_inc(&gDomain);
+    if (kInvalidDomain == gDomain) {
+        SkFAIL("Too many Content Key Domains");
     }
-    GR_STATIC_ASSERT(0 == kHash_MetaDataIdx);
-    fKey->fKey[kHash_MetaDataIdx] = 
-        SkChecksum::Compute(&fKey->fKey[kHash_MetaDataIdx + 1], fKey->size() - sizeof(uint32_t));
-    fKey = NULL;
+
+    return static_cast<Domain>(domain);
+}
+uint32_t GrResourceKeyHash(const uint32_t* data, size_t size) {
+    return SkChecksum::Compute(data, size);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 class GrResourceCache2::AutoValidate : ::SkNoncopyable {
 public:
     AutoValidate(GrResourceCache2* cache) : fCache(cache) { cache->validate(); }
     ~AutoValidate() { fCache->validate(); }
 private:
     GrResourceCache2* fCache;
@@ skipping 71 matching lines @@
     fBytes -= size;
     if (resource->cacheAccess().isBudgeted()) {
         --fBudgetedCount;
         fBudgetedBytes -= size;
     }
 
     fResources.remove(resource);
     if (resource->cacheAccess().getScratchKey().isValid()) {
         fScratchMap.remove(resource->cacheAccess().getScratchKey(), resource);
     }
-    if (const GrResourceKey* contentKey = resource->cacheAccess().getContentKey()) {
-        fContentHash.remove(*contentKey);
+    if (resource->cacheAccess().getContentKey().isValid()) {
+        fContentHash.remove(resource->cacheAccess().getContentKey());
     }
     this->validate();
 }
 
 void GrResourceCache2::abandonAll() {
     AutoValidate av(this);
 
     SkASSERT(!fPurging);
     while (GrGpuResource* head = fResources.head()) {
         SkASSERT(!head->wasDestroyed());
@@ skipping 71 matching lines @@
 
 void GrResourceCache2::willRemoveScratchKey(const GrGpuResource* resource) {
     SkASSERT(resource->cacheAccess().isScratch());
     fScratchMap.remove(resource->cacheAccess().getScratchKey(), resource);
 }
 
 bool GrResourceCache2::didSetContentKey(GrGpuResource* resource) {
     SkASSERT(!fPurging);
     SkASSERT(resource);
     SkASSERT(this->isInCache(resource));
-    SkASSERT(resource->cacheAccess().getContentKey());
+    SkASSERT(resource->cacheAccess().getContentKey().isValid());
 
-    GrGpuResource* res = fContentHash.find(*resource->cacheAccess().getContentKey());
+    GrGpuResource* res = fContentHash.find(resource->cacheAccess().getContentKey());
     if (NULL != res) {
         return false;
     }
 
     fContentHash.add(resource);
     this->validate();
     return true;
 }
 
 void GrResourceCache2::makeResourceMRU(GrGpuResource* resource) {
@@ skipping 13 matching lines @@
     // that additional resources became purgable.
     if (fPurging) {
         fNewlyPurgableResourceWhilePurging = true;
         return;
     }
 
     // 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().isScratch() &&
-                 (NULL == resource->cacheAccess().getContentKey());
+    bool noKey = !resource->cacheAccess().getScratchKey().isValid() &&
+                 !resource->cacheAccess().getContentKey().isValid();
 
     // Only cached resources should ever have a key.
     SkASSERT(noKey || resource->cacheAccess().isBudgeted());
 
     if (overBudget || noKey) {
         SkDEBUGCODE(int beforeCount = fCount;)
         resource->cacheAccess().release();
         // We should at least free this resource, perhaps dependent resources as well.
         SkASSERT(fCount < beforeCount);
     }
@@ skipping 126 matching lines @@
     GrGpuResource* resource = iter.init(fResources, ResourceList::Iter::kHead_IterStart);
     for ( ; resource; resource = iter.next()) {
         bytes += resource->gpuMemorySize();
         ++count;
 
         if (!resource->isPurgable()) {
             ++locked;
         }
 
         if (resource->cacheAccess().isScratch()) {
-            SkASSERT(NULL == resource->cacheAccess().getContentKey());
+            SkASSERT(!resource->cacheAccess().getContentKey().isValid());
             ++scratch;
             SkASSERT(fScratchMap.countForKey(resource->cacheAccess().getScratchKey()));
             SkASSERT(!resource->cacheAccess().isWrapped());
         } else if (resource->cacheAccess().getScratchKey().isValid()) {
-            SkASSERT(NULL != resource->cacheAccess().getContentKey());
+            SkASSERT(resource->cacheAccess().getContentKey().isValid());
             ++couldBeScratch;
             SkASSERT(fScratchMap.countForKey(resource->cacheAccess().getScratchKey()));
             SkASSERT(!resource->cacheAccess().isWrapped());
         }
-
-        if (const GrResourceKey* contentKey = resource->cacheAccess().getContentKey()) {
+        const GrContentKey& contentKey = resource->cacheAccess().getContentKey();
+        if (contentKey.isValid()) {
             ++content;
-            SkASSERT(fContentHash.find(*contentKey) == resource);
+            SkASSERT(fContentHash.find(contentKey) == resource);
             SkASSERT(!resource->cacheAccess().isWrapped());
         }
 
         if (resource->cacheAccess().isBudgeted()) {
             ++budgetedCount;
             budgetedBytes += resource->gpuMemorySize();
         }
     }
 
     SkASSERT(fBudgetedCount <= fCount);
@@ skipping 52 matching lines @@
 
     SkDebugf("Budget: %d items %d bytes\n", fMaxCount, fMaxBytes);
     SkDebugf("\t\tEntry Count: current %d"
              " (%d budgeted, %d wrapped, %d locked, %d scratch %.2g%% full), high %d\n",
         fCount, fBudgetedCount, wrapped, locked, scratch, countUtilization, fHighWaterCount);
     SkDebugf("\t\tEntry Bytes: current %d (budgeted %d, %.2g%% full, %d unbudgeted) high %d\n",
                 fBytes, fBudgetedBytes, byteUtilization, unbudgetedSize, fHighWaterBytes);
 }
 
 #endif