Remove external SkImageFilter cache, and rename UniqueIDCache -> Cache.

src/core/SkImageFilter.cpp

 /*
  * Copyright 2012 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkImageFilter.h"
 
 #include "SkBitmap.h"
@@ skipping 18 matching lines @@
     static int32_t gImageFilterUniqueID;
 
     // Never return 0.
     int32_t id;
     do {
         id = sk_atomic_inc(&gImageFilterUniqueID) + 1;
     } while (0 == id);
     return id;
 }
 
-struct SkImageFilter::UniqueIDCache::Key {
+struct SkImageFilter::Cache::Key {
     Key(const uint32_t uniqueID, const SkMatrix& matrix, const SkIRect& clipBounds, uint32_t srcGenID)
       : fUniqueID(uniqueID), fMatrix(matrix), fClipBounds(clipBounds), fSrcGenID(srcGenID) {
         // Assert that Key is tightly-packed, since it is hashed.
         SK_COMPILE_ASSERT(sizeof(Key) == sizeof(uint32_t) + sizeof(SkMatrix) + sizeof(SkIRect) +
                                          sizeof(uint32_t), image_filter_key_tight_packing);
         fMatrix.getType();  // force initialization of type, so hashes match
     }
     uint32_t fUniqueID;
     SkMatrix fMatrix;
     SkIRect fClipBounds;
@@ skipping 53 matching lines @@
     if (buffer.isVersionLT(SkReadBuffer::kImageFilterUniqueID_Version)) {
         fUniqueID = next_image_filter_unique_id();
     } else {
         fUniqueID = buffer.readUInt();
     }
     return buffer.isValid();
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-SkImageFilter::Cache* gExternalCache;
-
 SkImageFilter::SkImageFilter(int inputCount, SkImageFilter** inputs, const CropRect* cropRect)
   : fInputCount(inputCount),
     fInputs(new SkImageFilter*[inputCount]),
     fUsesSrcInput(false),
     fCropRect(cropRect ? *cropRect : CropRect(SkRect(), 0x0)),
     fUniqueID(next_image_filter_unique_id()) {
     for (int i = 0; i < inputCount; ++i) {
         if (NULL == inputs[i] || inputs[i]->usesSrcInput()) {
             fUsesSrcInput = true;
         }
@@ skipping 42 matching lines @@
     buffer.writeUInt(fCropRect.flags());
     buffer.writeUInt(fUniqueID);
 }
 
 bool SkImageFilter::filterImage(Proxy* proxy, const SkBitmap& src,
                                 const Context& context,
                                 SkBitmap* result, SkIPoint* offset) const {
     SkASSERT(result);
     SkASSERT(offset);
     uint32_t srcGenID = fUsesSrcInput ? src.getGenerationID() : 0;
-    Cache* externalCache = GetExternalCache();
-    UniqueIDCache::Key key(fUniqueID, context.ctm(), context.clipBounds(), srcGenID);
-    if (NULL != externalCache) {
-        if (externalCache->get(this, result, offset)) {
-            return true;
-        }
-    } else if (context.cache()) {
+    Cache::Key key(fUniqueID, context.ctm(), context.clipBounds(), srcGenID);
+    if (context.cache()) {
         if (context.cache()->get(key, result, offset)) {
             return true;
         }
     }
     /*
      *  Give the proxy first shot at the filter. If it returns false, ask
      *  the filter to do it.
      */
     if ((proxy && proxy->filterImage(this, src, context, result, offset)) ||
         this->onFilterImage(proxy, src, context, result, offset)) {
-        if (externalCache) {
-            externalCache->set(this, *result, *offset);
-        } else if (context.cache()) {
+        if (context.cache()) {
             context.cache()->set(key, *result, *offset);
         }
         return true;
     }
     return false;
 }
 
 bool SkImageFilter::filterBounds(const SkIRect& src, const SkMatrix& ctm,
                                  SkIRect* dst) const {
     SkASSERT(&src);
     SkASSERT(dst);
-    if (SkImageFilter::GetExternalCache()) {
-        /*
-         *  When the external cache is active, do not intersect the saveLayer
-         *  bounds with the clip bounds. This is so that the cached result
-         *  is always the full size of the primitive's bounds,
-         *  regardless of the clip active on first draw.
-         */
-        *dst = SkIRect::MakeLargest();
-        return true;
-    }
     return this->onFilterBounds(src, ctm, dst);
 }
 
 void SkImageFilter::computeFastBounds(const SkRect& src, SkRect* dst) const {
     if (0 == fInputCount) {
         *dst = src;
         return;
     }
     if (this->getInput(0)) {
         this->getInput(0)->computeFastBounds(src, dst);
@@ skipping 154 matching lines @@
 }
 
 bool SkImageFilter::asNewEffect(GrEffect**, GrTexture*, const SkMatrix&, const SkIRect&) const {
     return false;
 }
 
 bool SkImageFilter::asColorFilter(SkColorFilter**) const {
     return false;
 }
 
-void SkImageFilter::SetExternalCache(Cache* cache) {
-    SkRefCnt_SafeAssign(gExternalCache, cache);
-}
-
-SkImageFilter::Cache* SkImageFilter::GetExternalCache() {
-    return gExternalCache;
-}
-
 #if SK_SUPPORT_GPU
 
 void SkImageFilter::WrapTexture(GrTexture* texture, int width, int height, SkBitmap* result) {
     SkImageInfo info = SkImageInfo::MakeN32Premul(width, height);
     result->setInfo(info);
     result->setPixelRef(SkNEW_ARGS(SkGrPixelRef, (info, texture)))->unref();
 }
 
 bool SkImageFilter::getInputResultGPU(SkImageFilter::Proxy* proxy,
                                       const SkBitmap& src, const Context& ctx,
@@ skipping 17 matching lines @@
                 GrUnlockAndUnrefCachedBitmapTexture(resultTex);
             }
             return true;
         } else {
             return false;
         }
     }
 }
 #endif
 
