notify resource caches when pixelref genID goes stale

src/core/SkResourceCache.h

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkResourceCache_DEFINED
 #define SkResourceCache_DEFINED
 
@@ skipping 17 matching lines @@
 public:
     struct Key {
         // Call this to access your private contents. Must not use the address after calling init()
         void* writableContents() { return this + 1; }
 
         // must call this after your private data has been written.
         // nameSpace must be unique per Key subclass.
         // length must be a multiple of 4
         void init(void* nameSpace, size_t length);
 
+        void* getNamespace() const { return fNamespace; }
+
         // This is only valid after having called init().
         uint32_t hash() const { return fHash; }
 
         bool operator==(const Key& other) const {
             const uint32_t* a = this->as32();
             const uint32_t* b = other.as32();
             for (int i = 0; i < fCount32; ++i) {  // (This checks fCount == other.fCount first.)
                 if (a[i] != b[i]) {
                     return false;
                 }
@@ skipping 69 matching lines @@
     static bool Find(const Key& key, VisitorProc, void* context);
     static void Add(Rec*);
 
     static size_t GetTotalBytesUsed();
     static size_t GetTotalByteLimit();
     static size_t SetTotalByteLimit(size_t newLimit);
 
     static size_t SetSingleAllocationByteLimit(size_t);
     static size_t GetSingleAllocationByteLimit();
 
+    /**
+     *  Visit all Rec that match the specified namespace:
+     *      true  : Rec is valid

[mtklein, 2015/01/07 21:52:43]

I think everything might read more clearly if we had true mean purge, false mean
keep.

[reed1, 2015/01/07 22:20:41]

I agree 0.499999, but Find uses the same VisitorProc and it treats false as
purge so .... (can't win)

[mtklein, 2015/01/08 14:11:12]

Do you think we'll ever want to pass the same function to both Find and
PurgeVisitor?  If it's super confusing they both take the same signature, we can
always just typedef another bool(*PurgeProc)(const Rec&, void*) with its own
note.

[reed1, 2015/02/18 17:30:32]

Changed to new signature.

+     *      false : Rec is "stale" -- the cache will purge it.
+     */
+    static void PurgeVisitor(const void* nameSpace, VisitorProc, void* context);
+
     static void PurgeAll();
 
     /**
      *  Returns the DiscardableFactory used by the global cache, or NULL.
      */
     static DiscardableFactory GetDiscardableFactory();
 
     /**
      * Use this allocator for bitmaps, so they can use ashmem when available.
      * Returns NULL if the ResourceCache has not been initialized with a DiscardableFactory.
@@ skipping 49 matching lines @@
      */
     size_t setSingleAllocationByteLimit(size_t maximumAllocationSize);
     size_t getSingleAllocationByteLimit() const;
     /**
      *  Set the maximum number of bytes available to this cache. If the current
      *  cache exceeds this new value, it will be purged to try to fit within
      *  this new limit.
      */
     size_t setTotalByteLimit(size_t newLimit);
 
+    void purgeVisitor(const void* nameSpace, VisitorProc, void* context);
+
     void purgeAll() {
         this->purgeAsNeeded(true);
     }
 
     DiscardableFactory discardableFactory() const { return fDiscardableFactory; }
     SkBitmap::Allocator* allocator() const { return fAllocator; };
 
     SkCachedData* newCachedData(size_t bytes);
 
     /**
@@ skipping 27 matching lines @@
 
     void init();    // called by constructors
 
 #ifdef SK_DEBUG
     void validate() const;
 #else
     void validate() const {}
 #endif
 };
 #endif