Reland https://codereview.chromium.org/860333002 with fix for test failures.

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 45 matching lines @@
 
         // we should never go over the size limit
         REPORTER_ASSERT(reporter, curCacheSize <= maxCacheSize);
     }
 
     context->setResourceCacheLimits(oldMaxNum, oldMaxBytes);
 }
 
 class TestResource : public GrGpuResource {
     static const size_t kDefaultSize = 100;
-
+    enum ScratchConstructor { kScratchConstructor };
 public:
     SK_DECLARE_INST_COUNT(TestResource);
+    /** Property that distinctly categorizes the resource.
+     * For example, textures have width, height, ... */
+    enum SimulatedProperty { kProperty1_SimulatedProperty, kProperty2_SimulatedProperty };
+
     TestResource(GrGpu* gpu, size_t size, GrGpuResource::LifeCycle lifeCycle)
         : INHERITED(gpu, lifeCycle)
         , fToDelete(NULL)
-        , fSize(size) {
+        , fSize(size)
+        , fProperty(kProperty1_SimulatedProperty) {
         ++fNumAlive;
         this->registerWithCache();
     }
 
     TestResource(GrGpu* gpu, GrGpuResource::LifeCycle lifeCycle)
         : INHERITED(gpu, lifeCycle)
         , fToDelete(NULL)
-        , fSize(kDefaultSize) {
+        , fSize(kDefaultSize)
+        , fProperty(kProperty1_SimulatedProperty) {
         ++fNumAlive;
         this->registerWithCache();
     }
 
     TestResource(GrGpu* gpu)
         : INHERITED(gpu, kCached_LifeCycle)
         , fToDelete(NULL)
-        , fSize(kDefaultSize) {
+        , fSize(kDefaultSize)
+        , fProperty(kProperty1_SimulatedProperty) {
         ++fNumAlive;
         this->registerWithCache();
     }
 
-    TestResource(GrGpu* gpu, const GrScratchKey& scratchKey)
-        : INHERITED(gpu, kCached_LifeCycle)
-        , fToDelete(NULL)
-        , fSize(kDefaultSize) {
-        this->setScratchKey(scratchKey);
-        ++fNumAlive;
-        this->registerWithCache();
+    static TestResource* CreateScratchTestResource(GrGpu* gpu, SimulatedProperty property) {
+        return SkNEW_ARGS(TestResource, (gpu, property, kScratchConstructor));
     }
 
     ~TestResource() {
         --fNumAlive;
         SkSafeUnref(fToDelete);
     }
 
     void setSize(size_t size) {
         fSize = size;
         this->didChangeGpuMemorySize();
     }
 
     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);
+        }
+    }
+
+    static size_t ExpectedScratchKeySize() {
+        return sizeof(uint32_t) * (kScratchKeyFieldCnt + GrScratchKey::kMetaDataCnt);
+    }
+
 private:
+    static const size_t 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;
+        this->registerWithCache();
+    }
+
     size_t onGpuMemorySize() const SK_OVERRIDE { return fSize; }
 
     TestResource* fToDelete;
     size_t fSize;
     static int fNumAlive;
-
+    SimulatedProperty fProperty;
     typedef GrGpuResource INHERITED;
 };
 int TestResource::fNumAlive = 0;
 
 static void test_no_key(skiatest::Reporter* reporter) {
     SkAutoTUnref<GrContext> context(GrContext::CreateMockContext());
     REPORTER_ASSERT(reporter, SkToBool(context));
     if (NULL == context) {
         return;
     }
@@ skipping 39 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 contentKey(GrCacheID(GrCacheID::GenerateDomain(), keyData), 0);
 
     // Create a scratch, a content, and a wrapped resource
-    TestResource* scratch = SkNEW_ARGS(TestResource, (context->getGpu(), scratchKey));
+    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);
@@ skipping 66 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());
 
-    GrScratchKey scratchKey;
-    make_scratch_key(&scratchKey);
-
     GrCacheID::Key keyData;
     memset(&keyData, 0, sizeof(keyData));
     GrResourceKey contentKey(GrCacheID(GrCacheID::GenerateDomain(), keyData), 0);
 
     TestResource* scratch;
     TestResource* content;
     TestResource* wrapped;
     TestResource* unbudgeted;
 
     // A large uncached or wrapped resource shouldn't evict anything.