+namespace {
+
 class CacheImpl : public SkImageFilter::Cache {
 public:
-    explicit CacheImpl(int minChildren) : fMinChildren(minChildren) {
-        SkASSERT(fMinChildren <= 2);
+    CacheImpl(size_t maxBytes) : fMaxBytes(maxBytes), fCurrentBytes(0) {
     }
-
-    virtual ~CacheImpl();
-    bool get(const SkImageFilter* key, SkBitmap* result, SkIPoint* offset) SK_OVERRIDE;
-    void set(const SkImageFilter* key, const SkBitmap& result, const SkIPoint& offset) SK_OVERRIDE;
-    void remove(const SkImageFilter* key) SK_OVERRIDE;
-private:
-    typedef const SkImageFilter* Key;
-    struct Value {
-        Value(Key key, const SkBitmap& bitmap, const SkIPoint& offset)
-            : fKey(key), fBitmap(bitmap), fOffset(offset) {}
-        Key fKey;
-        SkBitmap fBitmap;
-        SkIPoint fOffset;
-        static const Key& GetKey(const Value& v) {
-            return v.fKey;
-        }
-        static uint32_t Hash(Key key) {
-            return SkChecksum::Murmur3(reinterpret_cast<const uint32_t*>(&key), sizeof(Key));
-        }
-    };
-    SkTDynamicHash<Value, Key> fData;
-    int fMinChildren;
-};
-
-bool CacheImpl::get(const SkImageFilter* key, SkBitmap* result, SkIPoint* offset) {
-    Value* v = fData.find(key);
-    if (v) {
-        *result = v->fBitmap;
-        *offset = v->fOffset;
-        return true;
-    }
-    return false;
-}
-
-void CacheImpl::remove(const SkImageFilter* key) {
-    Value* v = fData.find(key);
-    if (v) {
-        fData.remove(key);
-        delete v;
-    }
-}
-
-void CacheImpl::set(const SkImageFilter* key, const SkBitmap& result, const SkIPoint& offset) {
-    if (fMinChildren < 2 || !key->unique()) {
-        // We take !key->unique() as a signal that there are probably at least 2 refs on the key,
-        // meaning this filter probably has at least two children and is worth caching when
-        // fMinChildren is 2.  If fMinChildren is less than two, we'll just always cache.
-        fData.add(new Value(key, result, offset));
-    }
-}
-
-SkImageFilter::Cache* SkImageFilter::Cache::Create(int minChildren) {
-    return new CacheImpl(minChildren);
-}
-
-CacheImpl::~CacheImpl() {
-    SkTDynamicHash<Value, Key>::Iter iter(&fData);
-
-    while (!iter.done()) {
-        Value* v = &*iter;
-        ++iter;
-        delete v;
-    }
-}
-
-namespace {
-
-class UniqueIDCacheImpl : public SkImageFilter::UniqueIDCache {
-public:
-    UniqueIDCacheImpl(size_t maxBytes) : fMaxBytes(maxBytes), fCurrentBytes(0) {
-    }
-    virtual ~UniqueIDCacheImpl() {
+    virtual ~CacheImpl() {
         SkTDynamicHash<Value, Key>::Iter iter(&fLookup);
 
         while (!iter.done()) {
             Value* v = &*iter;
             ++iter;
             delete v;
         }
     }
     struct Value {
         Value(const Key& key, const SkBitmap& bitmap, const SkIPoint& offset)
@@ skipping 48 matching lines @@
         delete v;
     }
 private:
     SkTDynamicHash<Value, Key>         fLookup;
     mutable SkTInternalLList<Value>    fLRU;
     size_t                             fMaxBytes;
     size_t                             fCurrentBytes;
     mutable SkMutex                    fMutex;
 };
 
-SkImageFilter::UniqueIDCache* CreateCache() {
-    return SkImageFilter::UniqueIDCache::Create(kDefaultCacheSize);
+SkImageFilter::Cache* CreateCache() {
+    return SkImageFilter::Cache::Create(kDefaultCacheSize);
 }
 
 } // namespace
 
-SkImageFilter::UniqueIDCache* SkImageFilter::UniqueIDCache::Create(size_t maxBytes) {
-    return SkNEW_ARGS(UniqueIDCacheImpl, (maxBytes));
+SkImageFilter::Cache* SkImageFilter::Cache::Create(size_t maxBytes) {
+    return SkNEW_ARGS(CacheImpl, (maxBytes));
 }
 
-SkImageFilter::UniqueIDCache* SkImageFilter::UniqueIDCache::Get() {
-    SK_DECLARE_STATIC_LAZY_PTR(SkImageFilter::UniqueIDCache, cache, CreateCache);
+SkImageFilter::Cache* SkImageFilter::Cache::Get() {
+    SK_DECLARE_STATIC_LAZY_PTR(SkImageFilter::Cache, cache, CreateCache);
     return cache.get();
 }