Change SkResourceCache to take a Visitor inside its find().

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 42 matching lines @@
         uint32_t fHash;
         /* uint32_t fContents32[] */
 
         const uint32_t* as32() const { return (const uint32_t*)this; }
         const uint32_t* as32SkipCount() const { return this->as32() + 1; }
     };
 
     struct Rec {
         typedef SkResourceCache::Key Key;
 
-        Rec() : fLockCount(1) {}
+        Rec() {}
         virtual ~Rec() {}
 
         uint32_t getHash() const { return this->getKey().hash(); }
 
         virtual const Key& getKey() const = 0;
         virtual size_t bytesUsed() const = 0;
 
         // for SkTDynamicHash::Traits
         static uint32_t Hash(const Key& key) { return key.hash(); }
         static const Key& GetKey(const Rec& rec) { return rec.getKey(); }
 
     private:
         Rec*    fNext;
         Rec*    fPrev;
-        int32_t fLockCount;
 
         friend class SkResourceCache;
     };
 
     typedef const Rec* ID;
 
     /**
+     *  Callback function for find(). If called, the cache will have found a match for the
+     *  specified Key, and will pass in the corresponding Rec, along with a caller-specified
+     *  context. The function can read the data in Rec, and copy whatever it likes into context
+     *  (casting context to whatever it really is).
+     *
+     *  The return value determines what the cache will do with the Rec. If the function returns
+     *  true, then the Rec is considered "valid". If false is returned, the Rec will be considered
+     *  "stale" and will be purged from the cache.
+     */
+    typedef bool (*VisitorProc)(const Rec&, void* context);
+
+    /**
      *  Returns a locked/pinned SkDiscardableMemory instance for the specified
      *  number of bytes, or NULL on failure.
      */
     typedef SkDiscardableMemory* (*DiscardableFactory)(size_t bytes);
 
     /*
      *  The following static methods are thread-safe wrappers around a global
      *  instance of this cache.
      */
 
-    static const Rec* FindAndLock(const Key& key);
-    static const Rec* AddAndLock(Rec*);
+    /**
+     *  Returns true if the visitor was called on a matching Key, and the visitor returned true.
+     *
+     *  Find() will search the cache for the specified Key. If no match is found, return false and
+     *  do not call the VisitorProc. If a match is found, return whatever the visitor returns.
+     *  Its return value is interpreted to mean:
+     *      true  : Rec is valid
+     *      false : Rec is "stale" -- the cache will purge it.
+     */
+    static bool Find(const Key& key, VisitorProc, void* context);
     static void Add(Rec*);
-    static void Unlock(ID);
-    static void Remove(ID);
 
     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();
 
     static void PurgeAll();
 
@@ skipping 21 matching lines @@
 
     /**
      *  Construct the cache, allocating memory with malloc, and respect the
      *  byteLimit, purging automatically when a new image is added to the cache
      *  that pushes the total bytesUsed over the limit. Note: The limit can be
      *  changed at runtime with setTotalByteLimit.
      */
     explicit SkResourceCache(size_t byteLimit);
     ~SkResourceCache();
 
-    const Rec* findAndLock(const Key& key);
-    const Rec* addAndLock(Rec*);
+    /**
+     *  Returns true if the visitor was called on a matching Key, and the visitor returned true.
+     *
+     *  find() will search the cache for the specified Key. If no match is found, return false and
+     *  do not call the VisitorProc. If a match is found, return whatever the visitor returns.
+     *  Its return value is interpreted to mean:
+     *      true  : Rec is valid
+     *      false : Rec is "stale" -- the cache will purge it.
+     */
+    bool find(const Key&, VisitorProc, void* context);
     void add(Rec*);
-    void remove(Rec*);
-
-    /**
-     *  Given a non-null ID ptr returned by either findAndLock or addAndLock,
-     *  this releases the associated resources to be available to be purged
-     *  if needed. After this, the cached bitmap should no longer be
-     *  referenced by the caller.
-     */
-    void unlock(ID);
 
     size_t getTotalBytesUsed() const { return fTotalBytesUsed; }
     size_t getTotalByteLimit() const { return fTotalByteLimit; }
 
     /**
      *  This is respected by SkBitmapProcState::possiblyScaleImage.
      *  0 is no maximum at all; this is the default.
      *  setSingleAllocationByteLimit() returns the previous value.
      */
     size_t setSingleAllocationByteLimit(size_t maximumAllocationSize);
@@ skipping 31 matching lines @@
     size_t  fTotalByteLimit;
     size_t  fSingleAllocationByteLimit;
     int     fCount;
 
     void purgeAsNeeded(bool forcePurge = false);
 
     // linklist management
     void moveToHead(Rec*);
     void addToHead(Rec*);
     void detach(Rec*);
+    void remove(Rec*);
 
     void init();    // called by constructors
 
 #ifdef SK_DEBUG
     void validate() const;
 #else
     void validate() const {}
 #endif
 };
 #endif