Fix bug in GrCachedLayer reuse

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 79 matching lines @@
 
     // GrCachedLayer proper
     GrCachedLayer(uint32_t pictureID, int start, int stop,
                   const SkMatrix& ctm, const SkPaint* paint)
         : fKey(pictureID, start, ctm)
         , fStop(stop)
         , fPaint(paint ? SkNEW_ARGS(SkPaint, (*paint)) : NULL)
         , fTexture(NULL)
         , fRect(GrIRect16::MakeEmpty())
         , fPlot(NULL)
+        , fUses(0)
         , fLocked(false) {
         SkASSERT(SK_InvalidGenID != pictureID && start >= 0 && stop >= 0);
     }
 
     ~GrCachedLayer() {
         SkSafeUnref(fTexture);
         SkDELETE(fPaint);
     }
 
     uint32_t pictureID() const { return fKey.pictureID(); }
@@ skipping 38 matching lines @@
 
     // 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 NULL.
     GrIRect16       fRect;
 
     // For atlased layers, fPlot stores the atlas plot in which the layer rests.
     // It is always NULL for non-atlased layers.
     GrPlot*         fPlot;
 
+    // The number of actively hoisted layers using this cached image (e.g.,
+    // extant GrHoistedLayers pointing at this object). This object will
+    // be unlocked when the use count reaches 0.
+    int             fUses;
+
     // For non-atlased layers 'fLocked' should always match "fTexture".
     // (i.e., if there is a texture it is locked).
     // For atlased layers, 'fLocked' is true if the layer is in a plot and
     // actively required for rendering. If the layer is in a plot but not
     // actively required for rendering, then 'fLocked' is false. If the
     // layer isn't in a plot then is can never be locked.
     bool            fLocked;
+
+    void addUse()     { ++fUses; }
+    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.
 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, int start, const SkMatrix& ctm);
     GrCachedLayer* findLayerOrCreate(uint32_t pictureID,
                                      int start, int stop, 
                                      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);
 
-    // Inform the cache that layer's cached image is not currently required
-    void unlock(GrCachedLayer* layer);
+    // 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;)
 
 private:
@@ skipping 23 matching lines @@
     SkAutoTUnref<SkPicture::DeletionListener> fDeletionListener;
 
     // This implements a plot-centric locking mechanism (since the atlas
     // backing texture is always locked). Each layer that is locked (i.e.,
     // needed for the current rendering) in a plot increments the plot lock
     // count for that plot. Similarly, once a rendering is complete all the
     // layers used in it decrement the lock count for the used plots.
     // Plots with a 0 lock count are open for recycling/purging.
     int fPlotLocks[kNumPlotsX * kNumPlotsY];
 
+    // Inform the cache that layer's cached image is not currently required
+    void unlock(GrCachedLayer* layer);
+
     void initAtlas();
     GrCachedLayer* createLayer(uint32_t pictureID, int start, int stop, 
                                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