Remove Picture deletion listeners.

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
 
 #include "GrAtlas.h"
 #include "GrRect.h"
 
 #include "SkChecksum.h"
 #include "SkMessageBus.h"
 #include "SkPicture.h"
 #include "SkTDynamicHash.h"
 
 // Set to 0 to disable caching of hoisted layers
 #define GR_CACHE_HOISTED_LAYERS 0
 
-// 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 
+// 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:
     static const int kNumPlots = 4;
 
     // 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
@@ skipping 217 matching lines @@
     // 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) {
@@ skipping 19 matching lines @@
 
     // 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;
+    SkMessageBus<SkPicture::DeletionMessage>::Inbox fPictDeletionInbox;
 
     // 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
@@ skipping 18 matching lines @@
         SkASSERT(fPlotLocks[plotIdx] > 0);
         --fPlotLocks[plotIdx];
     }
 
     // for testing
     friend class TestingAccess;
     int numLayers() const { return fLayerHash.count(); }
 };
 
 #endif