Add size change notifications to GrResourceCache

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 43 matching lines @@
     }
 
     context->setTextureCacheLimits(oldMaxNum, oldMaxBytes);
 }
 
 class TestResource : public GrCacheable {
 public:
     SK_DECLARE_INST_COUNT(TestResource);
     TestResource()
         : fCache(NULL)
-        , fToDelete(NULL) {
+        , fToDelete(NULL)
+        , fSize(100) {
         ++fAlive;
     }
 
     ~TestResource() {
         --fAlive;
         if (NULL != fToDelete) {
             // Breaks our little 2-element cycle below.
             fToDelete->setDeleteWhenDestroyed(NULL, NULL);
             fCache->deleteResource(fToDelete->getCacheEntry());
         }
     }
 
-    size_t gpuMemorySize() const SK_OVERRIDE { return 100; }
+    void setSize(size_t size) {
+        fSize = size;
+        this->onResourceSizeChanged();
+    }
+
+    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;
 };
 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;
@@ skipping 66 matching lines @@
 
         a->unref();
         b->unref();
 
         cache.deleteResource(a->getCacheEntry());
 
         REPORTER_ASSERT(reporter, 0 == TestResource::alive());
     }
 }
 
+static void test_resource_size_changed(skiatest::Reporter* reporter,
+                                       GrContext* context) {
+    GrCacheID::Domain domain = GrCacheID::GenerateDomain();\
+    GrResourceKey::ResourceType t = GrResourceKey::GenerateResourceType();
+
+    GrCacheID::Key key1Data;
+    key1Data.fData64[0] = 0;
+    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);
+
+    {
+        GrResourceCache cache(3, 300);
+
+        TestResource* a = new TestResource();
+        a->setSize(100);
+        cache.addResource(key1, a);
+        a->unref();
+
+        TestResource* b = new TestResource();
+        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());
+    }
+    {
+        GrResourceCache cache(3, 300);
+
+        TestResource* a = new TestResource();
+        a->setSize(100);
+        cache.addResource(key1, a);
+        a->unref();
+
+        TestResource* b = new TestResource();
+        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(201);
+        REPORTER_ASSERT(reporter, NULL == cache.find(key1));
+
+        REPORTER_ASSERT(reporter, 201 == cache.getCachedResourceBytes());
+        REPORTER_ASSERT(reporter, 1 == cache.getCachedResourceCount());
+    }
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 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);
         if (NULL == context) {
             continue;
         }
 
         GrTextureDesc desc;
         desc.fConfig = kSkia8888_GrPixelConfig;
         desc.fFlags = kRenderTarget_GrTextureFlagBit;
         desc.fWidth = gWidth;
         desc.fHeight = gHeight;
 
         SkAutoTUnref<GrTexture> texture(context->createUncachedTexture(desc, NULL, 0));
         SkAutoTUnref<SkGpuDevice> device(SkNEW_ARGS(SkGpuDevice, (context, texture.get())));
         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