Fix bug in aggressive layer cache purging

src/gpu/GrLayerCache.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.
  */
 
 #include "GrAtlas.h"
 #include "GrGpu.h"
 #include "GrLayerCache.h"
@@ skipping 82 matching lines @@
         this->unlock(layer);
         SkDELETE(layer);
     }
 
     // The atlas only lets go of its texture when the atlas is deleted. 
     fAtlas.free();    
 }
 
 void GrLayerCache::initAtlas() {
     SkASSERT(NULL == fAtlas.get());
+    GR_STATIC_ASSERT(kNumPlotsX*kNumPlotsX == GrPictureInfo::kNumPlots);
 
     SkISize textureSize = SkISize::Make(kAtlasTextureWidth, kAtlasTextureHeight);
     fAtlas.reset(SkNEW_ARGS(GrAtlas, (fContext->getGpu(), kSkia8888_GrPixelConfig,
                                       kRenderTarget_GrSurfaceFlag,
                                       textureSize, kNumPlotsX, kNumPlotsY, false)));
 }
 
 void GrLayerCache::freeAll() {
 
     SkTDynamicHash<GrCachedLayer, GrCachedLayer::Key>::Iter iter(&fLayerHash);
@@ skipping 81 matching lines @@
         }
 
         SkIPoint16 loc;
         for (int i = 0; i < 2; ++i) { // extra pass in case we fail to add but are able to purge
             GrPlot* plot = fAtlas->addToAtlas(&pictInfo->fPlotUsage,
                                               desc.fWidth, desc.fHeight,
                                               NULL, &loc);
             // addToAtlas can allocate the backing texture
             SkDEBUGCODE(avl.setBackingTexture(fAtlas->getTexture()));
             if (plot) {
+#if !GR_CACHE_HOISTED_LAYERS
+                pictInfo->incPlotUsage(plot->id());
+#endif
                 // The layer was successfully added to the atlas
                 GrIRect16 bounds = GrIRect16::MakeXYWH(loc.fX, loc.fY,
                                                        SkToS16(desc.fWidth),
                                                        SkToS16(desc.fHeight));
                 layer->setTexture(fAtlas->getTexture(), bounds);
                 layer->setPlot(plot);
                 layer->setLocked(true);
                 this->incPlotLock(layer->plot()->id());
                 *needsRendering = true;
                 return true;
@@ skipping 43 matching lines @@
 
         this->decPlotLock(plotID);
         // At this point we could aggressively clear out un-locked plots but
         // by delaying we may be able to reuse some of the atlased layers later.
 #if !GR_CACHE_HOISTED_LAYERS
         // This testing code aggressively removes the atlased layers. This
         // can be used to separate the performance contribution of less
         // render target pingponging from that due to the re-use of cached layers
         GrPictureInfo* pictInfo = fPictureHash.find(layer->pictureID());
         SkASSERT(pictInfo);
-        
-        GrAtlas::RemovePlot(&pictInfo->fPlotUsage, layer->plot());
+
+        pictInfo->decPlotUsage(plotID);
+
+        if (0 == pictInfo->plotUsage(plotID)) {
+            GrAtlas::RemovePlot(&pictInfo->fPlotUsage, layer->plot());
+        }
         
         layer->setPlot(NULL);
         layer->setTexture(NULL, GrIRect16::MakeEmpty());
 #endif
 
     } else {
         layer->setTexture(NULL, GrIRect16::MakeEmpty());
     }
 
     layer->setLocked(false);
@@ skipping 15 matching lines @@
             // If there is no picture info for this picture then all of its
             // layers should be non-atlased.
             SkASSERT(!layer->isAtlased());
         }
 
         if (layer->plot()) {
             SkASSERT(pictInfo);
             SkASSERT(pictInfo->fPictureID == layer->pictureID());
 
             SkASSERT(pictInfo->fPlotUsage.contains(layer->plot()));
+#if !GR_CACHE_HOISTED_LAYERS
+            SkASSERT(pictInfo->plotUsage(layer->plot()->id()) > 0);
+#endif
 
             if (layer->locked()) {
                 plotLocks[layer->plot()->id()]++;
             }
         } 
     }
 
     for (int i = 0; i < kNumPlotsX*kNumPlotsY; ++i) {
         SkASSERT(plotLocks[i] == fPlotLocks[i]);
     }
@@ skipping 79 matching lines @@
         SkASSERT(!toBeRemoved[i]->locked());
 
         uint32_t pictureIDToRemove = toBeRemoved[i]->pictureID();
 
         // Aggressively remove layers and, if it becomes totally uncached, delete the picture info
         fLayerHash.remove(GrCachedLayer::GetKey(*toBeRemoved[i]));
         SkDELETE(toBeRemoved[i]);
 
         GrPictureInfo* pictInfo = fPictureHash.find(pictureIDToRemove);
         if (pictInfo) {
+#if !GR_CACHE_HOISTED_LAYERS
+            SkASSERT(0 == pictInfo->plotUsage(plot->id()));
+#endif
             GrAtlas::RemovePlot(&pictInfo->fPlotUsage, plot);
 
             if (pictInfo->fPlotUsage.isEmpty()) {
                 fPictureHash.remove(pictInfo->fPictureID);
                 SkDELETE(pictInfo);
             }
         }
     }
 
     plot->resetRects();
@@ skipping 64 matching lines @@
             continue;
         }
 
         SkString fileName(dirName);
         fileName.appendf("\\%d-%d.png", layer->fKey.pictureID(), layer->fKey.start());
 
         layer->texture()->surfacePriv().savePixels(fileName.c_str());
     }
 }
 #endif