Provide an option in bench_pictures to count pixel ram.

src/lazy/SkLruImageCache.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkLruImageCache.h"
 
 static intptr_t NextGenerationID() {
@@ skipping 69 matching lines @@
     if (NULL == pixels) {
         return SkImageCache::kThrownAway_CacheStatus;
     }
     if (pixels->isLocked()) {
         return SkImageCache::kPinned_CacheStatus;
     }
     return SkImageCache::kUnpinned_CacheStatus;
 }
 #endif
 
-void SkLruImageCache::setBudget(size_t newBudget) {
+size_t SkLruImageCache::setImageCacheLimit(size_t newLimit) {
+    size_t oldLimit = fRamBudget;
     SkAutoMutexAcquire ac(&fMutex);
-    fRamBudget = newBudget;
+    fRamBudget = newLimit;
     this->purgeIfNeeded();
+    return oldLimit;
 }
 
 void* SkLruImageCache::allocAndPinCache(size_t bytes, intptr_t* ID) {
     SkAutoMutexAcquire ac(&fMutex);
     CachedPixels* pixels = SkNEW_ARGS(CachedPixels, (bytes));
     if (ID != NULL) {
         *ID = pixels->getID();
     }
     pixels->lock();
     fRamUsed += bytes;
@@ skipping 57 matching lines @@
         if (pixels->getID() == ID) {
             return pixels;
         }
         pixels = iter.next();
     }
     return NULL;
 }
 
 void SkLruImageCache::purgeIfNeeded() {
     // Mutex is already locked.
-    this->purgeTilAtOrBelow(fRamBudget);
+    if (fRamBudget > 0) {
+        this->purgeTilAtOrBelow(fRamBudget);
+    }
 }
 
 void SkLruImageCache::purgeTilAtOrBelow(size_t limit) {
     // Mutex is already locked.
     if (fRamUsed > limit) {
         Iter iter;
         // Start from the tail, least recently used.
         CachedPixels* pixels = iter.init(fLRU, Iter::kTail_IterStart);
         while (pixels != NULL && fRamUsed > limit) {
             CachedPixels* prev = iter.prev();
             if (!pixels->isLocked()) {
                 this->removePixels(pixels);
             }
             pixels = prev;
         }
     }
 }