Add a simpler key type for scratch resource keys.

tests/ResourceCacheTest.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #if SK_SUPPORT_GPU
 
 #include "GrContext.h"
@@ skipping 64 matching lines @@
     }
 
     TestResource(GrGpu* gpu)
         : INHERITED(gpu, false)
         , fToDelete(NULL)
         , fSize(kDefaultSize) {
         ++fNumAlive;
         this->registerWithCache();
     }
 
-    TestResource(GrGpu* gpu, const GrResourceKey& scratchKey)
+    TestResource(GrGpu* gpu, const GrScratchKey& scratchKey)
         : INHERITED(gpu, false)
         , fToDelete(NULL)
         , fSize(kDefaultSize) {
         this->setScratchKey(scratchKey);
         ++fNumAlive;
         this->registerWithCache();
     }
 
     ~TestResource() {
         --fNumAlive;
@@ skipping 70 matching lines @@
     REPORTER_ASSERT(reporter, 1 == TestResource::NumAlive());
     REPORTER_ASSERT(reporter, 1 == cache2->getResourceCount());
     REPORTER_ASSERT(reporter, b->gpuMemorySize() == cache2->getResourceBytes());
 
     b->unref();
     REPORTER_ASSERT(reporter, 0 == TestResource::NumAlive());
     REPORTER_ASSERT(reporter, 0 == cache2->getResourceCount());
     REPORTER_ASSERT(reporter, 0 == cache2->getResourceBytes());
 }
 
