Add specialized content key class for resources.

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 102 matching lines @@
 
     static int NumAlive() { return fNumAlive; }
 
     void setUnrefWhenDestroyed(TestResource* resource) {
         SkRefCnt_SafeAssign(fToDelete, resource);
     }
 
     static void ComputeScratchKey(SimulatedProperty property, GrScratchKey* key) {
         static GrScratchKey::ResourceType t = GrScratchKey::GenerateResourceType();
         GrScratchKey::Builder builder(key, t, kScratchKeyFieldCnt);
-        for (size_t i = 0; i < kScratchKeyFieldCnt; ++i) {
-            builder[i] = i + static_cast<int>(property);
+        for (int i = 0; i < kScratchKeyFieldCnt; ++i) {
+            builder[i] = static_cast<uint32_t>(i + property);
         }
     }
 
     static size_t ExpectedScratchKeySize() {
         return sizeof(uint32_t) * (kScratchKeyFieldCnt + GrScratchKey::kMetaDataCnt);
     }
 
 private:
-    static const size_t kScratchKeyFieldCnt = 6;
+    static const int kScratchKeyFieldCnt = 6;
 
     TestResource(GrGpu* gpu, SimulatedProperty property, ScratchConstructor)
         : INHERITED(gpu, kCached_LifeCycle)
         , fToDelete(NULL)
         , fSize(kDefaultSize)
         , fProperty(property) {
         GrScratchKey scratchKey;
         ComputeScratchKey(fProperty, &scratchKey);
         this->setScratchKey(scratchKey);
         ++fNumAlive;
@@ skipping 58 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());
 }
 
+// Each integer passed as a template param creates a new domain.
+template <int> static void make_content_key(GrContentKey* key, int data) {
+    static GrContentKey::Domain d = GrContentKey::GenerateDomain();
+    GrContentKey::Builder builder(key, d, 1);
+    builder[0] = data;
+}
+
 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());
 
-    GrCacheID::Key keyData;
-    memset(&keyData, 0, sizeof(keyData));
-    GrResourceKey contentKey(GrCacheID(GrCacheID::GenerateDomain(), keyData), 0);
+    GrContentKey contentKey;
+    make_content_key<0>(&contentKey, 0);
 
     // Create a scratch, a content, and a wrapped resource
     TestResource* scratch =
             TestResource::CreateScratchTestResource(context->getGpu(),
                                                     TestResource::kProperty2_SimulatedProperty);
     scratch->setSize(10);
     TestResource* content = SkNEW_ARGS(TestResource, (context->getGpu()));
     content->setSize(11);
     REPORTER_ASSERT(reporter, content->cacheAccess().setContentKey(contentKey));
     TestResource* wrapped = SkNEW_ARGS(TestResource,
                                        (context->getGpu(), GrGpuResource::kWrapped_LifeCycle));
     wrapped->setSize(12);
     TestResource* unbudgeted = SkNEW_ARGS(TestResource,
                                           (context->getGpu(), GrGpuResource::kUncached_LifeCycle));
     unbudgeted->setSize(13);
 
     // Make sure we can't add a content key to the wrapped resource
-    keyData.fData8[0] = 1;
-    GrResourceKey contentKey2(GrCacheID(GrCacheID::GenerateDomain(), keyData), 0);
+    GrContentKey contentKey2;
+    make_content_key<0>(&contentKey2, 1);
     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 52 matching lines @@
     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());
 
-    GrCacheID::Key keyData;
-    memset(&keyData, 0, sizeof(keyData));
-    GrResourceKey contentKey(GrCacheID(GrCacheID::GenerateDomain(), keyData), 0);
+    GrContentKey contentKey;
+    make_content_key<0>(&contentKey, 0);
 
     TestResource* scratch;
     TestResource* content;
     TestResource* wrapped;
     TestResource* unbudgeted;
 
     // A large uncached or wrapped resource shouldn't evict anything.
     scratch = TestResource::CreateScratchTestResource(context->getGpu(),
                                                       TestResource::kProperty2_SimulatedProperty);
     scratch->setSize(10);
@@ skipping 238 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::Domain domain = GrCacheID::GenerateDomain();
-    GrCacheID::Key keyData;
-    memset(&keyData, 0, sizeof(keyData));
-    GrResourceKey key(GrCacheID(domain, keyData), 0);
+    GrContentKey key;
+    make_content_key<0>(&key, 0);
     
     // Create two resources that we will attempt to register with the same content key.
     TestResource* a = SkNEW_ARGS(TestResource, (context->getGpu()));
     TestResource* b = SkNEW_ARGS(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 27 matching lines @@
     REPORTER_ASSERT(reporter, 0 == TestResource::NumAlive());
 }
 
 static void test_purge_invalidated(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));
