Fix bug in GrCachedLayer reuse

tests/GpuLayerCacheTest.cpp

 /*
 * Copyright 2014 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 "GrLayerCache.h"
 #include "SkPictureRecorder.h"
 #include "Test.h"
 
 class TestingAccess {
 public:
     static int NumLayers(GrLayerCache* cache) {
         return cache->numLayers();
     }
     static void Purge(GrLayerCache* cache, uint32_t pictureID) {
         cache->purge(pictureID);
     }
+    static int Uses(GrCachedLayer* layer) {
+        return layer->uses();
+    }
 };
 
 // Add several layers to the cache
 static void create_layers(skiatest::Reporter* reporter,
                           GrLayerCache* cache,
                           const SkPicture& picture,
                           int numToAdd,
                           int idOffset) {
 
     for (int i = 0; i < numToAdd; ++i) {
@@ skipping 29 matching lines @@
     desc.fConfig = kSkia8888_GrPixelConfig;
 
     bool needsRerendering = cache->lock(layer, desc, false);
     REPORTER_ASSERT(reporter, needsRerendering);
 
     needsRerendering = cache->lock(layer, desc, false);
     REPORTER_ASSERT(reporter, !needsRerendering);
 
     REPORTER_ASSERT(reporter, layer->texture());
     REPORTER_ASSERT(reporter, layer->locked());
+
+    cache->addUse(layer);
+
+    REPORTER_ASSERT(reporter, 1 == TestingAccess::Uses(layer));
 }
 
 // This test case exercises the public API of the GrLayerCache class.
 // In particular it checks its interaction with the resource cache (w.r.t.
 // locking & unlocking textures).
 // TODO: need to add checks on VRAM usage!
 DEF_GPUTEST(GpuLayerCache, reporter, factory) {
     static const int kInitialNumLayers = 5;
 
     for (int i= 0; i < GrContextFactory::kGLContextTypeCnt; ++i) {
@@ skipping 30 matching lines @@
             } else {
                 // The 5th layer couldn't fit in the atlas
                 REPORTER_ASSERT(reporter, !layer->isAtlased());
             }
         }
 
         // Unlock the textures
         for (int i = 0; i < kInitialNumLayers; ++i) {
             GrCachedLayer* layer = cache.findLayer(picture->uniqueID(), i+1, SkMatrix::I());
             REPORTER_ASSERT(reporter, layer);
-            cache.unlock(layer);
+            cache.removeUse(layer);
         }
 
         for (int i = 0; i < kInitialNumLayers; ++i) {
             GrCachedLayer* layer = cache.findLayer(picture->uniqueID(), i+1, SkMatrix::I());
             REPORTER_ASSERT(reporter, layer);
 
+            // All the layers should be unlocked
             REPORTER_ASSERT(reporter, !layer->locked());
+
             // The first 4 layers should still be in the atlas.
             if (i < 4) {
                 REPORTER_ASSERT(reporter, layer->texture());
                 REPORTER_ASSERT(reporter, layer->isAtlased());
             } else {
-                // The final layer should be unlocked.
+                // The final layer should not be atlased.
                 REPORTER_ASSERT(reporter, NULL == layer->texture());
                 REPORTER_ASSERT(reporter, !layer->isAtlased());
             }
         }
 
         {
             // Add an additional layer. Since all the layers are unlocked this 
             // will force out the first atlased layer
             create_layers(reporter, &cache, *picture, 1, kInitialNumLayers);
             GrCachedLayer* layer = cache.findLayer(picture->uniqueID(), 
                                                    kInitialNumLayers+1, SkMatrix::I());
             REPORTER_ASSERT(reporter, layer);
 
             lock_layer(reporter, &cache, layer);
-            cache.unlock(layer);
+            cache.removeUse(layer);
         }
 
         for (int i = 0; i < kInitialNumLayers+1; ++i) {
             GrCachedLayer* layer = cache.findLayer(picture->uniqueID(), i+1, SkMatrix::I());
             // 3 old layers plus the new one should be in the atlas.
             if (1 == i || 2 == i || 3 == i || 5 == i) {
                 REPORTER_ASSERT(reporter, layer);
                 REPORTER_ASSERT(reporter, !layer->locked());
                 REPORTER_ASSERT(reporter, layer->texture());
                 REPORTER_ASSERT(reporter, layer->isAtlased());
@@ skipping 36 matching lines @@
 
         picture.reset(NULL);
         cache.processDeletedPictures();
 
         REPORTER_ASSERT(reporter, TestingAccess::NumLayers(&cache) == 0);
         // TODO: add VRAM/resource cache check here
     }
 }
 
 #endif