+static void make_scratch_key(GrScratchKey* key) {
+    static GrScratchKey::ResourceType t = GrScratchKey::GenerateResourceType();
+    GrScratchKey::Builder builder(key, t, 0);
+}
+
 static void test_budgeting(skiatest::Reporter* reporter) {
     SkAutoTUnref<GrContext> context(GrContext::CreateMockContext());
     REPORTER_ASSERT(reporter, SkToBool(context));
     if (NULL == context) {
         return;
     }
     context->setResourceCacheLimits(10, 300);
     GrResourceCache2* cache2 = context->getResourceCache2();
     cache2->purgeAllUnlocked();
     SkASSERT(0 == cache2->getResourceCount() && 0 == cache2->getResourceBytes());
     SkASSERT(0 == cache2->getBudgetedResourceCount() && 0 == cache2->getBudgetedResourceBytes());
 
+    GrScratchKey scratchKey;
+    make_scratch_key(&scratchKey);
+
     GrCacheID::Key keyData;
     memset(&keyData, 0, sizeof(keyData));
-    GrResourceKey::ResourceType t = GrResourceKey::GenerateResourceType();
-    GrResourceKey scratchKey(GrCacheID(GrResourceKey::ScratchDomain(), keyData), t, 0);
-    GrResourceKey contentKey(GrCacheID(GrCacheID::GenerateDomain(), keyData), t, 0);
+    GrResourceKey contentKey(GrCacheID(GrCacheID::GenerateDomain(), keyData), 0);
 
     // Create a scratch, a content, and a wrapped resource
     TestResource* scratch = new TestResource(context->getGpu(), scratchKey);
     scratch->setSize(10);
     TestResource* content = new TestResource(context->getGpu());
     scratch->setSize(11);
     REPORTER_ASSERT(reporter, content->cacheAccess().setContentKey(contentKey));
     TestResource* wrapped = new TestResource(context->getGpu(), true);
     scratch->setSize(12);
     TestResource* unbudgeted = new TestResource(context->getGpu());
     unbudgeted->setSize(13);
     unbudgeted->cacheAccess().setBudgeted(false);
 
     // Make sure we can't add a content key to the wrapped resource
     keyData.fData8[0] = 1;
-    GrResourceKey contentKey2(GrCacheID(GrCacheID::GenerateDomain(), keyData), t, 0);
+    GrResourceKey contentKey2(GrCacheID(GrCacheID::GenerateDomain(), keyData), 0);
     REPORTER_ASSERT(reporter, !wrapped->cacheAccess().setContentKey(contentKey2));
     REPORTER_ASSERT(reporter, NULL == cache2->findAndRefContentResource(contentKey2));
 
     // Make sure sizes are as we expect
     REPORTER_ASSERT(reporter, 4 == cache2->getResourceCount());
     REPORTER_ASSERT(reporter, scratch->gpuMemorySize() + content->gpuMemorySize() +
                               wrapped->gpuMemorySize() + unbudgeted->gpuMemorySize() ==
                               cache2->getResourceBytes());
     REPORTER_ASSERT(reporter, 2 == cache2->getBudgetedResourceCount());
     REPORTER_ASSERT(reporter, scratch->gpuMemorySize() + content->gpuMemorySize() ==
@@ skipping 51 matching lines @@
     SkAutoTUnref<GrContext> context(GrContext::CreateMockContext());
     REPORTER_ASSERT(reporter, SkToBool(context));
     if (NULL == context) {
         return;
     }
     context->setResourceCacheLimits(5, 30000);
     GrResourceCache2* cache2 = context->getResourceCache2();
     cache2->purgeAllUnlocked();
     SkASSERT(0 == cache2->getResourceCount() && 0 == cache2->getResourceBytes());
 
-    GrCacheID::Key keyData;
-    memset(&keyData, 0, sizeof(keyData));
-    GrCacheID::Domain domain = GrResourceKey::ScratchDomain();
-    GrResourceKey::ResourceType t = GrResourceKey::GenerateResourceType();
-    GrResourceKey scratchKey(GrCacheID(domain, keyData), t, 0);
+    GrScratchKey scratchKey;
+    make_scratch_key(&scratchKey);
 
     // Create two resources that have the same scratch key.
     TestResource* a = new TestResource(context->getGpu(), scratchKey);
     TestResource* b = new TestResource(context->getGpu(), scratchKey);
     a->setSize(11);
     b->setSize(12);
     // Scratch resources are registered with GrResourceCache2 just by existing. There are 2.
     REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive());
     SkDEBUGCODE(REPORTER_ASSERT(reporter, 2 == cache2->countScratchEntriesForKey(scratchKey));)
     REPORTER_ASSERT(reporter, 2 == cache2->getResourceCount());
@@ skipping 22 matching lines @@
     SkAutoTUnref<GrContext> context(GrContext::CreateMockContext());
     REPORTER_ASSERT(reporter, SkToBool(context));
     if (NULL == context) {
         return;
     }
     context->setResourceCacheLimits(5, 30000);
     GrResourceCache2* cache2 = context->getResourceCache2();
     cache2->purgeAllUnlocked();
     SkASSERT(0 == cache2->getResourceCount() && 0 == cache2->getResourceBytes());
 
-    GrCacheID::Key keyData;
-    memset(&keyData, 0, sizeof(keyData));
-    GrCacheID::Domain domain = GrResourceKey::ScratchDomain();
-    GrResourceKey::ResourceType t = GrResourceKey::GenerateResourceType();
-    GrResourceKey scratchKey(GrCacheID(domain, keyData), t, 0);
+    GrScratchKey scratchKey;
+    make_scratch_key(&scratchKey);
 
     // Create two resources that have the same scratch key.
     TestResource* a = new TestResource(context->getGpu(), scratchKey);
     TestResource* b = new TestResource(context->getGpu(), scratchKey);
     a->unref();
     b->unref();
 
     // Scratch resources are registered with GrResourceCache2 just by existing. There are 2.
     REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive());
     SkDEBUGCODE(REPORTER_ASSERT(reporter, 2 == cache2->countScratchEntriesForKey(scratchKey));)
@@ skipping 40 matching lines @@
         return;
     }
     context->setResourceCacheLimits(5, 30000);
     GrResourceCache2* cache2 = context->getResourceCache2();
     cache2->purgeAllUnlocked();
     SkASSERT(0 == cache2->getResourceCount() && 0 == cache2->getResourceBytes());
 
     GrCacheID::Domain domain = GrCacheID::GenerateDomain();
     GrCacheID::Key keyData;
     memset(&keyData, 0, sizeof(keyData));
-    GrResourceKey::ResourceType t = GrResourceKey::GenerateResourceType();
-    GrResourceKey key(GrCacheID(domain, keyData), t, 0);
+    GrResourceKey key(GrCacheID(domain, keyData), 0);
     
     // Create two resources that we will attempt to register with the same content key.
     TestResource* a = new TestResource(context->getGpu());
     TestResource* b = new TestResource(context->getGpu());
     a->setSize(11);
     b->setSize(12);
     
     // Can't set the same content key on two resources.
     REPORTER_ASSERT(reporter, a->cacheAccess().setContentKey(key));
     REPORTER_ASSERT(reporter, !b->cacheAccess().setContentKey(key));
