Update To 11.40.268.0

[platform/framework/web/crosswalk.git] / src / third_party / skia / tests / GpuLayerCacheTest.cpp

diff --git a/src/third_party/skia/tests/GpuLayerCacheTest.cpp b/src/third_party/skia/tests/GpuLayerCacheTest.cpp
index c9b88f5..277590e 100644 (file)
--- a/src/third_party/skia/tests/GpuLayerCacheTest.cpp
+++ b/src/third_party/skia/tests/GpuLayerCacheTest.cpp
@@ -21,6 +21,9 @@ public:
     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
@@ -33,12 +36,12 @@ static void create_layers(skiatest::Reporter* reporter,
     for (int i = 0; i < numToAdd; ++i) {
         GrCachedLayer* layer = cache->findLayerOrCreate(picture.uniqueID(), 
                                                         idOffset+i+1, idOffset+i+2, 
-                                                        SkIPoint::Make(0, 0),
+                                                        SkIRect::MakeEmpty(),
                                                         SkMatrix::I(),
                                                         NULL);
         REPORTER_ASSERT(reporter, layer);
-        GrCachedLayer* temp = cache->findLayer(picture.uniqueID(), idOffset+i+1, idOffset+i+2, 
-                                               SkIPoint::Make(0, 0), SkMatrix::I());
+        GrCachedLayer* temp = cache->findLayer(picture.uniqueID(), idOffset + i + 1,
+                                               SkIRect::MakeEmpty(), SkMatrix::I());
         REPORTER_ASSERT(reporter, temp == layer);
 
         REPORTER_ASSERT(reporter, TestingAccess::NumLayers(cache) == idOffset + i + 1);
@@ -46,7 +49,6 @@ static void create_layers(skiatest::Reporter* reporter,
         REPORTER_ASSERT(reporter, picture.uniqueID() == layer->pictureID());
         REPORTER_ASSERT(reporter, layer->start() == idOffset + i + 1);
         REPORTER_ASSERT(reporter, layer->stop() == idOffset + i + 2);
-        REPORTER_ASSERT(reporter, layer->ctm() == SkMatrix::I());
         REPORTER_ASSERT(reporter, NULL == layer->texture());
         REPORTER_ASSERT(reporter, NULL == layer->paint());
         REPORTER_ASSERT(reporter, !layer->isAtlased());
@@ -59,19 +61,27 @@ static void lock_layer(skiatest::Reporter* reporter,
                        GrLayerCache* cache,
                        GrCachedLayer* layer) {
     // Make the layer 512x512 (so it can be atlased)
-    GrTextureDesc desc;
+    GrSurfaceDesc desc;
     desc.fWidth = 512;
     desc.fHeight = 512;
     desc.fConfig = kSkia8888_GrPixelConfig;
 
-    bool needsRerendering = cache->lock(layer, desc, false);
+    bool needsRerendering;
+    bool inAtlas = cache->tryToAtlas(layer, desc, &needsRerendering);
+    if (!inAtlas) {
+        cache->lock(layer, desc, &needsRerendering);
+    }
     REPORTER_ASSERT(reporter, needsRerendering);
 
-    needsRerendering = cache->lock(layer, desc, false);
+    cache->lock(layer, desc, &needsRerendering);
     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.
@@ -103,8 +113,8 @@ DEF_GPUTEST(GpuLayerCache, reporter, factory) {
         create_layers(reporter, &cache, *picture, kInitialNumLayers, 0);
 
         for (int i = 0; i < kInitialNumLayers; ++i) {
-            GrCachedLayer* layer = cache.findLayer(picture->uniqueID(), i+1, i+2, 
-                                                   SkIPoint::Make(0, 0), SkMatrix::I());
+            GrCachedLayer* layer = cache.findLayer(picture->uniqueID(), i+1, 
+                                                   SkIRect::MakeEmpty(), SkMatrix::I());
             REPORTER_ASSERT(reporter, layer);
 
             lock_layer(reporter, &cache, layer);
@@ -121,27 +131,35 @@ DEF_GPUTEST(GpuLayerCache, reporter, factory) {
 
         // Unlock the textures
         for (int i = 0; i < kInitialNumLayers; ++i) {
-            GrCachedLayer* layer = cache.findLayer(picture->uniqueID(), i+1, i+2, 
-                                                   SkIPoint::Make(0, 0), SkMatrix::I());
+            GrCachedLayer* layer = cache.findLayer(picture->uniqueID(), i+1, 
+                                                   SkIRect::MakeEmpty(), 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, i+2, 
-                                                   SkIPoint::Make(0, 0), SkMatrix::I());
+            GrCachedLayer* layer = cache.findLayer(picture->uniqueID(), i+1, 
+                                                   SkIRect::MakeEmpty(), SkMatrix::I());
             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 {
-                // The final layer should be unlocked.
+#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
         }
 
         {
@@ -149,17 +167,18 @@ DEF_GPUTEST(GpuLayerCache, reporter, factory) {
             // will force out the first atlased layer
             create_layers(reporter, &cache, *picture, 1, kInitialNumLayers);
             GrCachedLayer* layer = cache.findLayer(picture->uniqueID(), 
-                                                   kInitialNumLayers+1, kInitialNumLayers+2, 
-                                                   SkIPoint::Make(0, 0), SkMatrix::I());
+                                                   kInitialNumLayers+1, 
+                                                   SkIRect::MakeEmpty(), 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, i+2, 
-                                                   SkIPoint::Make(0, 0), SkMatrix::I());
+            GrCachedLayer* layer = cache.findLayer(picture->uniqueID(), i + 1,
+                                                   SkIRect::MakeEmpty(), SkMatrix::I());
+#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);
@@ -167,15 +186,18 @@ DEF_GPUTEST(GpuLayerCache, reporter, factory) {
                 REPORTER_ASSERT(reporter, layer->texture());
                 REPORTER_ASSERT(reporter, layer->isAtlased());
             } else if (4 == i) {
+#endif
                 // The one that was never atlased should still be around
                 REPORTER_ASSERT(reporter, layer);
 
                 REPORTER_ASSERT(reporter, NULL == layer->texture());
                 REPORTER_ASSERT(reporter, !layer->isAtlased());
+#if GR_CACHE_HOISTED_LAYERS
             } else {
                 // The one bumped out of the atlas (i.e., 0) should be gone
                 REPORTER_ASSERT(reporter, NULL == layer);
             }
+#endif
         }
 
         //--------------------------------------------------------------------