Allow unbudgeted resources to be recycled by the cache as scratch.

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 79 matching lines @@
 
     TestResource(GrGpu* gpu)
         : INHERITED(gpu, kCached_LifeCycle)
         , fToDelete(NULL)
         , fSize(kDefaultSize)
         , fProperty(kProperty1_SimulatedProperty) {
         ++fNumAlive;
         this->registerWithCache();
     }
 
-    static TestResource* CreateScratchTestResource(GrGpu* gpu, SimulatedProperty property) {
-        return SkNEW_ARGS(TestResource, (gpu, property, kScratchConstructor));
+    static TestResource* CreateScratchTestResource(GrGpu* gpu,
+                                                   SimulatedProperty property,
+                                                   bool cached = true) {
+        return SkNEW_ARGS(TestResource, (gpu, property, cached, kScratchConstructor));
     }
 
     ~TestResource() {
         --fNumAlive;
         SkSafeUnref(fToDelete);
     }
 
     void setSize(size_t size) {
         fSize = size;
         this->didChangeGpuMemorySize();
@@ skipping 13 matching lines @@
         }
     }
 
     static size_t ExpectedScratchKeySize() {
         return sizeof(uint32_t) * (kScratchKeyFieldCnt + GrScratchKey::kMetaDataCnt);
     }
 
 private:
     static const int kScratchKeyFieldCnt = 6;
 
-    TestResource(GrGpu* gpu, SimulatedProperty property, ScratchConstructor)
-        : INHERITED(gpu, kCached_LifeCycle)
+    TestResource(GrGpu* gpu, SimulatedProperty property, bool cached, ScratchConstructor)
+        : INHERITED(gpu, cached ? kCached_LifeCycle : kUncached_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;
 
+class Mock {
+public:
+    Mock(int maxCnt, size_t maxBytes) {
+        fContext.reset(GrContext::CreateMockContext());
+        SkASSERT(fContext);
+        fContext->setResourceCacheLimits(maxCnt, maxBytes);
+        GrResourceCache2* cache2 = fContext->getResourceCache2();
+        cache2->purgeAllUnlocked();
+        SkASSERT(0 == cache2->getResourceCount() && 0 == cache2->getResourceBytes());
+    }
+
+    GrResourceCache2* cache() { return fContext->getResourceCache2(); }
+
+    GrContext* context() { return fContext; }
+
+private:
+    SkAutoTUnref<GrContext> fContext;
+};
+
 static void test_no_key(skiatest::Reporter* reporter) {
-    SkAutoTUnref<GrContext> context(GrContext::CreateMockContext());
-    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());
+    Mock mock(10, 30000);
+    GrContext* context = mock.context();
+    GrResourceCache2* cache2 = mock.cache();
 
     // Create a bunch of resources with no keys
     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);
@@ skipping 33 matching lines @@
 }
 
 // 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());
+    Mock mock(10, 300);
+    GrContext* context = mock.context();
+    GrResourceCache2* cache2 = mock.cache();
 
     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()));
@@ skipping 63 matching lines @@
     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());
 }
 
 static void test_unbudgeted(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());
+    Mock mock(10, 30000);
+    GrContext* context = mock.context();
+    GrResourceCache2* cache2 = mock.cache();
 
     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.
