Make uncached textures uncached from the get go.

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 48 matching lines @@
     }
 
     context->setResourceCacheLimits(oldMaxNum, oldMaxBytes);
 }
 
 class TestResource : public GrGpuResource {
     static const size_t kDefaultSize = 100;
 
 public:
     SK_DECLARE_INST_COUNT(TestResource);
-    TestResource(GrGpu* gpu, bool isWrapped)
-        : INHERITED(gpu, isWrapped)
+    TestResource(GrGpu* gpu, size_t size, GrGpuResource::LifeCycle lifeCycle)
+        : INHERITED(gpu, lifeCycle)
+        , fToDelete(NULL)
+        , fSize(size) {
+        ++fNumAlive;
+        this->registerWithCache();
+    }
+
+    TestResource(GrGpu* gpu, GrGpuResource::LifeCycle lifeCycle)
+        : INHERITED(gpu, lifeCycle)
         , fToDelete(NULL)
         , fSize(kDefaultSize) {
         ++fNumAlive;
         this->registerWithCache();
     }
 
     TestResource(GrGpu* gpu)
-        : INHERITED(gpu, false)
+        : INHERITED(gpu, kCached_LifeCycle)
         , fToDelete(NULL)
         , fSize(kDefaultSize) {
         ++fNumAlive;
         this->registerWithCache();
     }
 
     TestResource(GrGpu* gpu, const GrScratchKey& scratchKey)
-        : INHERITED(gpu, false)
+        : INHERITED(gpu, kCached_LifeCycle)
         , fToDelete(NULL)
         , fSize(kDefaultSize) {
         this->setScratchKey(scratchKey);
         ++fNumAlive;
         this->registerWithCache();
     }
 
     ~TestResource() {
         --fNumAlive;
         SkSafeUnref(fToDelete);
@@ skipping 26 matching lines @@
     REPORTER_ASSERT(reporter, SkToBool(context));
     if (NULL == context) {
         return;
     }
     context->setResourceCacheLimits(10, 30000);
     GrResourceCache2* cache2 = context->getResourceCache2();
     cache2->purgeAllUnlocked();
     SkASSERT(0 == cache2->getResourceCount() && 0 == cache2->getResourceBytes());
 
     // Create a bunch of resources with no keys
-    TestResource* a = new TestResource(context->getGpu());
-    TestResource* b = new TestResource(context->getGpu());
-    TestResource* c = new TestResource(context->getGpu());
-    TestResource* d = new TestResource(context->getGpu());
+    TestResource* a = SkNEW_ARGS(TestResource, (context->getGpu()));
+    TestResource* b = SkNEW_ARGS(TestResource, (context->getGpu()));
+    TestResource* c = SkNEW_ARGS(TestResource, (context->getGpu()));
+    TestResource* d = SkNEW_ARGS(TestResource, (context->getGpu()));
     a->setSize(11);
     b->setSize(12);
     c->setSize(13);
     d->setSize(14);
 
     REPORTER_ASSERT(reporter, 4 == TestResource::NumAlive());
     REPORTER_ASSERT(reporter, 4 == cache2->getResourceCount());
     REPORTER_ASSERT(reporter, a->gpuMemorySize() + b->gpuMemorySize() + c->gpuMemorySize() +
                               d->gpuMemorySize() == cache2->getResourceBytes());
 
@@ skipping 44 matching lines @@
     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 = new TestResource(context->getGpu(), scratchKey);
+    TestResource* scratch = SkNEW_ARGS(TestResource, (context->getGpu(), scratchKey));
     scratch->setSize(10);
-    TestResource* content = new TestResource(context->getGpu());
-    scratch->setSize(11);
+    TestResource* content = SkNEW_ARGS(TestResource, (context->getGpu()));
+    content->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());
+    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);
-    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), 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() +
@@ skipping 13 matching lines @@
     REPORTER_ASSERT(reporter, scratch->gpuMemorySize() + content->gpuMemorySize() ==
                               cache2->getBudgetedResourceBytes());
 
     // Unreffing the wrapped resource should free it right away.
     wrapped->unref();
     REPORTER_ASSERT(reporter, 3 == cache2->getResourceCount());
     REPORTER_ASSERT(reporter, scratch->gpuMemorySize() + content->gpuMemorySize() +
                               unbudgeted->gpuMemorySize() == cache2->getResourceBytes());
 
     // Now try freeing the budgeted resources first
