rename ScaledImageCache to ResourceCache

src/core/SkScaledImageCache.cpp

Index: src/core/SkScaledImageCache.cpp
diff --git a/src/core/SkScaledImageCache.cpp b/src/core/SkScaledImageCache.cpp
deleted file mode 100644
index 9d154223001bcf3201b08c89e7c15cd5bbbf31f8..0000000000000000000000000000000000000000
--- a/src/core/SkScaledImageCache.cpp
+++ /dev/null
@@ -1,584 +0,0 @@
-/*
- * 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 "SkChecksum.h"
-#include "SkScaledImageCache.h"
-#include "SkMipMap.h"
-#include "SkPixelRef.h"
-
-// This can be defined by the caller's build system
-//#define SK_USE_DISCARDABLE_SCALEDIMAGECACHE
-
-#ifndef SK_DISCARDABLEMEMORY_SCALEDIMAGECACHE_COUNT_LIMIT
-#   define SK_DISCARDABLEMEMORY_SCALEDIMAGECACHE_COUNT_LIMIT   1024
-#endif
-
-#ifndef SK_DEFAULT_IMAGE_CACHE_LIMIT
-    #define SK_DEFAULT_IMAGE_CACHE_LIMIT     (2 * 1024 * 1024)
-#endif
-
-void SkScaledImageCache::Key::init(size_t length) {
-    SkASSERT(SkAlign4(length) == length);
-    // 2 is fCount32 and fHash
-    fCount32 = SkToS32(2 + (length >> 2));
-    // skip both of our fields whe computing the murmur
-    fHash = SkChecksum::Murmur3(this->as32() + 2, (fCount32 - 2) << 2);
-}
-
-#include "SkTDynamicHash.h"
-
-class SkScaledImageCache::Hash :
-    public SkTDynamicHash<SkScaledImageCache::Rec, SkScaledImageCache::Key> {};
-
-
-///////////////////////////////////////////////////////////////////////////////
-
-// experimental hash to speed things up
-#define USE_HASH
-
-#if !defined(USE_HASH)
-static inline SkScaledImageCache::Rec* find_rec_in_list(
-        SkScaledImageCache::Rec* head, const Key & key) {
-    SkScaledImageCache::Rec* rec = head;
-    while ((rec != NULL) && (rec->fKey != key)) {
-        rec = rec->fNext;
-    }
-    return rec;
-}
-#endif
-
-void SkScaledImageCache::init() {
-    fHead = NULL;
-    fTail = NULL;
-#ifdef USE_HASH
-    fHash = new Hash;
-#else
-    fHash = NULL;
-#endif
-    fTotalBytesUsed = 0;
-    fCount = 0;
-    fSingleAllocationByteLimit = 0;
-    fAllocator = NULL;
-
-    // One of these should be explicit set by the caller after we return.
-    fTotalByteLimit = 0;
-    fDiscardableFactory = NULL;
-}
-
-#include "SkDiscardableMemory.h"
-
-class SkOneShotDiscardablePixelRef : public SkPixelRef {
-public:
-    SK_DECLARE_INST_COUNT(SkOneShotDiscardablePixelRef)
-    // Ownership of the discardablememory is transfered to the pixelref
-    SkOneShotDiscardablePixelRef(const SkImageInfo&, SkDiscardableMemory*, size_t rowBytes);
-    ~SkOneShotDiscardablePixelRef();
-
-protected:
-    virtual bool onNewLockPixels(LockRec*) SK_OVERRIDE;
-    virtual void onUnlockPixels() SK_OVERRIDE;
-    virtual size_t getAllocatedSizeInBytes() const SK_OVERRIDE;
-
-private:
-    SkDiscardableMemory* fDM;
-    size_t               fRB;
-    bool                 fFirstTime;
-
-    typedef SkPixelRef INHERITED;
-};
-
-SkOneShotDiscardablePixelRef::SkOneShotDiscardablePixelRef(const SkImageInfo& info,
-                                             SkDiscardableMemory* dm,
-                                             size_t rowBytes)
-    : INHERITED(info)
-    , fDM(dm)
-    , fRB(rowBytes)
-{
-    SkASSERT(dm->data());
-    fFirstTime = true;
-}
-
-SkOneShotDiscardablePixelRef::~SkOneShotDiscardablePixelRef() {
-    SkDELETE(fDM);
-}
-
-bool SkOneShotDiscardablePixelRef::onNewLockPixels(LockRec* rec) {
-    if (fFirstTime) {
-        // we're already locked
-        SkASSERT(fDM->data());
-        fFirstTime = false;
-        goto SUCCESS;
-    }
-
-    // A previous call to onUnlock may have deleted our DM, so check for that
-    if (NULL == fDM) {
-        return false;
-    }
-
-    if (!fDM->lock()) {
-        // since it failed, we delete it now, to free-up the resource
-        delete fDM;
-        fDM = NULL;
-        return false;
-    }
-
-SUCCESS:
-    rec->fPixels = fDM->data();
-    rec->fColorTable = NULL;
-    rec->fRowBytes = fRB;
-    return true;
-}
-
-void SkOneShotDiscardablePixelRef::onUnlockPixels() {
-    SkASSERT(!fFirstTime);
-    fDM->unlock();
-}
-
-size_t SkOneShotDiscardablePixelRef::getAllocatedSizeInBytes() const {
-    return this->info().getSafeSize(fRB);
-}
-
-class SkScaledImageCacheDiscardableAllocator : public SkBitmap::Allocator {
-public:
-    SkScaledImageCacheDiscardableAllocator(
-                            SkScaledImageCache::DiscardableFactory factory) {
-        SkASSERT(factory);
-        fFactory = factory;
-    }
-
-    virtual bool allocPixelRef(SkBitmap*, SkColorTable*) SK_OVERRIDE;
-
-private:
-    SkScaledImageCache::DiscardableFactory fFactory;
-};
-
-bool SkScaledImageCacheDiscardableAllocator::allocPixelRef(SkBitmap* bitmap,
-                                                       SkColorTable* ctable) {
-    size_t size = bitmap->getSize();
-    uint64_t size64 = bitmap->computeSize64();
-    if (0 == size || size64 > (uint64_t)size) {
-        return false;
-    }
-
-    SkDiscardableMemory* dm = fFactory(size);
-    if (NULL == dm) {
-        return false;
-    }
-
-    // can we relax this?
-    if (kN32_SkColorType != bitmap->colorType()) {
-        return false;
-    }
-
-    SkImageInfo info = bitmap->info();
-    bitmap->setPixelRef(SkNEW_ARGS(SkOneShotDiscardablePixelRef,
-                                   (info, dm, bitmap->rowBytes())))->unref();
-    bitmap->lockPixels();
-    return bitmap->readyToDraw();
-}
-
-SkScaledImageCache::SkScaledImageCache(DiscardableFactory factory) {
-    this->init();
-    fDiscardableFactory = factory;
-
-    fAllocator = SkNEW_ARGS(SkScaledImageCacheDiscardableAllocator, (factory));
-}
-
-SkScaledImageCache::SkScaledImageCache(size_t byteLimit) {
-    this->init();
-    fTotalByteLimit = byteLimit;
-}
-
-SkScaledImageCache::~SkScaledImageCache() {
-    SkSafeUnref(fAllocator);
-
-    Rec* rec = fHead;
-    while (rec) {
-        Rec* next = rec->fNext;
-        SkDELETE(rec);
-        rec = next;
-    }
-    delete fHash;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-const SkScaledImageCache::Rec* SkScaledImageCache::findAndLock(const Key& key) {
-#ifdef USE_HASH
-    Rec* rec = fHash->find(key);
-#else
-    Rec* rec = find_rec_in_list(fHead, key);
-#endif
-    if (rec) {
-        this->moveToHead(rec);  // for our LRU
-        rec->fLockCount += 1;
-    }
-    return rec;
-}
-
-const SkScaledImageCache::Rec* SkScaledImageCache::addAndLock(Rec* rec) {
-    SkASSERT(rec);
-    // See if we already have this key (racy inserts, etc.)
-    const Rec* existing = this->findAndLock(rec->getKey());
-    if (NULL != existing) {
-        SkDELETE(rec);
-        return existing;
-    }
-
-    this->addToHead(rec);
-    SkASSERT(1 == rec->fLockCount);
-#ifdef USE_HASH
-    SkASSERT(fHash);
-    fHash->add(rec);
-#endif
-    // We may (now) be overbudget, so see if we need to purge something.
-    this->purgeAsNeeded();
-    return rec;
-}
-
-void SkScaledImageCache::add(Rec* rec) {
-    SkASSERT(rec);
-    // See if we already have this key (racy inserts, etc.)
-    const Rec* existing = this->findAndLock(rec->getKey());
-    if (NULL != existing) {
-        SkDELETE(rec);
-        this->unlock(existing);
-        return;
-    }
-    
-    this->addToHead(rec);
-    SkASSERT(1 == rec->fLockCount);
-#ifdef USE_HASH
-    SkASSERT(fHash);
-    fHash->add(rec);
-#endif
-    this->unlock(rec);
-}
-
-void SkScaledImageCache::unlock(SkScaledImageCache::ID id) {
-    SkASSERT(id);
-
-#ifdef SK_DEBUG
-    {
-        bool found = false;
-        Rec* rec = fHead;
-        while (rec != NULL) {
-            if (rec == id) {
-                found = true;
-                break;
-            }
-            rec = rec->fNext;
-        }
-        SkASSERT(found);
-    }
-#endif
-    const Rec* rec = id;
-    SkASSERT(rec->fLockCount > 0);
-    // We're under our lock, and we're the only possible mutator, so unconsting is fine.
-    const_cast<Rec*>(rec)->fLockCount -= 1;
-
-    // we may have been over-budget, but now have released something, so check
-    // if we should purge.
-    if (0 == rec->fLockCount) {
-        this->purgeAsNeeded();
-    }
-}
-
-void SkScaledImageCache::purgeAsNeeded() {
-    size_t byteLimit;
-    int    countLimit;
-
-    if (fDiscardableFactory) {
-        countLimit = SK_DISCARDABLEMEMORY_SCALEDIMAGECACHE_COUNT_LIMIT;
-        byteLimit = SK_MaxU32;  // no limit based on bytes
-    } else {
-        countLimit = SK_MaxS32; // no limit based on count
-        byteLimit = fTotalByteLimit;
-    }
-
-    size_t bytesUsed = fTotalBytesUsed;
-    int    countUsed = fCount;
-
-    Rec* rec = fTail;
-    while (rec) {
-        if (bytesUsed < byteLimit && countUsed < countLimit) {
-            break;
-        }
-
-        Rec* prev = rec->fPrev;
-        if (0 == rec->fLockCount) {
-            size_t used = rec->bytesUsed();
-            SkASSERT(used <= bytesUsed);
-            this->detach(rec);
-#ifdef USE_HASH
-            fHash->remove(rec->getKey());
-#endif
-
-            SkDELETE(rec);
-
-            bytesUsed -= used;
-            countUsed -= 1;
-        }
-        rec = prev;
-    }
-
-    fTotalBytesUsed = bytesUsed;
-    fCount = countUsed;
-}
-
-size_t SkScaledImageCache::setTotalByteLimit(size_t newLimit) {
-    size_t prevLimit = fTotalByteLimit;
-    fTotalByteLimit = newLimit;
-    if (newLimit < prevLimit) {
-        this->purgeAsNeeded();
-    }
-    return prevLimit;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-void SkScaledImageCache::detach(Rec* rec) {
-    Rec* prev = rec->fPrev;
-    Rec* next = rec->fNext;
-
-    if (!prev) {
-        SkASSERT(fHead == rec);
-        fHead = next;
-    } else {
-        prev->fNext = next;
-    }
-
-    if (!next) {
-        fTail = prev;
-    } else {
-        next->fPrev = prev;
-    }
-
-    rec->fNext = rec->fPrev = NULL;
-}
-
-void SkScaledImageCache::moveToHead(Rec* rec) {
-    if (fHead == rec) {
-        return;
-    }
-
-    SkASSERT(fHead);
-    SkASSERT(fTail);
-
-    this->validate();
-
-    this->detach(rec);
-
-    fHead->fPrev = rec;
-    rec->fNext = fHead;
-    fHead = rec;
-
-    this->validate();
-}
-
-void SkScaledImageCache::addToHead(Rec* rec) {
-    this->validate();
-
-    rec->fPrev = NULL;
-    rec->fNext = fHead;
-    if (fHead) {
-        fHead->fPrev = rec;
-    }
-    fHead = rec;
-    if (!fTail) {
-        fTail = rec;
-    }
-    fTotalBytesUsed += rec->bytesUsed();
-    fCount += 1;
-
-    this->validate();
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-#ifdef SK_DEBUG
-void SkScaledImageCache::validate() const {
-    if (NULL == fHead) {
-        SkASSERT(NULL == fTail);
-        SkASSERT(0 == fTotalBytesUsed);
-        return;
-    }
-
-    if (fHead == fTail) {
-        SkASSERT(NULL == fHead->fPrev);
-        SkASSERT(NULL == fHead->fNext);
-        SkASSERT(fHead->bytesUsed() == fTotalBytesUsed);
-        return;
-    }
-
-    SkASSERT(NULL == fHead->fPrev);
-    SkASSERT(NULL != fHead->fNext);
-    SkASSERT(NULL == fTail->fNext);
-    SkASSERT(NULL != fTail->fPrev);
-
-    size_t used = 0;
-    int count = 0;
-    const Rec* rec = fHead;
-    while (rec) {
-        count += 1;
-        used += rec->bytesUsed();
-        SkASSERT(used <= fTotalBytesUsed);
-        rec = rec->fNext;
-    }
-    SkASSERT(fCount == count);
-
-    rec = fTail;
-    while (rec) {
-        SkASSERT(count > 0);
-        count -= 1;
-        SkASSERT(used >= rec->bytesUsed());
-        used -= rec->bytesUsed();
-        rec = rec->fPrev;
-    }
-
-    SkASSERT(0 == count);
-    SkASSERT(0 == used);
-}
-#endif
-
-void SkScaledImageCache::dump() const {
-    this->validate();
-
-    const Rec* rec = fHead;
-    int locked = 0;
-    while (rec) {
-        locked += rec->fLockCount > 0;
-        rec = rec->fNext;
-    }
-
-    SkDebugf("SkScaledImageCache: count=%d bytes=%d locked=%d %s\n",
-             fCount, fTotalBytesUsed, locked,
-             fDiscardableFactory ? "discardable" : "malloc");
-}
-
-size_t SkScaledImageCache::setSingleAllocationByteLimit(size_t newLimit) {
-    size_t oldLimit = fSingleAllocationByteLimit;
-    fSingleAllocationByteLimit = newLimit;
-    return oldLimit;
-}
-
-size_t SkScaledImageCache::getSingleAllocationByteLimit() const {
-    return fSingleAllocationByteLimit;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-#include "SkThread.h"
-
-SK_DECLARE_STATIC_MUTEX(gMutex);
-static SkScaledImageCache* gScaledImageCache = NULL;
-static void cleanup_gScaledImageCache() {
-    // We'll clean this up in our own tests, but disable for clients.
-    // Chrome seems to have funky multi-process things going on in unit tests that
-    // makes this unsafe to delete when the main process atexit()s.
-    // SkLazyPtr does the same sort of thing.
-#if SK_DEVELOPER
-    SkDELETE(gScaledImageCache);
-#endif
-}
-
-/** Must hold gMutex when calling. */
-static SkScaledImageCache* get_cache() {
-    // gMutex is always held when this is called, so we don't need to be fancy in here.
-    gMutex.assertHeld();
-    if (NULL == gScaledImageCache) {
-#ifdef SK_USE_DISCARDABLE_SCALEDIMAGECACHE
-        gScaledImageCache = SkNEW_ARGS(SkScaledImageCache, (SkDiscardableMemory::Create));
-#else
-        gScaledImageCache = SkNEW_ARGS(SkScaledImageCache, (SK_DEFAULT_IMAGE_CACHE_LIMIT));
-#endif
-        atexit(cleanup_gScaledImageCache);
-    }
-    return gScaledImageCache;
-}
-
-void SkScaledImageCache::Unlock(SkScaledImageCache::ID id) {
-    SkAutoMutexAcquire am(gMutex);
-    get_cache()->unlock(id);
-
-//    get_cache()->dump();
-}
-
-size_t SkScaledImageCache::GetTotalBytesUsed() {
-    SkAutoMutexAcquire am(gMutex);
-    return get_cache()->getTotalBytesUsed();
-}
-
-size_t SkScaledImageCache::GetTotalByteLimit() {
-    SkAutoMutexAcquire am(gMutex);
-    return get_cache()->getTotalByteLimit();
-}
-
-size_t SkScaledImageCache::SetTotalByteLimit(size_t newLimit) {
-    SkAutoMutexAcquire am(gMutex);
-    return get_cache()->setTotalByteLimit(newLimit);
-}
-
-SkBitmap::Allocator* SkScaledImageCache::GetAllocator() {
-    SkAutoMutexAcquire am(gMutex);
-    return get_cache()->allocator();
-}
-
-void SkScaledImageCache::Dump() {
-    SkAutoMutexAcquire am(gMutex);
-    get_cache()->dump();
-}
-
-size_t SkScaledImageCache::SetSingleAllocationByteLimit(size_t size) {
-    SkAutoMutexAcquire am(gMutex);
-    return get_cache()->setSingleAllocationByteLimit(size);
-}
-
-size_t SkScaledImageCache::GetSingleAllocationByteLimit() {
-    SkAutoMutexAcquire am(gMutex);
-    return get_cache()->getSingleAllocationByteLimit();
-}
-
-const SkScaledImageCache::Rec* SkScaledImageCache::FindAndLock(const Key& key) {
-    SkAutoMutexAcquire am(gMutex);
-    return get_cache()->findAndLock(key);
-}
-
-const SkScaledImageCache::Rec* SkScaledImageCache::AddAndLock(Rec* rec) {
-    SkAutoMutexAcquire am(gMutex);
-    return get_cache()->addAndLock(rec);
-}
-
-void SkScaledImageCache::Add(Rec* rec) {
-    SkAutoMutexAcquire am(gMutex);
-    get_cache()->add(rec);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-#include "SkGraphics.h"
-
-size_t SkGraphics::GetImageCacheTotalBytesUsed() {
-    return SkScaledImageCache::GetTotalBytesUsed();
-}
-
-size_t SkGraphics::GetImageCacheTotalByteLimit() {
-    return SkScaledImageCache::GetTotalByteLimit();
-}
-
-size_t SkGraphics::SetImageCacheTotalByteLimit(size_t newLimit) {
-    return SkScaledImageCache::SetTotalByteLimit(newLimit);
-}
-
-size_t SkGraphics::GetImageCacheSingleAllocationByteLimit() {
-    return SkScaledImageCache::GetSingleAllocationByteLimit();
-}
-
-size_t SkGraphics::SetImageCacheSingleAllocationByteLimit(size_t newLimit) {
-    return SkScaledImageCache::SetSingleAllocationByteLimit(newLimit);
-}
-