Provide an option in bench_pictures to count pixel ram.

include/lazy/SkLruImageCache.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 SkLruImageCache_DEFINED
 #define SkLruImageCache_DEFINED
 
 #include "SkImageCache.h"
 #include "SkThread.h"
 #include "SkTInternalLList.h"
 
 class CachedPixels;
 
 /**
  *  SkImageCache implementation that uses an LRU cache to age out old images.
  */
 class SkLruImageCache : public SkImageCache {
 
 public:
     SkLruImageCache(size_t budget);
 
     virtual ~SkLruImageCache();
 
 #ifdef SK_DEBUG
     CacheStatus getCacheStatus(intptr_t ID) const SK_OVERRIDE;
 #endif
 

[reed1, 2013/03/04 20:07:27]

existing API naming we use for font cache. Maybe we share naming styles?

    static size_t GetFontCacheLimit();
    static size_t SetFontCacheLimit(size_t bytes);
    static size_t GetFontCacheUsed();

[scroggo, 2013/03/04 20:49:29]

Done. Currently, we do not have a notion like the font cache of having a single
global/single per thread (though I'm happy to revisit that), so I left them
member functions rather than static. They do have similar names though.

+    /**
+     *  Set the budget. If more bytes are used than this, the cache will free unpinned memory until
+     *  under the new budget or until all unpinned memory is freed. This will never free pinned
+     *  memory, so the cache can potentially remain over budget. The budget is enforced each time
+     *  memory is allocated or released.
+     *  0 is a special flag for an infinite budget.
+     */
     void setBudget(size_t newBudget);
 
+    /**
+     *  Return the amount of memory currently in use by the cache. Can include memory that is no
+     *  longer pinned, but has not been freed.
+     */
+    size_t getRamUsed() const { return fRamUsed; }
+
     virtual void* allocAndPinCache(size_t bytes, intptr_t* ID) SK_OVERRIDE;
     virtual void* pinCache(intptr_t ID) SK_OVERRIDE;
     virtual void releaseCache(intptr_t ID) SK_OVERRIDE;
     virtual void throwAwayCache(intptr_t ID) SK_OVERRIDE;
 
 private:
     // Linked list of recently used. Head is the most recently used, and tail is the least.
     SkTInternalLList<CachedPixels> fLRU;
     typedef SkTInternalLList<CachedPixels>::Iter Iter;
 
@@ skipping 22 matching lines @@
      */
     void purgeTilAtOrBelow(size_t limit);
 
     /**
      *  Remove a set of CachedPixels. Mutex must be locked before calling.
      */
     void removePixels(CachedPixels*);
 };
 
 #endif // SkLruImageCache_DEFINED