-    scratch = SkNEW_ARGS(TestResource, (context->getGpu(), scratchKey));
+    scratch = TestResource::CreateScratchTestResource(context->getGpu(),
+                                                      TestResource::kProperty2_SimulatedProperty);
     scratch->setSize(10);
     scratch->unref();
     REPORTER_ASSERT(reporter, 1 == cache2->getResourceCount());
     REPORTER_ASSERT(reporter, 10 == cache2->getResourceBytes());
     REPORTER_ASSERT(reporter, 1 == cache2->getBudgetedResourceCount());
     REPORTER_ASSERT(reporter, 10 == cache2->getBudgetedResourceBytes());
 
     content = SkNEW_ARGS(TestResource, (context->getGpu()));
     content->setSize(11);
     REPORTER_ASSERT(reporter, content->cacheAccess().setContentKey(contentKey));
@@ skipping 41 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());
 
-    GrScratchKey scratchKey;
-    make_scratch_key(&scratchKey);
-
     // Create two resources that have the same scratch key.
-    TestResource* a = SkNEW_ARGS(TestResource, (context->getGpu(), scratchKey));
-    TestResource* b = SkNEW_ARGS(TestResource, (context->getGpu(), scratchKey));
+    TestResource* a =
+            TestResource::CreateScratchTestResource(context->getGpu(),
+                                                    TestResource::kProperty2_SimulatedProperty);
+    TestResource* b =
+            TestResource::CreateScratchTestResource(context->getGpu(),
+                                                    TestResource::kProperty2_SimulatedProperty);
     a->setSize(11);
     b->setSize(12);
+    GrScratchKey scratchKey1;
+    TestResource::ComputeScratchKey(TestResource::kProperty1_SimulatedProperty, &scratchKey1);
+    // Check for negative case consistency. (leaks upon test failure.)
+    REPORTER_ASSERT(reporter, NULL == cache2->findAndRefScratchResource(scratchKey1));
+
+    GrScratchKey scratchKey;
+    TestResource::ComputeScratchKey(TestResource::kProperty2_SimulatedProperty, &scratchKey);
+
     // 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());
     REPORTER_ASSERT(reporter, a->gpuMemorySize() + b->gpuMemorySize() ==
                               cache2->getResourceBytes());
 
     // Our refs mean that the resources are non purgable.
     cache2->purgeAllUnlocked();
     REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive());
@@ skipping 16 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());
 
-    GrScratchKey scratchKey;
-    make_scratch_key(&scratchKey);
-
     // Create two resources that have the same scratch key.
-    TestResource* a = SkNEW_ARGS(TestResource, (context->getGpu(), scratchKey));
-    TestResource* b = SkNEW_ARGS(TestResource, (context->getGpu(), scratchKey));
+    TestResource* a =
+            TestResource::CreateScratchTestResource(context->getGpu(),
+                                                    TestResource::kProperty2_SimulatedProperty);
+    TestResource* b =
+            TestResource::CreateScratchTestResource(context->getGpu(),
+                                                    TestResource::kProperty2_SimulatedProperty);
     a->unref();
     b->unref();
 
+
+    GrScratchKey scratchKey;
+    // Ensure that scratch key lookup is correct for negative case.
+    TestResource::ComputeScratchKey(TestResource::kProperty1_SimulatedProperty, &scratchKey);
+    // (following leaks upon test failure).
+    REPORTER_ASSERT(reporter, cache2->findAndRefScratchResource(scratchKey) == NULL);
+
     // Scratch resources are registered with GrResourceCache2 just by existing. There are 2.
+    TestResource::ComputeScratchKey(TestResource::kProperty2_SimulatedProperty, &scratchKey);
     REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive());
     SkDEBUGCODE(REPORTER_ASSERT(reporter, 2 == cache2->countScratchEntriesForKey(scratchKey));)
     REPORTER_ASSERT(reporter, 2 == cache2->getResourceCount());
 
     // Find the first resource and remove its scratch key
     GrGpuResource* find;
     find = cache2->findAndRefScratchResource(scratchKey);
     find->cacheAccess().removeScratchKey();
     // It's still alive, but not cached by scratch key anymore
     REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive());
