Add auto purging for SkPicture-related Ganesh resources (esp. layers)

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
 
 #define USE_ATLAS 0
 
 #include "GrAllocPool.h"
 #include "GrAtlas.h"
 #include "GrPictureUtils.h"
 #include "GrRect.h"
 #include "SkChecksum.h"
 #include "SkTDynamicHash.h"
+#include "SkMessageBus.h"
 
 class SkPicture;
 
+// The layer cache listens for these messages to purge picture-related resources.
+struct GrPictureDeletedMessage {
+    uint32_t pictureID;
+};
+
 // GrPictureInfo stores the atlas plots used by a single picture. A single 
 // plot may be used to store layers from multiple pictures.
 struct GrPictureInfo {
 public:
     // for SkTDynamicHash - just use the pictureID as the hash key
     static const uint32_t& GetKey(const GrPictureInfo& pictInfo) { return pictInfo.fPictureID; }
     static uint32_t Hash(const uint32_t& key) { return SkChecksum::Mix(key); }
 
     // GrPictureInfo proper
     GrPictureInfo(uint32_t pictureID) : fPictureID(pictureID) { }
@@ skipping 107 matching lines @@
     
     // Inform the cache that layer's cached image is now required. Return true
     // if it was found in the ResourceCache and doesn't need to be regenerated.
     // If false is returned the caller should (re)render the layer into the
     // newly acquired texture.
     bool lock(GrCachedLayer* layer, const GrTextureDesc& desc);
 
     // Inform the cache that layer's cached image is not currently required
     void unlock(GrCachedLayer* layer);
 
-    // Remove all the layers (and unlock any resources) associated with 'picture'
-    void purge(const SkPicture* picture);
+    // 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:
     static const int kNumPlotsX = 2;
     static const int kNumPlotsY = 2;
 
     GrContext*                fContext;  // pointer back to owning context
     SkAutoTDelete<GrAtlas>    fAtlas;    // TODO: could lazily allocate
 
     // 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;
 
+    SkMessageBus<GrPictureDeletedMessage>::Inbox fPictDeletionInbox;
+
+    SkAutoTUnref<SkPicture::DeletionListener> fDeletionListener;
+
     void initAtlas();
     GrCachedLayer* createLayer(const SkPicture* picture, int layerID);
 
+    // Remove all the layers (and unlock any resources) associated with 'pictureID'
+    void purge(uint32_t pictureID);
+
     // for testing
-    friend class GetNumLayers;
+    friend class TestingAccess;
     int numLayers() const { return fLayerHash.count(); }
 };
 
 #endif