skia: Add support for CHROMIUM_image backed textures.

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.
  */
 
 // Include here to ensure SK_SUPPORT_GPU is set correctly before it is examined.
 #include "SkTypes.h"
 
@@ skipping 232 matching lines @@
     static const size_t kDefaultSize = 100;
     
     /** Property that distinctly categorizes the resource.
      * For example, textures have width, height, ... */
     enum SimulatedProperty { kA_SimulatedProperty, kB_SimulatedProperty };
 
     TestResource(GrGpu* gpu, size_t size, GrGpuResource::LifeCycle lifeCycle)
         : INHERITED(gpu, lifeCycle)
         , fToDelete(nullptr)
         , fSize(size)
-        , fProperty(kA_SimulatedProperty) {
+        , fProperty(kA_SimulatedProperty)
+        , fReuseable(true) {
         ++fNumAlive;
         this->registerWithCache();
     }
 
     TestResource(GrGpu* gpu, GrGpuResource::LifeCycle lifeCycle)
         : INHERITED(gpu, lifeCycle)
         , fToDelete(nullptr)
         , fSize(kDefaultSize)
-        , fProperty(kA_SimulatedProperty) {
+        , fProperty(kA_SimulatedProperty)
+        , fReuseable(true) {
         ++fNumAlive;
         this->registerWithCache();
     }
 
     TestResource(GrGpu* gpu)
         : INHERITED(gpu, kCached_LifeCycle)
         , fToDelete(nullptr)
         , fSize(kDefaultSize)
-        , fProperty(kA_SimulatedProperty) {
+        , fProperty(kA_SimulatedProperty)
+        , fReuseable(true) {
         ++fNumAlive;
         this->registerWithCache();
     }
 
-    static TestResource* CreateScratch(GrGpu* gpu, SimulatedProperty property, bool cached = true) {
-        return new TestResource(gpu, property, cached, kScratchConstructor);
+    static TestResource* CreateScratch(GrGpu* gpu, SimulatedProperty property, bool cached = true,
+                                       bool reuseable = true) {
+        return new TestResource(gpu, property, cached, kScratchConstructor, reuseable);
     }
 
     ~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, bool cached, ScratchConstructor)
+    TestResource(GrGpu* gpu, SimulatedProperty property, bool cached, ScratchConstructor,
+                 bool reuseable)
         : INHERITED(gpu, cached ? kCached_LifeCycle : kUncached_LifeCycle)
         , fToDelete(nullptr)
         , fSize(kDefaultSize)
-        , fProperty(property) {
+        , fProperty(property)
+        , fReuseable(reuseable) {
         GrScratchKey scratchKey;
         ComputeScratchKey(fProperty, &scratchKey);
         this->setScratchKey(scratchKey);
         ++fNumAlive;
         this->registerWithCache();
     }
 
     size_t onGpuMemorySize() const override { return fSize; }
+    bool reuseable() const override { return fReuseable; }
 
     TestResource* fToDelete;
     size_t fSize;
     static int fNumAlive;
     SimulatedProperty fProperty;
+    bool fReuseable;
     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);
@@ skipping 842 matching lines @@
             cache->notifyFlushOccurred();
         }
         REPORTER_ASSERT(reporter, 0 == cache->getResourceCount());
 
         cache->purgeAllUnlocked();
     }
 
     REPORTER_ASSERT(reporter, 0 == cache->getResourceCount());
 }
 
+static void test_reuseable_resources(skiatest::Reporter* reporter) {
+    Mock mock(1000, 1000);
+    GrContext* context = mock.context();
+    TestResource* scratch = TestResource::CreateScratch(context->getGpu(),
+            TestResource::kB_SimulatedProperty, true, true);
+    scratch->unref();
+    REPORTER_ASSERT(reporter, TestResource::NumAlive() == 1);
+    scratch = TestResource::CreateScratch(context->getGpu(),
+            TestResource::kB_SimulatedProperty, false, true);
+    scratch->unref();
+    REPORTER_ASSERT(reporter, TestResource::NumAlive() == 2);
+    scratch = TestResource::CreateScratch(context->getGpu(),
+            TestResource::kB_SimulatedProperty, false, false);
+    scratch->unref();
+    REPORTER_ASSERT(reporter, TestResource::NumAlive() == 2);
+}
+
 static void test_large_resource_count(skiatest::Reporter* reporter) {
     // 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.
     static const int kResourceCnt = 2000;
 
     Mock mock(2 * kResourceCnt, 2 * kResourceCnt + 1000);
     GrContext* context = mock.context();
     GrResourceCache* cache = mock.cache();
 
@@ skipping 101 matching lines @@
     test_unbudgeted_to_scratch(reporter);
     test_duplicate_unique_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_timestamp_wrap(reporter);
     test_flush(reporter);
+    test_reuseable_resources(reporter);
     test_large_resource_count(reporter);
     test_custom_data(reporter);
     test_abandoned(reporter);
 }
 
 #endif