-    wrapped = new TestResource(context->getGpu(), true);
+    wrapped = SkNEW_ARGS(TestResource, (context->getGpu(), GrGpuResource::kWrapped_LifeCycle));
     scratch->setSize(12);
     content->unref();
     cache2->purgeAllUnlocked();
     REPORTER_ASSERT(reporter, 3 == cache2->getResourceCount());
     REPORTER_ASSERT(reporter, scratch->gpuMemorySize() + wrapped->gpuMemorySize() +
                               unbudgeted->gpuMemorySize() == cache2->getResourceBytes());
     REPORTER_ASSERT(reporter, 1 == cache2->getBudgetedResourceCount());
     REPORTER_ASSERT(reporter, scratch->gpuMemorySize() == cache2->getBudgetedResourceBytes());
 
     scratch->unref();
     cache2->purgeAllUnlocked();
     REPORTER_ASSERT(reporter, 2 == cache2->getResourceCount());
     REPORTER_ASSERT(reporter, unbudgeted->gpuMemorySize() + wrapped->gpuMemorySize() ==
                               cache2->getResourceBytes());
     REPORTER_ASSERT(reporter, 0 == cache2->getBudgetedResourceCount());
     REPORTER_ASSERT(reporter, 0 == cache2->getBudgetedResourceBytes());
 
     wrapped->unref();
     REPORTER_ASSERT(reporter, 1 == cache2->getResourceCount());
     REPORTER_ASSERT(reporter, unbudgeted->gpuMemorySize() == cache2->getResourceBytes());
     REPORTER_ASSERT(reporter, 0 == cache2->getBudgetedResourceCount());
     REPORTER_ASSERT(reporter, 0 == cache2->getBudgetedResourceBytes());
 
     unbudgeted->unref();
     REPORTER_ASSERT(reporter, 0 == cache2->getResourceCount());
     REPORTER_ASSERT(reporter, 0 == cache2->getResourceBytes());
     REPORTER_ASSERT(reporter, 0 == cache2->getBudgetedResourceCount());
     REPORTER_ASSERT(reporter, 0 == cache2->getBudgetedResourceBytes());
+

[robertphillips, 2015/01/14 16:42:59]

At some point this could be broken into a test_unbudgeted subroutine (it seems
self contained and might better organize the test).

(very low priority suggestion)

[bsalomon, 2015/01/14 18:32:04]

Done.

+    // A large uncached or wrapped resource shouldn't evict anything.
+    scratch = SkNEW_ARGS(TestResource, (context->getGpu(), scratchKey));
+    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));
+    content->unref();
+    REPORTER_ASSERT(reporter, 2 == cache2->getResourceCount());
+    REPORTER_ASSERT(reporter, 21 == cache2->getResourceBytes());
+    REPORTER_ASSERT(reporter, 2 == cache2->getBudgetedResourceCount());
+    REPORTER_ASSERT(reporter, 21 == cache2->getBudgetedResourceBytes());
+
+    size_t large = 2 * cache2->getResourceBytes();
+    unbudgeted = SkNEW_ARGS(TestResource,
+                            (context->getGpu(), large, GrGpuResource::kUncached_LifeCycle));
+    REPORTER_ASSERT(reporter, 3 == cache2->getResourceCount());
+    REPORTER_ASSERT(reporter, 21 + large == cache2->getResourceBytes());
+    REPORTER_ASSERT(reporter, 2 == cache2->getBudgetedResourceCount());
+    REPORTER_ASSERT(reporter, 21 == cache2->getBudgetedResourceBytes());
+
+    unbudgeted->unref();
+    REPORTER_ASSERT(reporter, 2 == cache2->getResourceCount());
+    REPORTER_ASSERT(reporter, 21 == cache2->getResourceBytes());
+    REPORTER_ASSERT(reporter, 2 == cache2->getBudgetedResourceCount());
+    REPORTER_ASSERT(reporter, 21 == cache2->getBudgetedResourceBytes());
+
+    wrapped = SkNEW_ARGS(TestResource,
+                         (context->getGpu(), large, GrGpuResource::kWrapped_LifeCycle));
+    REPORTER_ASSERT(reporter, 3 == cache2->getResourceCount());
+    REPORTER_ASSERT(reporter, 21 + large == cache2->getResourceBytes());
+    REPORTER_ASSERT(reporter, 2 == cache2->getBudgetedResourceCount());
+    REPORTER_ASSERT(reporter, 21 == cache2->getBudgetedResourceBytes());
+
+    wrapped->unref();
+    REPORTER_ASSERT(reporter, 2 == cache2->getResourceCount());
+    REPORTER_ASSERT(reporter, 21 == cache2->getResourceBytes());
+    REPORTER_ASSERT(reporter, 2 == cache2->getBudgetedResourceCount());
+    REPORTER_ASSERT(reporter, 21 == cache2->getBudgetedResourceBytes());
+
+    cache2->purgeAllUnlocked();
+    REPORTER_ASSERT(reporter, 0 == cache2->getResourceCount());
+    REPORTER_ASSERT(reporter, 0 == cache2->getResourceBytes());
+    REPORTER_ASSERT(reporter, 0 == cache2->getBudgetedResourceCount());
+    REPORTER_ASSERT(reporter, 0 == cache2->getBudgetedResourceBytes());
 }
 
 static void test_duplicate_scratch_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());
 
     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);
