GrResourceCache2 manages scratch texture.

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"
+#include "GrContextFactory.h"
+#include "GrGpu.h"
+#include "GrResourceCache.h"
 #include "SkCanvas.h"
-#include "GrContextFactory.h"
-#include "GrResourceCache.h"
 #include "SkSurface.h"
 #include "Test.h"
 
 static const int gWidth = 640;
 static const int gHeight = 480;
 
 ////////////////////////////////////////////////////////////////////////////////
 static void test_cache(skiatest::Reporter* reporter,
                        GrContext* context,
                        SkCanvas* canvas) {
@@ skipping 85 matching lines @@
 int TestResource::fAlive = 0;
 
 static void test_purge_invalidated(skiatest::Reporter* reporter, GrContext* context) {
     GrCacheID::Domain domain = GrCacheID::GenerateDomain();
     GrCacheID::Key keyData;
     keyData.fData64[0] = 5;
     keyData.fData64[1] = 18;
     GrResourceKey::ResourceType t = GrResourceKey::GenerateResourceType();
     GrResourceKey key(GrCacheID(domain, keyData), t, 0);
 
-    GrResourceCache cache(5, 30000);
+    GrResourceCache cache(context->getGpu()->caps(), 5, 30000);
 
     // Add two resources with the same key that delete each other from the cache when destroyed.
     TestResource* a = new TestResource(context->getGpu());
     TestResource* b = new TestResource(context->getGpu());
     cache.addResource(key, a);
     cache.addResource(key, b);
     // Circle back.
     a->setDeleteWhenDestroyed(&cache, b);
     b->setDeleteWhenDestroyed(&cache, a);
     a->unref();
@@ skipping 17 matching lines @@
     GrCacheID::Domain domain = GrCacheID::GenerateDomain();
     GrCacheID::Key keyData;
     keyData.fData64[0] = 5;
     keyData.fData64[1] = 0;
     GrResourceKey::ResourceType t = GrResourceKey::GenerateResourceType();
 
     GrResourceKey key(GrCacheID(domain, keyData), t, 0);
 
     {
         {
-            GrResourceCache cache(3, 30000);
+            GrResourceCache cache(context->getGpu()->caps(), 3, 30000);
             TestResource* a = new TestResource(context->getGpu());
             TestResource* b = new TestResource(context->getGpu());
             cache.addResource(key, a);
             cache.addResource(key, b);
 
             a->setDeleteWhenDestroyed(&cache, b);
             b->setDeleteWhenDestroyed(&cache, a);
 
             a->unref();
             b->unref();
             REPORTER_ASSERT(reporter, 2 == TestResource::alive());
         }
         REPORTER_ASSERT(reporter, 0 == TestResource::alive());
     }
     {
-        GrResourceCache cache(3, 30000);
+        GrResourceCache cache(context->getGpu()->caps(), 3, 30000);
         TestResource* a = new TestResource(context->getGpu());
         TestResource* b = new TestResource(context->getGpu());
         cache.addResource(key, a);
         cache.addResource(key, b);
 
         a->setDeleteWhenDestroyed(&cache, b);
         b->setDeleteWhenDestroyed(&cache, a);
 
         a->unref();
         b->unref();
@@ skipping 14 matching lines @@
     key1Data.fData64[1] = 0;
     GrResourceKey key1(GrCacheID(domain, key1Data), t, 0);
 
     GrCacheID::Key key2Data;
     key2Data.fData64[0] = 1;
     key2Data.fData64[1] = 0;
     GrResourceKey key2(GrCacheID(domain, key2Data), t, 0);
 
     // Test changing resources sizes (both increase & decrease).
     {
-        GrResourceCache cache(2, 300);
+        GrResourceCache cache(context->getGpu()->caps(), 2, 300);
 
         TestResource* a = new TestResource(context->getGpu());
         a->setSize(100); // Test didChangeGpuMemorySize() when not in the cache.
         cache.addResource(key1, a);
         a->unref();
 
         TestResource* b = new TestResource(context->getGpu());
         b->setSize(100);
         cache.addResource(key2, b);
         b->unref();
 
         REPORTER_ASSERT(reporter, 200 == cache.getCachedResourceBytes());
         REPORTER_ASSERT(reporter, 2 == cache.getCachedResourceCount());
 
         static_cast<TestResource*>(cache.find(key2))->setSize(200);
         static_cast<TestResource*>(cache.find(key1))->setSize(50);
 
         REPORTER_ASSERT(reporter, 250 == cache.getCachedResourceBytes());
         REPORTER_ASSERT(reporter, 2 == cache.getCachedResourceCount());
     }
 
     // Test increasing a resources size beyond the cache budget.
     {
-        GrResourceCache cache(2, 300);
+        GrResourceCache cache(context->getGpu()->caps(), 2, 300);
 
         TestResource* a = new TestResource(context->getGpu(), 100);
         cache.addResource(key1, a);
         a->unref();
 
         TestResource* b = new TestResource(context->getGpu(), 100);
         cache.addResource(key2, b);
         b->unref();
 
         REPORTER_ASSERT(reporter, 200 == cache.getCachedResourceBytes());
         REPORTER_ASSERT(reporter, 2 == cache.getCachedResourceCount());
 
         static_cast<TestResource*>(cache.find(key2))->setSize(201);
         REPORTER_ASSERT(reporter, NULL == cache.find(key1));
 
         REPORTER_ASSERT(reporter, 201 == cache.getCachedResourceBytes());
         REPORTER_ASSERT(reporter, 1 == cache.getCachedResourceCount());
     }
-
-    // Test changing the size of an exclusively-held resource.
-    {
-        GrResourceCache cache(2, 300);
-
-        TestResource* a = new TestResource(context->getGpu(), 100);
-        cache.addResource(key1, a);
-        cache.makeExclusive(a->getCacheEntry());
-
-        TestResource* b = new TestResource(context->getGpu(), 100);
-        cache.addResource(key2, b);
-        b->unref();
-
-        REPORTER_ASSERT(reporter, 200 == cache.getCachedResourceBytes());
-        REPORTER_ASSERT(reporter, 2 == cache.getCachedResourceCount());
-        REPORTER_ASSERT(reporter, NULL == cache.find(key1));
-
-        a->setSize(200);
-
-        REPORTER_ASSERT(reporter, 300 == cache.getCachedResourceBytes());
-        REPORTER_ASSERT(reporter, 2 == cache.getCachedResourceCount());
-        // Internal resource cache validation will test the detached size (debug mode only).
-
-        cache.makeNonExclusive(a->getCacheEntry());
-        a->unref();
-
-        REPORTER_ASSERT(reporter, 300 == cache.getCachedResourceBytes());
-        REPORTER_ASSERT(reporter, 2 == cache.getCachedResourceCount());
-        REPORTER_ASSERT(reporter, cache.find(key1));
-        // Internal resource cache validation will test the detached size (debug mode only).
-    }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 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;
         }
         GrContext* context = factory->get(glType);
@@ skipping 10 matching lines @@
         SkAutoTUnref<SkSurface> surface(SkSurface::NewRenderTarget(context, info));
 
         test_cache(reporter, context, surface->getCanvas());
         test_purge_invalidated(reporter, context);
         test_cache_delete_on_destruction(reporter, context);
         test_resource_size_changed(reporter, context);
     }
 }
 
 #endif