private iterator to visit all resource cache entries

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
 
 #include "SkBitmap.h"
 #include "SkMessageBus.h"
 #include "SkTDArray.h"
 
 class SkCachedData;
 class SkDiscardableMemory;
-class SkMipMap;
 
 /**
  *  Cache object for bitmaps (with possible scale in X Y as part of the key).
  *
  *  Multiple caches can be instantiated, but each instance is not implicitly
  *  thread-safe, so if a given instance is to be shared across threads, the
  *  caller must manage the access itself (e.g. via a mutex).
  *
  *  As a convenience, a global instance is also defined, which can be safely
  *  access across threads via the static methods (e.g. FindAndLock, etc.).
@@ skipping 43 matching lines @@
         typedef SkResourceCache::Key Key;
 
         Rec() {}
         virtual ~Rec() {}
 
         uint32_t getHash() const { return this->getKey().hash(); }
 
         virtual const Key& getKey() const = 0;
         virtual size_t bytesUsed() const = 0;
 
+        // for memory usage diagnostics
+        virtual const char* getCategory() const = 0;
+        virtual SkDiscardableMemory* diagnostic_only_getDiscardable() const { return NULL; }
+
         // 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;
 
         friend class SkResourceCache;
     };
@@ skipping 18 matching lines @@
      *  "stale" and will be purged from the cache.
      */
     typedef bool (*FindVisitor)(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);
 
+    /**
+     *  Will be called for each rec in the cache.
+     */
+    typedef void (*Visitor)(const Rec&, void* context);

[mtklein_C, 2015/08/04 20:27:37]

It'd be nice to have Visitor and VisitAll right next to each other?

[reed1, 2015/08/07 16:19:59]

Done.

+
     /*
      *  The following static methods are thread-safe wrappers around a global
      *  instance of this cache.
      */
 
     /**
      *  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 FindVisitor. 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, FindVisitor, void* context);
     static void Add(Rec*);
+    static void VisitAll(Visitor, void* context);
 
     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 size_t GetEffectiveSingleAllocationByteLimit();
 
     static void PurgeAll();
 
+    static void TestDumpMemoryStatistics();
+
     /**
      *  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.
      */
     static SkBitmap::Allocator* GetAllocator();
@@ skipping 31 matching lines @@
      *  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 FindVisitor. 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&, FindVisitor, void* context);
     void add(Rec*);
+    void visitAll(Visitor, void* context);
 
     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 54 matching lines @@
 
     void init();    // called by constructors
 
 #ifdef SK_DEBUG
     void validate() const;
 #else
     void validate() const {}
 #endif
 };
 #endif