@@ skipping 42 matching lines @@
     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_unbudgeted_to_scratch(skiatest::Reporter* reporter) {
+    Mock mock(10, 300);
+    GrContext* context = mock.context();
+    GrResourceCache2* cache2 = mock.cache();
+
+    TestResource* resource =
+        TestResource::CreateScratchTestResource(context->getGpu(),
+                                                TestResource::kProperty1_SimulatedProperty, false);
+    GrScratchKey key;
+    TestResource::ComputeScratchKey(TestResource::kProperty1_SimulatedProperty, &key);
+
+    size_t size = resource->gpuMemorySize();
+    for (int i = 0; i < 2; ++i) {
+        // Since this resource is unbudgeted, it should not be reachable as scratch.
+        REPORTER_ASSERT(reporter, resource->cacheAccess().getScratchKey() == key);
+        REPORTER_ASSERT(reporter, !resource->cacheAccess().isScratch());
+        REPORTER_ASSERT(reporter, !resource->cacheAccess().isBudgeted());
+        REPORTER_ASSERT(reporter, NULL == cache2->findAndRefScratchResource(key));
+        REPORTER_ASSERT(reporter, 1 == cache2->getResourceCount());
+        REPORTER_ASSERT(reporter, size == cache2->getResourceBytes());
+        REPORTER_ASSERT(reporter, 0 == cache2->getBudgetedResourceCount());
+        REPORTER_ASSERT(reporter, 0 == cache2->getBudgetedResourceBytes());
+
+        // Once it is unrefed, it should become available as scratch.
+        resource->unref();
+        REPORTER_ASSERT(reporter, 1 == cache2->getResourceCount());
+        REPORTER_ASSERT(reporter, size == cache2->getResourceBytes());
+        REPORTER_ASSERT(reporter, 1 == cache2->getBudgetedResourceCount());
+        REPORTER_ASSERT(reporter, size == cache2->getBudgetedResourceBytes());
+        resource = static_cast<TestResource*>(cache2->findAndRefScratchResource(key));
+        REPORTER_ASSERT(reporter, resource);
+        REPORTER_ASSERT(reporter, resource->cacheAccess().getScratchKey() == key);
+        REPORTER_ASSERT(reporter, resource->cacheAccess().isScratch());
+        REPORTER_ASSERT(reporter, resource->cacheAccess().isBudgeted());
+
+        if (0 == i) {
+            // If made unbudgeted, it should return to original state: ref'ed and unbudgeted. Try 
+            // the above tests again.
+            resource->cacheAccess().makeUnbudgeted();
+        } else {
+            // After the second time around, try removing the scratch key
+            resource->cacheAccess().removeScratchKey();
+            REPORTER_ASSERT(reporter, 1 == cache2->getResourceCount());
+            REPORTER_ASSERT(reporter, size == cache2->getResourceBytes());
+            REPORTER_ASSERT(reporter, 1 == cache2->getBudgetedResourceCount());
+            REPORTER_ASSERT(reporter, size == cache2->getBudgetedResourceBytes());
+            REPORTER_ASSERT(reporter, !resource->cacheAccess().getScratchKey().isValid());
+            REPORTER_ASSERT(reporter, !resource->cacheAccess().isScratch());
+            REPORTER_ASSERT(reporter, resource->cacheAccess().isBudgeted());
+
+            // now when it is unrefed it should die since it has no key.
+            resource->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());
+        }
+    }
+}
+
 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());
+    Mock mock(5, 30000);
+    GrContext* context = mock.context();
+    GrResourceCache2* cache2 = mock.cache();
 
     // 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->setSize(11);
     b->setSize(12);
@@ skipping 24 matching lines @@
     SkDEBUGCODE(REPORTER_ASSERT(reporter, 2 == cache2->countScratchEntriesForKey(scratchKey));)
 
     // Purge again. This time resources should be purgable.
     cache2->purgeAllUnlocked();
     REPORTER_ASSERT(reporter, 0 == TestResource::NumAlive());
     REPORTER_ASSERT(reporter, 0 == cache2->getResourceCount());
     SkDEBUGCODE(REPORTER_ASSERT(reporter, 0 == cache2->countScratchEntriesForKey(scratchKey));)
 }
 
 static void test_remove_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());
+    Mock mock(5, 30000);
+    GrContext* context = mock.context();
+    GrResourceCache2* cache2 = mock.cache();
 
     // 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();
@@ skipping 39 matching lines @@
     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());
+    Mock mock(5, 30000);
+    GrContext* context = mock.context();
+    GrResourceCache2* cache2 = mock.cache();
 
     // 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();
@@ skipping 38 matching lines @@
 
     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());
+    Mock mock(5, 30000);
+    GrContext* context = mock.context();
+    GrResourceCache2* cache2 = mock.cache();
 
     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);
     
@@ skipping 24 matching lines @@
     REPORTER_ASSERT(reporter, a->gpuMemorySize() == cache2->getResourceBytes());
     REPORTER_ASSERT(reporter, 1 == TestResource::NumAlive());
 
     cache2->purgeAllUnlocked();
     REPORTER_ASSERT(reporter, 0 == cache2->getResourceCount());
     REPORTER_ASSERT(reporter, 0 == cache2->getResourceBytes());
     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;
