Revert of Update Layer Hoisting to store its atlas texture in the resource cache (patchset #6 id:100001 of https://codereview.chromium.org/1406013006/ )

Reason for revert:
Android

Original issue's description:
> Update Layer Hoisting to store its atlas texture in the resource cache
>
> BUG=skia:4346
>
> Committed: https://skia.googlesource.com/skia/+/42597bc99f00553825843b5ed41e81b121773368

TBR=bsalomon@google.com
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
BUG=skia:4346

Review URL: https://codereview.chromium.org/1413483004

1 files changed, 30 insertions, 160 deletions

diff --git a/tests/GpuLayerCacheTest.cpp b/tests/GpuLayerCacheTest.cpp
index b91c5b01b0..95ac7b641d 100644
--- a/tests/GpuLayerCacheTest.cpp
+++ b/tests/GpuLayerCacheTest.cpp
@@ -10,24 +10,11 @@
 #include "GrContext.h"
 #include "GrContextFactory.h"
 #include "GrLayerCache.h"
-#include "GrResourceCache.h"
 #include "SkPictureRecorder.h"
 #include "Test.h"
 
 class TestingAccess {
 public:
-    static int NumPlots() {
-        return GrLayerCache::kNumPlotsX * GrLayerCache::kNumPlotsY;
-    }
-    static SkISize PlotSize() {
-        return SkISize::Make(GrLayerCache::kAtlasTextureWidth / GrLayerCache::kNumPlotsX,
-                             GrLayerCache::kAtlasTextureHeight / GrLayerCache::kNumPlotsY);
-    }
-
-    static GrTexture* GetBackingTexture(GrLayerCache* cache) {
-        return cache->fAtlas->getTextureOrNull();
-    }
-
     static int NumLayers(GrLayerCache* cache) {
         return cache->numLayers();
     }
@@ -52,17 +39,17 @@ static void create_layers(skiatest::Reporter* reporter,
                           int idOffset) {
 
     for (int i = 0; i < numToAdd; ++i) {
-        int key[1] = { idOffset+i+1 };
+        int indices[1] = { idOffset+i+1 };
         GrCachedLayer* layer = cache->findLayerOrCreate(picture.uniqueID(),
                                                         idOffset+i+1, idOffset+i+2,
                                                         SkIRect::MakeEmpty(),
                                                         SkIRect::MakeEmpty(),
                                                         SkMatrix::I(),
-                                                        key, 1,
+                                                        indices, 1,
                                                         nullptr);
         REPORTER_ASSERT(reporter, layer);
         GrCachedLayer* temp = TestingAccess::Find(cache, picture.uniqueID(), SkMatrix::I(),
-                                                  key, 1);
+                                                  indices, 1);
         REPORTER_ASSERT(reporter, temp == layer);
 
         REPORTER_ASSERT(reporter, TestingAccess::NumLayers(cache) == idOffset + i + 1);
@@ -79,10 +66,10 @@ static void create_layers(skiatest::Reporter* reporter,
 static void lock_layer(skiatest::Reporter* reporter,
                        GrLayerCache* cache,
                        GrCachedLayer* layer) {
-    // Make each layer big enough to consume one whole plot in the atlas
+    // Make the layer 512x512 (so it can be atlased)
     GrSurfaceDesc desc;
-    desc.fWidth = TestingAccess::PlotSize().fWidth;
-    desc.fHeight = TestingAccess::PlotSize().fHeight;
+    desc.fWidth = 512;
+    desc.fHeight = 512;
     desc.fConfig = kSkia8888_GrPixelConfig;
 
     bool needsRerendering;
@@ -108,14 +95,9 @@ static void lock_layer(skiatest::Reporter* reporter,
 // locking & unlocking textures).
 // TODO: need to add checks on VRAM usage!
 DEF_GPUTEST(GpuLayerCache, reporter, factory) {
-    // Add one more layer than can fit in the atlas
-    static const int kInitialNumLayers = TestingAccess::NumPlots() + 1;
-
-#if GR_CACHE_STATS
-    GrResourceCache::Stats stats;
-#endif
+    static const int kInitialNumLayers = 5;
 
-    for (int i = 0; i < GrContextFactory::kGLContextTypeCnt; ++i) {
+    for (int i= 0; i < GrContextFactory::kGLContextTypeCnt; ++i) {
         GrContextFactory::GLContextType glCtxType = (GrContextFactory::GLContextType) i;
 
         if (!GrContextFactory::IsRenderingGLContext(glCtxType)) {
@@ -128,73 +110,50 @@ DEF_GPUTEST(GpuLayerCache, reporter, factory) {
             continue;
         }
 
-        SkAutoTUnref<const SkPicture> picture;
-
-        {
-            SkPictureRecorder recorder;
-            SkCanvas* c = recorder.beginRecording(1, 1);
-                // Draw something, anything, to prevent an empty-picture optimization,
-                // which is a singleton and never purged.
-                c->drawRect(SkRect::MakeWH(1,1), SkPaint());
-            picture.reset(recorder.endRecording());
-        }
-
-        GrResourceCache* resourceCache = context->getResourceCache();
+        SkPictureRecorder recorder;
+        SkCanvas* c = recorder.beginRecording(1, 1);
+            // Draw something, anything, to prevent an empty-picture optimization,
+            // which is a singleton and never purged.
+            c->drawRect(SkRect::MakeWH(1,1), SkPaint());
+        SkAutoTUnref<const SkPicture> picture(recorder.endRecording());
 
         GrLayerCache cache(context);
 
         create_layers(reporter, &cache, *picture, kInitialNumLayers, 0);
 
         for (int i = 0; i < kInitialNumLayers; ++i) {
-            int key[1] = { i + 1 };
+            int indices[1] = { i + 1 };
             GrCachedLayer* layer = TestingAccess::Find(&cache, picture->uniqueID(), SkMatrix::I(),
-                                                       key, 1);
+                                                       indices, 1);
             REPORTER_ASSERT(reporter, layer);
 
             lock_layer(reporter, &cache, layer);
 
-#if GR_CACHE_STATS
-            resourceCache->getStats(&stats);
-#endif
-
-            // The first 4 layers should be in the atlas (and thus have non-empty rects)
-            if (i < TestingAccess::NumPlots()) {
+            // The first 4 layers should be in the atlas (and thus have non-empty
+            // rects)
+            if (i < 4) {
                 REPORTER_ASSERT(reporter, layer->isAtlased());
-#if GR_CACHE_STATS
-                REPORTER_ASSERT(reporter, 1 == stats.fTotal);
-#endif
             } else {
                 // The 5th layer couldn't fit in the atlas
                 REPORTER_ASSERT(reporter, !layer->isAtlased());
-#if GR_CACHE_STATS
-                REPORTER_ASSERT(reporter, 2 == stats.fTotal);
-#endif
             }
         }
 
         // Unlock the textures
         for (int i = 0; i < kInitialNumLayers; ++i) {
-            int key[1] = { i+1 };
+            int indices[1] = { i+1 };
 
             GrCachedLayer* layer = TestingAccess::Find(&cache, picture->uniqueID(), SkMatrix::I(),
-                                                       key, 1);
+                                                       indices, 1);
             REPORTER_ASSERT(reporter, layer);
             cache.removeUse(layer);
         }
 
-#if GR_CACHE_STATS
-        resourceCache->getStats(&stats);
-        REPORTER_ASSERT(reporter, 2 == stats.fTotal);
-        // The floating layer is purgeable the cache is not
-        REPORTER_ASSERT(reporter, 1 == stats.fNumPurgeable);
-        REPORTER_ASSERT(reporter, 1 == stats.fNumNonPurgeable);
-#endif
-
         for (int i = 0; i < kInitialNumLayers; ++i) {
-            int key[1] = { i+1 };
+            int indices[1] = { i+1 };
 
             GrCachedLayer* layer = TestingAccess::Find(&cache, picture->uniqueID(), SkMatrix::I(),
-                                                       key, 1);
+                                                       indices, 1);
             REPORTER_ASSERT(reporter, layer);
 
             // All the layers should be unlocked
@@ -217,37 +176,14 @@ DEF_GPUTEST(GpuLayerCache, reporter, factory) {
 #endif
         }
 
-        // Let go of the backing texture
-        cache.end();
-        REPORTER_ASSERT(reporter, nullptr == TestingAccess::GetBackingTexture(&cache));
-
-#if GR_CACHE_STATS
-        resourceCache->getStats(&stats);
-        REPORTER_ASSERT(reporter, 2 == stats.fTotal);
-        // Now both the floater and the atlas are purgeable
-        REPORTER_ASSERT(reporter, 2 == stats.fNumPurgeable);
-#endif
-
-        // re-attach to the backing texture
-        cache.begin();
-        REPORTER_ASSERT(reporter, TestingAccess::GetBackingTexture(&cache));
-
-#if GR_CACHE_STATS
-        resourceCache->getStats(&stats);
-        REPORTER_ASSERT(reporter, 2 == stats.fTotal);
-        // The atlas is restored to being non-purgeable
-        REPORTER_ASSERT(reporter, 1 == stats.fNumPurgeable);
-        REPORTER_ASSERT(reporter, 1 == stats.fNumNonPurgeable);
-#endif
-
         {
-            int key[1] = { kInitialNumLayers+1 };
+            int 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(),
-                                                       key, 1);
+                                                       indices, 1);
             REPORTER_ASSERT(reporter, layer);
 
             lock_layer(reporter, &cache, layer);
@@ -255,10 +191,10 @@ DEF_GPUTEST(GpuLayerCache, reporter, factory) {
         }
 
         for (int i = 0; i < kInitialNumLayers+1; ++i) {
-            int key[1] = { i+1 };
+            int indices[1] = { i+1 };
 
             GrCachedLayer* layer = TestingAccess::Find(&cache, picture->uniqueID(), SkMatrix::I(),
-                                                       key, 1);
+                                                       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) {
@@ -287,14 +223,7 @@ DEF_GPUTEST(GpuLayerCache, reporter, factory) {
         TestingAccess::Purge(&cache, picture->uniqueID());
 
         REPORTER_ASSERT(reporter, TestingAccess::NumLayers(&cache) == 0);
-
-#if GR_CACHE_STATS
-        resourceCache->getStats(&stats);
-        REPORTER_ASSERT(reporter, 2 == stats.fTotal);
-        // Atlas isn't purgeable
-        REPORTER_ASSERT(reporter, 1 == stats.fNumPurgeable);
-        REPORTER_ASSERT(reporter, 1 == stats.fNumNonPurgeable);
-#endif
+        // TODO: add VRAM/resource cache check here
 
         //--------------------------------------------------------------------
         // Test out the GrContext-style purge. This should remove all the layers
@@ -306,77 +235,18 @@ DEF_GPUTEST(GpuLayerCache, reporter, factory) {
         cache.freeAll();
 
         REPORTER_ASSERT(reporter, TestingAccess::NumLayers(&cache) == 0);
-
-        REPORTER_ASSERT(reporter, nullptr == TestingAccess::GetBackingTexture(&cache));
-
-#if GR_CACHE_STATS
-        resourceCache->getStats(&stats);
-        REPORTER_ASSERT(reporter, 2 == stats.fTotal);
-        REPORTER_ASSERT(reporter, 2 == stats.fNumPurgeable);
-#endif
-
-        // Purge the resource cache ...
-        resourceCache->purgeAllUnlocked();
-
-#if GR_CACHE_STATS
-        resourceCache->getStats(&stats);
-        REPORTER_ASSERT(reporter, 0 == stats.fTotal);
-#endif
-
-        // and try to re-attach to the backing texture. This should fail
-        cache.begin();
-        REPORTER_ASSERT(reporter, nullptr == TestingAccess::GetBackingTexture(&cache));
+        // TODO: add VRAM/resource cache check here
 
         //--------------------------------------------------------------------
         // Test out the MessageBus-style purge. This will not free the atlas
         // but should eliminate the free-floating layers.
         create_layers(reporter, &cache, *picture, kInitialNumLayers, 0);
 
-        // Allocate/use the layers
-        for (int i = 0; i < kInitialNumLayers; ++i) {
-            int key[1] = { i + 1 };
-            GrCachedLayer* layer = TestingAccess::Find(&cache, picture->uniqueID(), SkMatrix::I(),
-                                                       key, 1);
-            REPORTER_ASSERT(reporter, layer);
-
-            lock_layer(reporter, &cache, layer);
-        }
-
-#if GR_CACHE_STATS
-        resourceCache->getStats(&stats);
-        REPORTER_ASSERT(reporter, 2 == stats.fTotal);
-        REPORTER_ASSERT(reporter, 2 == stats.fNumNonPurgeable);
-#endif
-
-        // Unlock the textures
-        for (int i = 0; i < kInitialNumLayers; ++i) {
-            int key[1] = { i+1 };
-
-            GrCachedLayer* layer = TestingAccess::Find(&cache, picture->uniqueID(), SkMatrix::I(),
-                                                       key, 1);
-            REPORTER_ASSERT(reporter, layer);
-            cache.removeUse(layer);
-        }
-
         picture.reset(nullptr);
         cache.processDeletedPictures();
 
         REPORTER_ASSERT(reporter, TestingAccess::NumLayers(&cache) == 0);
-
-#if GR_CACHE_STATS
-        resourceCache->getStats(&stats);
-        REPORTER_ASSERT(reporter, 2 == stats.fTotal);
-        REPORTER_ASSERT(reporter, 1 == stats.fNumPurgeable);
-        REPORTER_ASSERT(reporter, 1 == stats.fNumNonPurgeable);
-#endif
-
-        cache.end();
-
-#if GR_CACHE_STATS
-        resourceCache->getStats(&stats);
-        REPORTER_ASSERT(reporter, 2 == stats.fTotal);
-        REPORTER_ASSERT(reporter, 2 == stats.fNumPurgeable);
-#endif
+        // TODO: add VRAM/resource cache check here
     }
 }