@@ skipping 18 matching lines @@
     REPORTER_ASSERT(reporter, 1 == TestResource::NumAlive());
     SkDEBUGCODE(REPORTER_ASSERT(reporter, 0 == cache2->countScratchEntriesForKey(scratchKey));)
     REPORTER_ASSERT(reporter, 1 == cache2->getResourceCount());
 
     find->unref();
     REPORTER_ASSERT(reporter, 0 == TestResource::NumAlive());
     SkDEBUGCODE(REPORTER_ASSERT(reporter, 0 == cache2->countScratchEntriesForKey(scratchKey));)
     REPORTER_ASSERT(reporter, 0 == cache2->getResourceCount());
 }
 
+static void test_scratch_key_consistency(skiatest::Reporter* reporter) {
+    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());
+
+    // Create two resources that have the same scratch key.
+    TestResource* a =
+            TestResource::CreateScratchTestResource(context->getGpu(),
+                                                    TestResource::kProperty2_SimulatedProperty);
+    TestResource* b =
+            TestResource::CreateScratchTestResource(context->getGpu(),
+                                                    TestResource::kProperty2_SimulatedProperty);
+    a->unref();
+    b->unref();
+
+    GrScratchKey scratchKey;
+    // Ensure that scratch key comparison and assignment is consistent.
+    GrScratchKey scratchKey1;
+    TestResource::ComputeScratchKey(TestResource::kProperty1_SimulatedProperty, &scratchKey1);
+    GrScratchKey scratchKey2;
+    TestResource::ComputeScratchKey(TestResource::kProperty2_SimulatedProperty, &scratchKey2);
+    REPORTER_ASSERT(reporter, scratchKey1.size() == TestResource::ExpectedScratchKeySize());
+    REPORTER_ASSERT(reporter, scratchKey1 != scratchKey2);
+    REPORTER_ASSERT(reporter, scratchKey2 != scratchKey1);
+    scratchKey = scratchKey1;
+    REPORTER_ASSERT(reporter, scratchKey.size() == TestResource::ExpectedScratchKeySize());
+    REPORTER_ASSERT(reporter, scratchKey1 == scratchKey);
+    REPORTER_ASSERT(reporter, scratchKey == scratchKey1);
+    REPORTER_ASSERT(reporter, scratchKey2 != scratchKey);
+    REPORTER_ASSERT(reporter, scratchKey != scratchKey2);
+    scratchKey = scratchKey2;
+    REPORTER_ASSERT(reporter, scratchKey.size() == TestResource::ExpectedScratchKeySize());
+    REPORTER_ASSERT(reporter, scratchKey1 != scratchKey);
+    REPORTER_ASSERT(reporter, scratchKey != scratchKey1);
+    REPORTER_ASSERT(reporter, scratchKey2 == scratchKey);
+    REPORTER_ASSERT(reporter, scratchKey == scratchKey2);
+
+    // Ensure that scratch key lookup is correct for negative case.
+    TestResource::ComputeScratchKey(TestResource::kProperty1_SimulatedProperty, &scratchKey);
+    // (following leaks upon test failure).
+    REPORTER_ASSERT(reporter, cache2->findAndRefScratchResource(scratchKey) == NULL);
+
+    // Find the first resource with a scratch key and a copy of a scratch key.
+    TestResource::ComputeScratchKey(TestResource::kProperty2_SimulatedProperty, &scratchKey);
+    GrGpuResource* find = cache2->findAndRefScratchResource(scratchKey);
+    REPORTER_ASSERT(reporter, find != NULL);
+    find->unref();
+
+    scratchKey2 = scratchKey;
+    find = cache2->findAndRefScratchResource(scratchKey2);
+    REPORTER_ASSERT(reporter, find != NULL);
+    REPORTER_ASSERT(reporter, find == a || find == b);
+
+    GrGpuResource* find2 = cache2->findAndRefScratchResource(scratchKey2);
+    REPORTER_ASSERT(reporter, find2 != NULL);
+    REPORTER_ASSERT(reporter, find2 == a || find2 == b);
+    REPORTER_ASSERT(reporter, find2 != find);
+    find2->unref();
+    find->unref();
+}
+
 static void test_duplicate_content_key(skiatest::Reporter* reporter) {
     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());
@@ skipping 329 matching lines @@
         test_cache(reporter, context, surface->getCanvas());
     }
 
     // The below tests create their own mock contexts.
     test_no_key(reporter);
     test_budgeting(reporter);
     test_unbudgeted(reporter);
     test_duplicate_content_key(reporter);
     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