-    }
+    Mock mock(5, 30000);
+    GrContext* context = mock.context();
+    GrResourceCache2* cache2 = mock.cache();
 
     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()));
     a->cacheAccess().setContentKey(key1);
     b->cacheAccess().setContentKey(key2);
     c->cacheAccess().setContentKey(key3);
     a->unref();
     b->unref();
     c->unref();
@@ skipping 25 matching lines @@
     REPORTER_ASSERT(reporter, !cache2->hasContentKey(key3));
 #endif
 
     cache2->purgeAllUnlocked();
     REPORTER_ASSERT(reporter, 0 == TestResource::NumAlive());
     REPORTER_ASSERT(reporter, 0 == cache2->getResourceCount());
     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;
-    }
+    Mock mock(3, 30000);
+    GrContext* context = mock.context();
+    GrResourceCache2* cache2 = mock.cache();
 
     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);
-        b->cacheAccess().setContentKey(key2);
+    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);
+    // Make a cycle
+    a->setUnrefWhenDestroyed(b);
+    b->setUnrefWhenDestroyed(a);
 
-        REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive());
+    REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive());
 
-        a->unref();
-        b->unref();
+    a->unref();
+    b->unref();
 
-        REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive());
+    REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive());
 
-        cache2->purgeAllUnlocked();
-        REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive());
+    cache2->purgeAllUnlocked();
+    REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive());
 
-        // Break the cycle
-        a->setUnrefWhenDestroyed(NULL);
-        REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive());
+    // Break the cycle
+    a->setUnrefWhenDestroyed(NULL);
+    REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive());
 
-        cache2->purgeAllUnlocked();
-        REPORTER_ASSERT(reporter, 0 == TestResource::NumAlive());
-    }
+    cache2->purgeAllUnlocked();
+    REPORTER_ASSERT(reporter, 0 == TestResource::NumAlive());
 }
 
 static void test_resource_size_changed(skiatest::Reporter* reporter) {
-    SkAutoTUnref<GrContext> context(GrContext::CreateMockContext());
-    REPORTER_ASSERT(reporter, SkToBool(context));
-    if (NULL == context) {
-        return;
-    }
-
     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());
+        Mock mock(3, 30000);
+        GrContext* context = mock.context();
+        GrResourceCache2* cache2 = mock.cache();
 
         TestResource* a = SkNEW_ARGS(TestResource, (context->getGpu()));
         a->cacheAccess().setContentKey(key1);
         a->unref();
 
         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());
+        Mock mock(2, 300);
+        GrContext* context = mock.context();
+        GrResourceCache2* cache2 = mock.cache();
 
         TestResource* a = SkNEW_ARGS(TestResource, (context->getGpu()));
         a->setSize(100);
         a->cacheAccess().setContentKey(key1);
         a->unref();
 
         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);
         }
         REPORTER_ASSERT(reporter, !cache2->hasContentKey(key1));
 
         REPORTER_ASSERT(reporter, 201 == cache2->getResourceBytes());
         REPORTER_ASSERT(reporter, 1 == cache2->getResourceCount());
     }
 }
 
 static void test_large_resource_count(skiatest::Reporter* reporter) {
-    SkAutoTUnref<GrContext> context(GrContext::CreateMockContext());
-    REPORTER_ASSERT(reporter, SkToBool(context));
-    if (NULL == context) {
-        return;
-    }
-
-    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());
+    static const int kResourceCnt = 2000;
 
+    Mock mock(2 * kResourceCnt, 2 * kResourceCnt + 1000);
+    GrContext* context = mock.context();
+    GrResourceCache2* cache2 = mock.cache();
 
     for (int i = 0; i < kResourceCnt; ++i) {
         GrContentKey key1, key2;
         make_content_key<1>(&key1, i);
         make_content_key<2>(&key2, i);
 
         TestResource* resource;
 
         resource = SkNEW_ARGS(TestResource, (context->getGpu()));
         resource->cacheAccess().setContentKey(key1);
@@ skipping 57 matching lines @@
         SkImageInfo info = SkImageInfo::MakeN32Premul(gWidth, gHeight);
         SkAutoTUnref<SkSurface> surface(SkSurface::NewRenderTarget(context,
                                                                    SkSurface::kNo_Budgeted, info));
         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_unbudgeted_to_scratch(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