Update Layer Hoisting to store its atlas texture in the resource cache

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 147 matching lines @@
                   const SkPaint* paint)
         : fKey(pictureID, ctm, key, keySize, true)
         , fStart(start)
         , fStop(stop)
         , fSrcIR(srcIR)
         , fDstIR(dstIR)
         , fOffset(SkIPoint::Make(0, 0))
         , fPaint(paint ? new SkPaint(*paint) : nullptr)
         , fFilter(nullptr)
         , fTexture(nullptr)
+        , fAtlased(false)
         , fRect(SkIRect::MakeEmpty())
         , fPlot(nullptr)
         , fUses(0)
         , fLocked(false) {
         SkASSERT(SK_InvalidGenID != pictureID);
 
         if (fPaint) {
             if (fPaint->getImageFilter()) {
                 fFilter = SkSafeRef(fPaint->getImageFilter());
                 fPaint->setImageFilter(nullptr);
             }
         }
     }
 
     ~GrCachedLayer() {
-        SkSafeUnref(fTexture);
+        if (!fAtlased) {
+            SkSafeUnref(fTexture);
+        }
         SkSafeUnref(fFilter);
         delete fPaint;
     }
 
     uint32_t pictureID() const { return fKey.pictureID(); }
     // TODO: remove these when GrCachedLayer & ReplacementInfo fuse
     const int* key() const { return fKey.key(); }
     int keySize() const { return fKey.keySize(); }
 
     int start() const { return fStart; }
     // TODO: make bound debug only
     const SkIRect& srcIR() const { return fSrcIR; }
     const SkIRect& dstIR() const { return fDstIR; }
     int stop() const { return fStop; }
-    void setTexture(GrTexture* texture, const SkIRect& rect) {
-        SkRefCnt_SafeAssign(fTexture, texture);
+    void setTexture(GrTexture* texture, const SkIRect& rect, bool atlased) {
+        if (texture && !atlased) {
+            texture->ref();  // non-atlased textures carry a ref
+        }
+        if (fTexture && !fAtlased) {
+            fTexture->unref();  // non-atlased textures carry a ref
+        }
+        fTexture = texture;
+        fAtlased = atlased;
         fRect = rect;
         if (!fTexture) {
             fLocked = false;
         }
     }
     GrTexture* texture() { return fTexture; }
     const SkPaint* paint() const { return fPaint; }
     const SkImageFilter* filter() const { return fFilter; }
     const SkIRect& rect() const { return fRect; }
 
     void setOffset(const SkIPoint& offset) { fOffset = offset; }
     const SkIPoint& offset() const { return fOffset; }
 
     void setPlot(GrLayerAtlas::Plot* plot) {
         SkASSERT(nullptr == plot || nullptr == fPlot);
         fPlot = plot;
     }
     GrLayerAtlas::Plot* plot() { return fPlot; }
 
-    bool isAtlased() const { return SkToBool(fPlot); }
+    bool isAtlased() const { SkASSERT(fAtlased == SkToBool(fPlot)); return fAtlased; }
 
     void setLocked(bool locked) { fLocked = locked; }
     bool locked() const { return fLocked; }
 
     SkDEBUGCODE(const GrLayerAtlas::Plot* plot() const { return fPlot; })
     SkDEBUGCODE(void validate(const GrTexture* backingTexture) const;)
 
 private:
     const Key       fKey;
 
@@ skipping 15 matching lines @@
     SkPaint*  fPaint;
 
     // The imagefilter that needs to be applied to the layer prior to it being
     // composited with the rest of the scene.
     const SkImageFilter* fFilter;
 
     // fTexture is a ref on the atlasing texture for atlased layers and a
     // ref on a GrTexture for non-atlased textures.
     GrTexture*      fTexture;
 
+    // true if this layer is in the atlas (and 'fTexture' doesn't carry a ref)
+    // and false if the layer is a free floater (and carries a ref).
+    bool            fAtlased;
+
     // For both atlased and non-atlased layers 'fRect' contains the  bound of
     // the layer in whichever texture it resides. It is empty when 'fTexture'
     // is nullptr.
     SkIRect         fRect;
 
     // For atlased layers, fPlot stores the atlas plot in which the layer rests.
     // It is always nullptr for non-atlased layers.
     GrLayerAtlas::Plot* fPlot;
 
     // The number of actively hoisted layers using this cached image (e.g.,
@@ skipping 13 matching lines @@
     void removeUse()  { SkASSERT(fUses > 0); --fUses; }
     int uses() const { return fUses; }
 
     friend class GrLayerCache;  // for access to usage methods
     friend class TestingAccess; // for testing
 };
 
 // The GrLayerCache caches pre-computed saveLayers for later rendering.
 // Non-atlased layers are stored in their own GrTexture while the atlased
 // layers share a single GrTexture.
-// Unlike the GrFontCache, the GrTexture atlas only has one GrAtlas (for 8888)
-// and one GrPlot (for the entire atlas). As such, the GrLayerCache
-// roughly combines the functionality of the GrFontCache and GrTextStrike
-// classes.
+// Unlike the GrFontCache, the GrLayerCache only has one atlas (for 8888).
+// As such, the GrLayerCache roughly combines the functionality of the
+// GrFontCache and GrTextStrike classes.
 class GrLayerCache {
 public:
     GrLayerCache(GrContext*);
     ~GrLayerCache();
 
     // As a cache, the GrLayerCache can be ordered to free up all its cached
     // elements by the GrContext
     void freeAll();
 
     GrCachedLayer* findLayer(uint32_t pictureID, const SkMatrix& ctm,
@@ skipping 37 matching lines @@
     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;
     }
 
+    void begin();
+    void end();
+
 #if !GR_CACHE_HOISTED_LAYERS
     void purgeAll();
 #endif
 
 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;
 
     GrContext*                  fContext;  // pointer back to owning context
-    SkAutoTDelete<GrLayerAtlas> fAtlas;    // TODO: could lazily allocate
+    SkAutoTDelete<GrLayerAtlas> fAtlas;    // lazily allocated
 
     // We cache this information here (rather then, say, on the owning picture)
     // because we want to be able to clean it up as needed (e.g., if a picture
     // is leaked and never cleans itself up we still want to be able to
     // remove the GrPictureInfo once its layers are purged from all the atlas
     // plots).
     SkTDynamicHash<GrPictureInfo, uint32_t> fPictureHash;
 
     SkTDynamicHash<GrCachedLayer, GrCachedLayer::Key> fLayerHash;
 
@@ skipping 15 matching lines @@
                                const SkIRect& srcIR, const SkIRect& dstIR,
                                const SkMatrix& initialMat,
                                const int* key, int keySize,
                                const SkPaint* paint);
 
     // Remove all the layers (and unlock any resources) associated with 'pictureID'
     void purge(uint32_t pictureID);
 
     void purgePlot(GrLayerAtlas::Plot* plot);
 
-    // Try to find a purgeable plot and clear it out. Return true if a plot
+    // Either purge all un-locked plots or just one. Return true if >= 1 plot
     // was purged; false otherwise.
-    bool purgePlot();
+    bool purgePlots(bool justOne);
 
     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