-
-    keyData.fData64[0] = 1;
-    GrResourceKey key1(GrCacheID(domain, keyData), 0);
-    keyData.fData64[0] = 2;
-    GrResourceKey key2(GrCacheID(domain, keyData), 0);
-    keyData.fData64[0] = 3;
-    GrResourceKey key3(GrCacheID(domain, keyData), 0);
+    GrContentKey key1, key2, key3;
+    make_content_key<0>(&key1, 1);
+    make_content_key<0>(&key2, 2);
+    make_content_key<0>(&key3, 3);
     
     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 = SkNEW_ARGS(TestResource, (context->getGpu()));
     TestResource* b = SkNEW_ARGS(TestResource, (context->getGpu()));
     TestResource* c = SkNEW_ARGS(TestResource, (context->getGpu()));
@@ skipping 37 matching lines @@
     REPORTER_ASSERT(reporter, 0 == cache2->getResourceBytes());
 }
 
 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));
-
-    keyData.fData64[0] = 1;
-    GrResourceKey key1(GrCacheID(domain, keyData), 0);
-
-    keyData.fData64[0] = 2;
-    GrResourceKey key2(GrCacheID(domain, keyData), 0);
+    GrContentKey key1, key2;
+    make_content_key<0>(&key1, 1);
+    make_content_key<0>(&key2, 2);
 
     {
         context->setResourceCacheLimits(3, 30000);
         GrResourceCache2* cache2 = context->getResourceCache2();
         cache2->purgeAllUnlocked();
         SkASSERT(0 == cache2->getResourceCount() && 0 == cache2->getResourceBytes());
 
         TestResource* a = SkNEW_ARGS(TestResource, (context->getGpu()));
         TestResource* b = SkNEW_ARGS(TestResource, (context->getGpu()));
         a->cacheAccess().setContentKey(key1);
@@ skipping 22 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();
-
-    GrCacheID::Key key1Data;
-    key1Data.fData64[0] = 0;
-    key1Data.fData64[1] = 0;
-    GrResourceKey key1(GrCacheID(domain, key1Data), 0);
-
-    GrCacheID::Key key2Data;
-    key2Data.fData64[0] = 1;
-    key2Data.fData64[1] = 0;
-    GrResourceKey key2(GrCacheID(domain, key2Data), 0);
+    GrContentKey key1, key2;
+    make_content_key<0>(&key1, 1);
+    make_content_key<0>(&key2, 2);
 
     // 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 = SkNEW_ARGS(TestResource, (context->getGpu()));
         a->cacheAccess().setContentKey(key1);
@@ skipping 56 matching lines @@
 
     static const int kResourceCnt = 2000;
     // 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();
-
-    GrCacheID::Key keyData;
-    memset(&keyData, 0, sizeof(keyData));
 
     for (int i = 0; i < kResourceCnt; ++i) {
+        GrContentKey key1, key2;
+        make_content_key<1>(&key1, i);
+        make_content_key<2>(&key2, i);
+
         TestResource* resource;
-        keyData.fData32[0] = i;
 
-        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), 0);
         resource = SkNEW_ARGS(TestResource, (context->getGpu()));
         resource->cacheAccess().setContentKey(key1);
         resource->setSize(1);
         resource->unref();
+
+        resource = SkNEW_ARGS(TestResource, (context->getGpu()));
+        resource->cacheAccess().setContentKey(key2);
+        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), 0);
-        REPORTER_ASSERT(reporter, cache2->hasContentKey(key0));
-        GrResourceKey key1(GrCacheID(domain0, keyData), 0);
+        GrContentKey key1, key2;
+        make_content_key<1>(&key1, i);
+        make_content_key<2>(&key2, i);
+
         REPORTER_ASSERT(reporter, cache2->hasContentKey(key1));
+        REPORTER_ASSERT(reporter, cache2->hasContentKey(key2));
     }
 
     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), 0);
-        REPORTER_ASSERT(reporter, !cache2->hasContentKey(key0));
-        GrResourceKey key1(GrCacheID(domain0, keyData), 0);
+        GrContentKey key1, key2;
+        make_content_key<1>(&key1, i);
+        make_content_key<2>(&key2, i);
+
         REPORTER_ASSERT(reporter, !cache2->hasContentKey(key1));
+        REPORTER_ASSERT(reporter, !cache2->hasContentKey(key2));
     }
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 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)) {
             continue;
@@ skipping 21 matching lines @@
     test_duplicate_scratch_key(reporter);
     test_remove_scratch_key(reporter);
     test_scratch_key_consistency(reporter);
     test_purge_invalidated(reporter);
     test_cache_chained_purge(reporter);
     test_resource_size_changed(reporter);
     test_large_resource_count(reporter);
 }
 
 #endif