Index: src/core/SkScaledImageCache.h |
diff --git a/src/core/SkScaledImageCache.h b/src/core/SkScaledImageCache.h |
deleted file mode 100644 |
index c31f8ffed938843361304224999ffe9d4e3ffd50..0000000000000000000000000000000000000000 |
--- a/src/core/SkScaledImageCache.h |
+++ /dev/null |
@@ -1,204 +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. |
- */ |
- |
-#ifndef SkScaledImageCache_DEFINED |
-#define SkScaledImageCache_DEFINED |
- |
-#include "SkBitmap.h" |
- |
-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.). |
- */ |
-class SkScaledImageCache { |
-public: |
- struct Key { |
- // Call this to access your private contents. Must not use the address after calling init() |
- void* writableContents() { return this + 1; } |
- |
- // must call this after your private data has been written. |
- // length must be a multiple of 4 |
- void init(size_t length); |
- |
- // This is only valid after having called init(). |
- uint32_t hash() const { return fHash; } |
- |
- bool operator==(const Key& other) const { |
- const uint32_t* a = this->as32(); |
- const uint32_t* b = other.as32(); |
- for (int i = 0; i < fCount32; ++i) { |
- if (a[i] != b[i]) { |
- return false; |
- } |
- } |
- return true; |
- } |
- |
- private: |
- // store fCount32 first, so we don't consider it in operator< |
- int32_t fCount32; // 2 + user contents count32 |
- 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 SkScaledImageCache::Key Key; |
- |
- Rec() : fLockCount(1) {} |
- 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; |
- int32_t fPad; |
- |
- friend class SkScaledImageCache; |
- }; |
- |
- typedef const Rec* ID; |
- |
- /** |
- * 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*); |
- static void Add(Rec*); |
- static void Unlock(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 SkBitmap::Allocator* GetAllocator(); |
- |
- /** |
- * Call SkDebugf() with diagnostic information about the state of the cache |
- */ |
- static void Dump(); |
- |
- /////////////////////////////////////////////////////////////////////////// |
- |
- /** |
- * Construct the cache to call DiscardableFactory when it |
- * allocates memory for the pixels. In this mode, the cache has |
- * not explicit budget, and so methods like getTotalBytesUsed() |
- * and getTotalByteLimit() will return 0, and setTotalByteLimit |
- * will ignore its argument and return 0. |
- */ |
- SkScaledImageCache(DiscardableFactory); |
- |
- /** |
- * 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 SkScaledImageCache(size_t byteLimit); |
- ~SkScaledImageCache(); |
- |
- const Rec* findAndLock(const Key& key); |
- const Rec* addAndLock(Rec*); |
- void add(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); |
- size_t getSingleAllocationByteLimit() const; |
- /** |
- * Set the maximum number of bytes available to this cache. If the current |
- * cache exceeds this new value, it will be purged to try to fit within |
- * this new limit. |
- */ |
- size_t setTotalByteLimit(size_t newLimit); |
- |
- SkBitmap::Allocator* allocator() const { return fAllocator; }; |
- |
- /** |
- * Call SkDebugf() with diagnostic information about the state of the cache |
- */ |
- void dump() const; |
- |
-private: |
- Rec* fHead; |
- Rec* fTail; |
- |
- class Hash; |
- Hash* fHash; |
- |
- DiscardableFactory fDiscardableFactory; |
- // the allocator is NULL or one that matches discardables |
- SkBitmap::Allocator* fAllocator; |
- |
- size_t fTotalBytesUsed; |
- size_t fTotalByteLimit; |
- size_t fSingleAllocationByteLimit; |
- int fCount; |
- |
- void purgeRec(Rec*); |
- void purgeAsNeeded(); |
- |
- // linklist management |
- void moveToHead(Rec*); |
- void addToHead(Rec*); |
- void detach(Rec*); |
- |
- void init(); // called by constructors |
- |
-#ifdef SK_DEBUG |
- void validate() const; |
-#else |
- void validate() const {} |
-#endif |
-}; |
-#endif |