| Index: tests/GpuLayerCacheTest.cpp
 | 
| diff --git a/tests/GpuLayerCacheTest.cpp b/tests/GpuLayerCacheTest.cpp
 | 
| index b91c5b01b0e6f74c09d8f3232266d6d73433d102..95ac7b641ddf6f4531a6aca6b6d782ece1a41387 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 @@
 | 
|                            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 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 @@
 | 
|  // 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
 | 
| -
 | 
| -    for (int i = 0; i < GrContextFactory::kGLContextTypeCnt; ++i) {
 | 
| +    static const int kInitialNumLayers = 5;
 | 
| +
 | 
| +    for (int i= 0; i < GrContextFactory::kGLContextTypeCnt; ++i) {
 | 
|          GrContextFactory::GLContextType glCtxType = (GrContextFactory::GLContextType) i;
 | 
|  
 | 
|          if (!GrContextFactory::IsRenderingGLContext(glCtxType)) {
 | 
| @@ -128,73 +110,50 @@
 | 
|              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 };
 | 
| -            GrCachedLayer* layer = TestingAccess::Find(&cache, picture->uniqueID(), SkMatrix::I(),
 | 
| -                                                       key, 1);
 | 
| +            int indices[1] = { i + 1 };
 | 
| +            GrCachedLayer* layer = TestingAccess::Find(&cache, picture->uniqueID(), SkMatrix::I(),
 | 
| +                                                       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 };
 | 
| -
 | 
| -            GrCachedLayer* layer = TestingAccess::Find(&cache, picture->uniqueID(), SkMatrix::I(),
 | 
| -                                                       key, 1);
 | 
| +            int indices[1] = { i+1 };
 | 
| +
 | 
| +            GrCachedLayer* layer = TestingAccess::Find(&cache, picture->uniqueID(), SkMatrix::I(),
 | 
| +                                                       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 };
 | 
| -
 | 
| -            GrCachedLayer* layer = TestingAccess::Find(&cache, picture->uniqueID(), SkMatrix::I(),
 | 
| -                                                       key, 1);
 | 
| +            int 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
 | 
| @@ -217,37 +176,14 @@
 | 
|  #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 @@
 | 
|          }
 | 
|  
 | 
|          for (int i = 0; i < kInitialNumLayers+1; ++i) {
 | 
| -            int key[1] = { i+1 };
 | 
| -
 | 
| -            GrCachedLayer* layer = TestingAccess::Find(&cache, picture->uniqueID(), SkMatrix::I(),
 | 
| -                                                       key, 1);
 | 
| +            int 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) {
 | 
| @@ -287,14 +223,7 @@
 | 
|          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 @@
 | 
|          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
 | 
|      }
 | 
|  }
 | 
|  
 | 
| 
 |