@@ skipping 31 matching lines @@
     SkAutoTUnref<GrContext> context(GrContext::CreateMockContext());
     REPORTER_ASSERT(reporter, SkToBool(context));
     if (NULL == context) {
         return;
     }
 
     GrCacheID::Domain domain = GrCacheID::GenerateDomain();
     GrCacheID::Key keyData;
     memset(&keyData, 0, sizeof(keyData));
 
-    GrResourceKey::ResourceType t = GrResourceKey::GenerateResourceType();
-
     keyData.fData64[0] = 1;
-    GrResourceKey key1(GrCacheID(domain, keyData), t, 0);
+    GrResourceKey key1(GrCacheID(domain, keyData), 0);
     keyData.fData64[0] = 2;
-    GrResourceKey key2(GrCacheID(domain, keyData), t, 0);
+    GrResourceKey key2(GrCacheID(domain, keyData), 0);
     keyData.fData64[0] = 3;
-    GrResourceKey key3(GrCacheID(domain, keyData), t, 0);
+    GrResourceKey key3(GrCacheID(domain, keyData), 0);
     
     context->setResourceCacheLimits(5, 30000);
     GrResourceCache2* cache2 = context->getResourceCache2();
     cache2->purgeAllUnlocked();
     SkASSERT(0 == cache2->getResourceCount() && 0 == cache2->getResourceBytes());
 
     // Add three resources to the cache.
     TestResource* a = new TestResource(context->getGpu());
     TestResource* b = new TestResource(context->getGpu());
     TestResource* c = new TestResource(context->getGpu());
