Fuse GrReplacements and GrLayerCache

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) {
+    static unsigned 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();
     }
     static GrCachedLayer* Find(GrLayerCache* cache, uint32_t pictureID,
-                               const SkMatrix& initialMat, const int* key, int keySize) {
+                               const SkMatrix& initialMat, 
+                               const unsigned* key, int keySize) {
         return cache->findLayer(pictureID, initialMat, key, keySize);
     }
 };
 
 // Add several layers to the cache
 static void create_layers(skiatest::Reporter* reporter,
                           GrLayerCache* cache,
                           const SkPicture& picture,
-                          int numToAdd,
-                          int idOffset) {
+                          unsigned numToAdd,
+                          unsigned idOffset) {
 
-    for (int i = 0; i < numToAdd; ++i) {
-        int indices[1] = { idOffset+i+1 };
+    for (unsigned i = 0; i < numToAdd; ++i) {
+        unsigned indices[1] = { idOffset+i+1 };
         GrCachedLayer* layer = cache->findLayerOrCreate(picture.uniqueID(), 
                                                         idOffset+i+1, idOffset+i+2, 
                                                         SkIRect::MakeEmpty(),
                                                         SkMatrix::I(),
                                                         indices, 1,
                                                         NULL);
         REPORTER_ASSERT(reporter, layer);
         GrCachedLayer* temp = TestingAccess::Find(cache, picture.uniqueID(), SkMatrix::I(), 
                                                   indices, 1);
         REPORTER_ASSERT(reporter, temp == layer);
@@ skipping 57 matching lines @@
         }
 
         SkPictureRecorder recorder;
         recorder.beginRecording(1, 1);
         SkAutoTUnref<const SkPicture> picture(recorder.endRecording());
 
         GrLayerCache cache(context);
 
         create_layers(reporter, &cache, *picture, kInitialNumLayers, 0);
 
-        for (int i = 0; i < kInitialNumLayers; ++i) {
-            int indices[1] = { i + 1 };
+        for (unsigned i = 0; i < kInitialNumLayers; ++i) {
+            unsigned indices[1] = { i + 1 };
             GrCachedLayer* layer = TestingAccess::Find(&cache, picture->uniqueID(), SkMatrix::I(),
                                                        indices, 1);
             REPORTER_ASSERT(reporter, layer);
 
             lock_layer(reporter, &cache, layer);
 
             // The first 4 layers should be in the atlas (and thus have non-empty
             // rects)
             if (i < 4) {
                 REPORTER_ASSERT(reporter, layer->isAtlased());
             } 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) {
-            int indices[1] = { i+1 };
+        for (unsigned i = 0; i < kInitialNumLayers; ++i) {
+            unsigned indices[1] = { i+1 };
 
             GrCachedLayer* layer = TestingAccess::Find(&cache, picture->uniqueID(), SkMatrix::I(),
                                                        indices, 1);
             REPORTER_ASSERT(reporter, layer);
             cache.removeUse(layer);
         }
 
-        for (int i = 0; i < kInitialNumLayers; ++i) {
-            int indices[1] = { i+1 };
+        for (unsigned i = 0; i < kInitialNumLayers; ++i) {
+            unsigned indices[1] = { i+1 };
 
             GrCachedLayer* layer = TestingAccess::Find(&cache, picture->uniqueID(), SkMatrix::I(),
                                                        indices, 1);
             REPORTER_ASSERT(reporter, layer);
 
             // All the layers should be unlocked
             REPORTER_ASSERT(reporter, !layer->locked());
 
             // When hoisted layers aren't cached they are aggressively removed
             // from the atlas
 #if GR_CACHE_HOISTED_LAYERS
             // The first 4 layers should still be in the atlas.
             if (i < 4) {
                 REPORTER_ASSERT(reporter, layer->texture());
                 REPORTER_ASSERT(reporter, layer->isAtlased());
             } else {
 #endif
                 // The final layer should not be atlased.
                 REPORTER_ASSERT(reporter, NULL == layer->texture());
                 REPORTER_ASSERT(reporter, !layer->isAtlased());
 #if GR_CACHE_HOISTED_LAYERS
             }
 #endif
         }
 
         {
-            int indices[1] = { kInitialNumLayers+1 };
+            unsigned indices[1] = { kInitialNumLayers+1 };
 
             // 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 = TestingAccess::Find(&cache, picture->uniqueID(), SkMatrix::I(),
                                                        indices, 1);
             REPORTER_ASSERT(reporter, layer);
 
             lock_layer(reporter, &cache, layer);
             cache.removeUse(layer);
         }
 
-        for (int i = 0; i < kInitialNumLayers+1; ++i) {
-            int indices[1] = { i+1 };
+        for (unsigned i = 0; i < kInitialNumLayers+1; ++i) {
+            unsigned indices[1] = { i+1 };
 
             GrCachedLayer* layer = TestingAccess::Find(&cache, picture->uniqueID(), SkMatrix::I(),
                                                        indices, 1);
 #if GR_CACHE_HOISTED_LAYERS
             // 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 39 matching lines @@
 
         picture.reset(NULL);
         cache.processDeletedPictures();
 
         REPORTER_ASSERT(reporter, TestingAccess::NumLayers(&cache) == 0);
         // TODO: add VRAM/resource cache check here
     }
 }
 
 #endif