Revert of Discard atlas after every MultiPictureDraw::draw

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 63 matching lines @@
     }
 
 private:
     const GrTexture* fBackingTexture;
     const GrCachedLayer* fLayer;
 };
 #endif
 
 GrLayerCache::GrLayerCache(GrContext* context)
     : fContext(context) {
+    this->initAtlas();
     memset(fPlotLocks, 0, sizeof(fPlotLocks));
 }
 
 GrLayerCache::~GrLayerCache() {
 
     SkTDynamicHash<GrCachedLayer, GrCachedLayer::Key>::Iter iter(&fLayerHash);
     for (; !iter.done(); ++iter) {
         GrCachedLayer* layer = &(*iter);
         SkASSERT(0 == layer->uses());
         this->unlock(layer);
@@ skipping 18 matching lines @@
     SkTDynamicHash<GrCachedLayer, GrCachedLayer::Key>::Iter iter(&fLayerHash);
     for (; !iter.done(); ++iter) {
         GrCachedLayer* layer = &(*iter);
         this->unlock(layer);
         SkDELETE(layer);
     }
     fLayerHash.rewind();
 
     // The atlas only lets go of its texture when the atlas is deleted. 
     fAtlas.free();
+    // GrLayerCache always assumes an atlas exists so recreate it. The atlas 
+    // lazily allocates a replacement texture so reallocating a new 
+    // atlas here won't disrupt a GrContext::abandonContext or freeGpuResources.
+    // TODO: Make GrLayerCache lazily allocate the atlas manager?
+    this->initAtlas();
 }
 
 GrCachedLayer* GrLayerCache::createLayer(uint32_t pictureID, 
                                          int start, int stop, 
                                          const SkIRect& bounds,
                                          const SkMatrix& ctm,
                                          const SkPaint* paint) {
     SkASSERT(pictureID != SK_InvalidGenID && start >= 0 && stop > 0);
 
     GrCachedLayer* layer = SkNEW_ARGS(GrCachedLayer, (pictureID, start, stop, bounds, ctm, paint));
@@ skipping 25 matching lines @@
 
 bool GrLayerCache::tryToAtlas(GrCachedLayer* layer, 
                               const GrTextureDesc& desc, 
                               bool* needsRendering) {
     SkDEBUGCODE(GrAutoValidateLayer avl(fAtlas->getTexture(), layer);)
 
     SkASSERT(PlausiblyAtlasable(desc.fWidth, desc.fHeight));
 
     if (layer->locked()) {
         // This layer is already locked
-        SkASSERT(fAtlas);
         SkASSERT(layer->isAtlased());
         SkASSERT(layer->rect().width() == desc.fWidth);
         SkASSERT(layer->rect().height() == desc.fHeight);
         *needsRendering = false;
         return true;
     }
 
     if (layer->isAtlased()) {
-        SkASSERT(fAtlas);
         // Hooray it is still in the atlas - make sure it stays there
         layer->setLocked(true);
         this->incPlotLock(layer->plot()->id());
         *needsRendering = false;
         return true;
     } else {
-        if (!fAtlas) {
-            this->initAtlas();
-            if (!fAtlas) {
-                return false;
-            }
-        }
         // Not in the atlas - will it fit?
         GrPictureInfo* pictInfo = fPictureHash.find(layer->pictureID());
         if (NULL == pictInfo) {
             pictInfo = SkNEW_ARGS(GrPictureInfo, (layer->pictureID()));
             fPictureHash.add(pictInfo);
         }
 
         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,
@@ skipping 52 matching lines @@
         // invalid or not locked
         return;
     }
 
     if (layer->isAtlased()) {
         const int plotID = layer->plot()->id();
 
         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
+#if DISABLE_CACHING
         // 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());
         
         layer->setPlot(NULL);
         layer->setTexture(NULL, GrIRect16::MakeEmpty());
@@ skipping 78 matching lines @@
 
     GrPictureInfo* pictInfo = fPictureHash.find(pictureID);
     if (pictInfo) {
         fPictureHash.remove(pictureID);
         SkDELETE(pictInfo);
     }
 }
 
 bool GrLayerCache::purgePlot() {
     SkDEBUGCODE(GrAutoValidateCache avc(this);)
-    SkASSERT(fAtlas);
 
     GrAtlas::PlotIter iter;
     GrPlot* plot;
     for (plot = fAtlas->iterInit(&iter, GrAtlas::kLRUFirst_IterOrder);
          plot;
          plot = iter.prev()) {
         if (fPlotLocks[plot->id()] > 0) {
             continue;
         }
 
@@ skipping 34 matching lines @@
             if (pictInfo->fPlotUsage.isEmpty()) {
                 fPictureHash.remove(pictInfo->fPictureID);
                 SkDELETE(pictInfo);
             }
         }
     }
 
     plot->resetRects();
 }
 
-#if !GR_CACHE_HOISTED_LAYERS
 void GrLayerCache::purgeAll() {
-    if (!fAtlas) {
-        return;
-    }
-
     GrAtlas::PlotIter iter;
     GrPlot* plot;
     for (plot = fAtlas->iterInit(&iter, GrAtlas::kLRUFirst_IterOrder);
          plot;
          plot = iter.prev()) {
         SkASSERT(0 == fPlotLocks[plot->id()]);
 
         this->purgePlot(plot);
     }
-
-    fContext->discardRenderTarget(fAtlas->getTexture()->asRenderTarget());
 }
-#endif
 
 class GrPictureDeletionListener : public SkPicture::DeletionListener {
     virtual void onDeletion(uint32_t pictureID) SK_OVERRIDE{
         const GrPictureDeletedMessage message = { pictureID };
         SkMessageBus<GrPictureDeletedMessage>::Post(message);
     }
 };
 
 void GrLayerCache::trackPicture(const SkPicture* picture) {
     if (NULL == fDeletionListener) {
         fDeletionListener.reset(SkNEW(GrPictureDeletionListener));
     }
 
     picture->addDeletionListener(fDeletionListener);
 }
 
 void GrLayerCache::processDeletedPictures() {
     SkTDArray<GrPictureDeletedMessage> deletedPictures;
     fPictDeletionInbox.poll(&deletedPictures);
 
     for (int i = 0; i < deletedPictures.count(); i++) {
         this->purge(deletedPictures[i].pictureID);
     }
 }
 
 #ifdef SK_DEVELOPER
 void GrLayerCache::writeLayersToDisk(const SkString& dirName) {
 
-    if (fAtlas) {
-        GrTexture* atlasTexture = fAtlas->getTexture();
-        if (NULL != atlasTexture) {
-            SkString fileName(dirName);
-            fileName.append("\\atlas.png");
+    GrTexture* atlasTexture = fAtlas->getTexture();
+    if (NULL != atlasTexture) {
+        SkString fileName(dirName);
+        fileName.append("\\atlas.png");
 
-            atlasTexture->surfacePriv().savePixels(fileName.c_str());
-        }
+        atlasTexture->surfacePriv().savePixels(fileName.c_str());
     }
 
     SkTDynamicHash<GrCachedLayer, GrCachedLayer::Key>::Iter iter(&fLayerHash);
     for (; !iter.done(); ++iter) {
         GrCachedLayer* layer = &(*iter);
 
         if (layer->isAtlased() || !layer->texture()) {
             continue;
         }
 
         SkString fileName(dirName);
         fileName.appendf("\\%d-%d.png", layer->fKey.pictureID(), layer->fKey.start());
 
         layer->texture()->surfacePriv().savePixels(fileName.c_str());
     }
 }
 #endif