@@ skipping 40 matching lines @@
 static void test_cache_chained_purge(skiatest::Reporter* reporter) {
     SkAutoTUnref<GrContext> context(GrContext::CreateMockContext());
     REPORTER_ASSERT(reporter, SkToBool(context));
     if (NULL == context) {
         return;
     }
 
     GrCacheID::Domain domain = GrCacheID::GenerateDomain();
     GrCacheID::Key keyData;
     memset(&keyData, 0, sizeof(keyData));
-    GrResourceKey::ResourceType t = GrResourceKey::GenerateResourceType();
 
     keyData.fData64[0] = 1;
-    GrResourceKey key1(GrCacheID(domain, keyData), t, 0);
+    GrResourceKey key1(GrCacheID(domain, keyData), 0);
 
     keyData.fData64[0] = 2;
-    GrResourceKey key2(GrCacheID(domain, keyData), t, 0);
+    GrResourceKey key2(GrCacheID(domain, keyData), 0);
 
     {
         context->setResourceCacheLimits(3, 30000);
         GrResourceCache2* cache2 = context->getResourceCache2();
         cache2->purgeAllUnlocked();
         SkASSERT(0 == cache2->getResourceCount() && 0 == cache2->getResourceBytes());
 
         TestResource* a = new TestResource(context->getGpu());
         TestResource* b = new TestResource(context->getGpu());
         a->cacheAccess().setContentKey(key1);
@@ skipping 23 matching lines @@
 }
 
 static void test_resource_size_changed(skiatest::Reporter* reporter) {
     SkAutoTUnref<GrContext> context(GrContext::CreateMockContext());
     REPORTER_ASSERT(reporter, SkToBool(context));
     if (NULL == context) {
         return;
     }
 
     GrCacheID::Domain domain = GrCacheID::GenerateDomain();
-    GrResourceKey::ResourceType t = GrResourceKey::GenerateResourceType();
 
     GrCacheID::Key key1Data;
     key1Data.fData64[0] = 0;
     key1Data.fData64[1] = 0;
-    GrResourceKey key1(GrCacheID(domain, key1Data), t, 0);
+    GrResourceKey key1(GrCacheID(domain, key1Data), 0);
 
     GrCacheID::Key key2Data;
     key2Data.fData64[0] = 1;
     key2Data.fData64[1] = 0;
-    GrResourceKey key2(GrCacheID(domain, key2Data), t, 0);
+    GrResourceKey key2(GrCacheID(domain, key2Data), 0);
 
     // Test changing resources sizes (both increase & decrease).
     {
         context->setResourceCacheLimits(3, 30000);
         GrResourceCache2* cache2 = context->getResourceCache2();
         cache2->purgeAllUnlocked();
         SkASSERT(0 == cache2->getResourceCount() && 0 == cache2->getResourceBytes());
 
         TestResource* a = new TestResource(context->getGpu());
         a->cacheAccess().setContentKey(key1);
@@ skipping 58 matching lines @@
     // Set the cache size to double the resource count because we're going to create 2x that number
     // resources, using two different key domains. Add a little slop to the bytes because we resize
     // down to 1 byte after creating the resource.
     context->setResourceCacheLimits(2 * kResourceCnt, 2 * kResourceCnt + 1000);
     GrResourceCache2* cache2 = context->getResourceCache2();
     cache2->purgeAllUnlocked();
     SkASSERT(0 == cache2->getResourceCount() && 0 == cache2->getResourceBytes());
 
     GrCacheID::Domain domain0 = GrCacheID::GenerateDomain();
     GrCacheID::Domain domain1 = GrCacheID::GenerateDomain();
-    GrResourceKey::ResourceType t = GrResourceKey::GenerateResourceType();
 
     GrCacheID::Key keyData;
     memset(&keyData, 0, sizeof(keyData));
 
     for (int i = 0; i < kResourceCnt; ++i) {
         TestResource* resource;
         keyData.fData32[0] = i;
 
-        GrResourceKey key0(GrCacheID(domain0, keyData), t, 0);
+        GrResourceKey key0(GrCacheID(domain0, keyData), 0);
         resource = SkNEW_ARGS(TestResource, (context->getGpu()));
         resource->cacheAccess().setContentKey(key0);
         resource->setSize(1);
         resource->unref();
 
-        GrResourceKey key1(GrCacheID(domain1, keyData), t, 0);
+        GrResourceKey key1(GrCacheID(domain1, keyData), 0);
         resource = SkNEW_ARGS(TestResource, (context->getGpu()));
         resource->cacheAccess().setContentKey(key1);
         resource->setSize(1);
         resource->unref();
     }
 
     REPORTER_ASSERT(reporter, TestResource::NumAlive() == 2 * kResourceCnt);
     REPORTER_ASSERT(reporter, cache2->getBudgetedResourceBytes() == 2 * kResourceCnt);
     REPORTER_ASSERT(reporter, cache2->getBudgetedResourceCount() == 2 * kResourceCnt);
     REPORTER_ASSERT(reporter, cache2->getResourceBytes() == 2 * kResourceCnt);
     REPORTER_ASSERT(reporter, cache2->getResourceCount() == 2 * kResourceCnt);
     for (int i = 0; i < kResourceCnt; ++i) {
         keyData.fData32[0] = i;
-        GrResourceKey key0(GrCacheID(domain0, keyData), t, 0);
+        GrResourceKey key0(GrCacheID(domain0, keyData), 0);
         REPORTER_ASSERT(reporter, cache2->hasContentKey(key0));
-        GrResourceKey key1(GrCacheID(domain0, keyData), t, 0);
+        GrResourceKey key1(GrCacheID(domain0, keyData), 0);
         REPORTER_ASSERT(reporter, cache2->hasContentKey(key1));
     }
 
     cache2->purgeAllUnlocked();
     REPORTER_ASSERT(reporter, TestResource::NumAlive() == 0);
     REPORTER_ASSERT(reporter, cache2->getBudgetedResourceBytes() == 0);
     REPORTER_ASSERT(reporter, cache2->getBudgetedResourceCount() == 0);
     REPORTER_ASSERT(reporter, cache2->getResourceBytes() == 0);
     REPORTER_ASSERT(reporter, cache2->getResourceCount() == 0);
 
     for (int i = 0; i < kResourceCnt; ++i) {
         keyData.fData32[0] = i;
-        GrResourceKey key0(GrCacheID(domain0, keyData), t, 0);
+        GrResourceKey key0(GrCacheID(domain0, keyData), 0);
         REPORTER_ASSERT(reporter, !cache2->hasContentKey(key0));
-        GrResourceKey key1(GrCacheID(domain0, keyData), t, 0);
+        GrResourceKey key1(GrCacheID(domain0, keyData), 0);
         REPORTER_ASSERT(reporter, !cache2->hasContentKey(key1));
     }
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 DEF_GPUTEST(ResourceCache, reporter, factory) {
     for (int type = 0; type < GrContextFactory::kLastGLContextType; ++type) {
         GrContextFactory::GLContextType glType = static_cast<GrContextFactory::GLContextType>(type);
         if (!GrContextFactory::IsRenderingGLContext(glType)) {
@@ skipping 19 matching lines @@
     test_duplicate_content_key(reporter);
     test_duplicate_scratch_key(reporter);
     test_remove_scratch_key(reporter);
     test_purge_invalidated(reporter);
     test_cache_chained_purge(reporter);
     test_resource_size_changed(reporter);
     test_large_resource_count(reporter);
 }
 
 #endif