Alter layer hoisting to only hoist layers for one canvas at a time

src/gpu/GrLayerCache.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrLayerCache_DEFINED
 #define GrLayerCache_DEFINED
 
@@ skipping 190 matching lines @@
     void freeAll();
 
     GrCachedLayer* findLayer(uint32_t pictureID, int start, 
                              const SkIRect& bounds, const SkMatrix& ctm);
     GrCachedLayer* findLayerOrCreate(uint32_t pictureID,
                                      int start, int stop, 
                                      const SkIRect& bounds,
                                      const SkMatrix& ctm,
                                      const SkPaint* paint);
 
-    // Inform the cache that layer's cached image is now required. 
-    // Return true if the layer must be re-rendered. Return false if the
-    // layer was found in the cache and can be reused.
-    bool lock(GrCachedLayer* layer, const GrTextureDesc& desc, bool dontAtlas);
+    // Attempt to place 'layer' in the atlas. Return true on success; false on failure.
+    // When true is returned, 'needsRendering' will indicate if the layer must be (re)drawn.
+    // Additionally, the GPU resources will be locked.
+    bool tryToAtlas(GrCachedLayer* layer, const GrTextureDesc& desc, bool* needsRendering);
+
+    // Attempt to lock the GPU resources required for a layer. Return true on success;
+    // false on failure. When true is returned 'needsRendering' will indicate if the
+    // layer must be (re)drawn.
+    // Note that atlased layers should already have been locked and rendered so only
+    // free floating layers will have 'needsRendering' set.
+    // Currently, this path always uses a new scratch texture for non-Atlased layers
+    // and (thus) doesn't cache anything. This can yield a lot of re-rendering.
+    // TODO: allow rediscovery of free-floating layers that are still in the resource cache.
+    bool lock(GrCachedLayer* layer, const GrTextureDesc& desc, bool* needsRendering);
 
     // addUse is just here to keep the API symmetric
     void addUse(GrCachedLayer* layer) { layer->addUse(); }
     void removeUse(GrCachedLayer* layer) {
         layer->removeUse();
         if (layer->uses() == 0) {
             // If no one cares about the layer allow it to be recycled.
             this->unlock(layer);
         }
     }
 
     // Setup to be notified when 'picture' is deleted
     void trackPicture(const SkPicture* picture);
 
     // Cleanup after any SkPicture deletions
     void processDeletedPictures();
 
     SkDEBUGCODE(void validate() const;)
 
 #ifdef SK_DEVELOPER
     void writeLayersToDisk(const SkString& dirName);
 #endif
 
+    static bool PlausiblyAtlasable(int width, int height) {
+        return width <= kPlotWidth && height <= kPlotHeight;
+    }
+
 private:
     static const int kAtlasTextureWidth = 1024;
     static const int kAtlasTextureHeight = 1024;
 
     static const int kNumPlotsX = 2;
     static const int kNumPlotsY = 2;
 
     static const int kPlotWidth = kAtlasTextureWidth / kNumPlotsX;
     static const int kPlotHeight = kAtlasTextureHeight / kNumPlotsY;
 
@@ skipping 27 matching lines @@
     void initAtlas();
     GrCachedLayer* createLayer(uint32_t pictureID, int start, int stop, 
                                const SkIRect& bounds, const SkMatrix& ctm, 
                                const SkPaint* paint);
 
     void purgeAll();
 
     // Remove all the layers (and unlock any resources) associated with 'pictureID'
     void purge(uint32_t pictureID);
 
-    static bool PlausiblyAtlasable(int width, int height) {
-        return width <= kPlotWidth && height <= kPlotHeight;
-    }
-
     void purgePlot(GrPlot* plot);
 
     // Try to find a purgeable plot and clear it out. Return true if a plot
     // was purged; false otherwise.
     bool purgePlot();
 
     void incPlotLock(int plotIdx) { ++fPlotLocks[plotIdx]; }
     void decPlotLock(int plotIdx) {
         SkASSERT(fPlotLocks[plotIdx] > 0);
         --fPlotLocks[plotIdx];
     }
 
     // for testing
     friend class TestingAccess;
     int numLayers() const { return fLayerHash.count(); }
 };
 
 #endif