+    TestResource* a = SkNEW_ARGS(TestResource, (context->getGpu(), scratchKey));
+    TestResource* b = SkNEW_ARGS(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());
     REPORTER_ASSERT(reporter, a->gpuMemorySize() + b->gpuMemorySize() ==
                               cache2->getResourceBytes());
 
     // Our refs mean that the resources are non purgable.
@@ skipping 22 matching lines @@
     }
     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 = new TestResource(context->getGpu(), scratchKey);
-    TestResource* b = new TestResource(context->getGpu(), scratchKey);
+    TestResource* a = SkNEW_ARGS(TestResource, (context->getGpu(), scratchKey));
+    TestResource* b = SkNEW_ARGS(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));)
     REPORTER_ASSERT(reporter, 2 == cache2->getResourceCount());
 
     // Find the first resource and remove its scratch key
     GrGpuResource* find;
@@ skipping 39 matching lines @@
     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);
     
     // 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());
+    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));
 
     // Still have two resources because b is still reffed.
     REPORTER_ASSERT(reporter, 2 == cache2->getResourceCount());
     REPORTER_ASSERT(reporter, a->gpuMemorySize() + b->gpuMemorySize() ==
@@ skipping 40 matching lines @@
     GrResourceKey key2(GrCacheID(domain, keyData), 0);
     keyData.fData64[0] = 3;
     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());
+    TestResource* a = SkNEW_ARGS(TestResource, (context->getGpu()));
+    TestResource* b = SkNEW_ARGS(TestResource, (context->getGpu()));
+    TestResource* c = SkNEW_ARGS(TestResource, (context->getGpu()));
     a->cacheAccess().setContentKey(key1);
     b->cacheAccess().setContentKey(key2);
     c->cacheAccess().setContentKey(key3);
     a->unref();
     b->unref();
     c->unref();
 
     REPORTER_ASSERT(reporter, cache2->hasContentKey(key1));
     REPORTER_ASSERT(reporter, cache2->hasContentKey(key2));
     REPORTER_ASSERT(reporter, cache2->hasContentKey(key3));
@@ skipping 43 matching lines @@
 
     keyData.fData64[0] = 2;
     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());
+        TestResource* a = SkNEW_ARGS(TestResource, (context->getGpu()));
+        TestResource* b = SkNEW_ARGS(TestResource, (context->getGpu()));
         a->cacheAccess().setContentKey(key1);
         b->cacheAccess().setContentKey(key2);
 
         // Make a cycle
         a->setUnrefWhenDestroyed(b);
         b->setUnrefWhenDestroyed(a);
 
         REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive());
 
         a->unref();
@@ skipping 32 matching lines @@
     key2Data.fData64[1] = 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());
+        TestResource* a = SkNEW_ARGS(TestResource, (context->getGpu()));
         a->cacheAccess().setContentKey(key1);
         a->unref();
 
-        TestResource* b = new TestResource(context->getGpu());
+        TestResource* b = SkNEW_ARGS(TestResource, (context->getGpu()));
         b->cacheAccess().setContentKey(key2);
         b->unref();
 
         REPORTER_ASSERT(reporter, 200 == cache2->getResourceBytes());
         REPORTER_ASSERT(reporter, 2 == cache2->getResourceCount());
         {
             SkAutoTUnref<TestResource> find2(static_cast<TestResource*>(cache2->findAndRefContentResource(key2)));
             find2->setSize(200);
             SkAutoTUnref<TestResource> find1(static_cast<TestResource*>(cache2->findAndRefContentResource(key1)));
             find1->setSize(50);
         }
 
         REPORTER_ASSERT(reporter, 250 == cache2->getResourceBytes());
         REPORTER_ASSERT(reporter, 2 == cache2->getResourceCount());
     }
 
     // Test increasing a resources size beyond the cache budget.
     {
         context->setResourceCacheLimits(2, 300);
         GrResourceCache2* cache2 = context->getResourceCache2();
         cache2->purgeAllUnlocked();
         SkASSERT(0 == cache2->getResourceCount() && 0 == cache2->getResourceBytes());
 
-        TestResource* a = new TestResource(context->getGpu());
+        TestResource* a = SkNEW_ARGS(TestResource, (context->getGpu()));
         a->setSize(100);
         a->cacheAccess().setContentKey(key1);
         a->unref();
 
-        TestResource* b = new TestResource(context->getGpu());
+        TestResource* b = SkNEW_ARGS(TestResource, (context->getGpu()));
         b->setSize(100);
         b->cacheAccess().setContentKey(key2);
         b->unref();
 
         REPORTER_ASSERT(reporter, 200 == cache2->getResourceBytes());
         REPORTER_ASSERT(reporter, 2 == cache2->getResourceCount());
 
         {
             SkAutoTUnref<TestResource> find2(static_cast<TestResource*>(cache2->findAndRefContentResource(key2)));
             find2->setSize(201);
@@ skipping 101 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