Merge GrGpuObject and GrCacheable.

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 "GrContextFactory.h"
@@ skipping 40 matching lines @@
         size_t curCacheSize;
         context->getResourceCacheUsage(NULL, &curCacheSize);
 
         // we should never go over the size limit
         REPORTER_ASSERT(reporter, curCacheSize <= maxCacheSize);
     }
 
     context->setResourceCacheLimits(oldMaxNum, oldMaxBytes);
 }
 
-class TestResource : public GrCacheable {
+class TestResource : public GrGpuObject {
     static const size_t kDefaultSize = 100;
 
 public:
     SK_DECLARE_INST_COUNT(TestResource);
-    TestResource(size_t size = kDefaultSize)
-        : fCache(NULL)
+    TestResource(GrGpu* gpu, size_t size = kDefaultSize)
+        : INHERITED(gpu, false)
+        , fCache(NULL)
         , fToDelete(NULL)
         , fSize(size) {
         ++fAlive;
     }
 
     ~TestResource() {
         --fAlive;
         if (NULL != fToDelete) {
             // Breaks our little 2-element cycle below.
             fToDelete->setDeleteWhenDestroyed(NULL, NULL);
             fCache->deleteResource(fToDelete->getCacheEntry());
         }
+        this->release();
     }
 
     void setSize(size_t size) {
         fSize = size;
         this->didChangeGpuMemorySize();
     }
 
     size_t gpuMemorySize() const SK_OVERRIDE { return fSize; }
 
-    bool isValidOnGpu() const SK_OVERRIDE { return true; }
-
     static int alive() { return fAlive; }
 
     void setDeleteWhenDestroyed(GrResourceCache* cache, TestResource* resource) {
         fCache = cache;
         fToDelete = resource;
     }
 
 private:
     GrResourceCache* fCache;
     TestResource* fToDelete;
     size_t fSize;
     static int fAlive;
 
-    typedef GrCacheable INHERITED;
+    typedef GrGpuObject INHERITED;
 };
 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);
 
     // Add two resources with the same key that delete each other from the cache when destroyed.
-    TestResource* a = new TestResource();
-    TestResource* b = new TestResource();
+    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();
     b->unref();
 
     // Add a third independent resource also with the same key.
-    GrCacheable* r = new TestResource();
+    GrGpuObject* r = new TestResource(context->getGpu());
     cache.addResource(key, r);
     r->unref();
 
     // Invalidate all three, all three should be purged and destroyed.
     REPORTER_ASSERT(reporter, 3 == TestResource::alive());
     const GrResourceInvalidatedMessage msg = { key };
     SkMessageBus<GrResourceInvalidatedMessage>::Post(msg);
     cache.purgeAsNeeded();
     REPORTER_ASSERT(reporter, 0 == TestResource::alive());
 }
 
 static void test_cache_delete_on_destruction(skiatest::Reporter* reporter,
                                              GrContext* context) {
     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);
-            TestResource* a = new TestResource();
-            TestResource* b = new TestResource();
+            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);
-        TestResource* a = new TestResource();
-        TestResource* b = new TestResource();
+        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();
 
         cache.deleteResource(a->getCacheEntry());
@@ skipping 14 matching lines @@
 
     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);
 
-        TestResource* a = new TestResource(0);
+        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(0);
+        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);
 
-        TestResource* a = new TestResource(100);
+        TestResource* a = new TestResource(context->getGpu(), 100);
         cache.addResource(key1, a);
         a->unref();
 
-        TestResource* b = new TestResource(100);
+        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(100);
+        TestResource* a = new TestResource(context->getGpu(), 100);
         cache.addResource(key1, a);
         cache.makeExclusive(a->getCacheEntry());
 
-        TestResource* b = new TestResource(100);
+        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());
@@ skipping 33 matching lines @@
         SkCanvas canvas(device.get());
 
         test_cache(reporter, context, &canvas);
         test_purge_invalidated(reporter, context);
         test_cache_delete_on_destruction(reporter, context);
         test_resource_size_changed(reporter, context);
     }
 }
 
 #endif