Allow clients to specify an external SkImageFilter 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"
 #include "SkDevice.h"
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
 #include "SkRect.h"
 #include "SkTDynamicHash.h"
 #include "SkValidationUtils.h"
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
 #include "SkGrPixelRef.h"
 #include "SkGr.h"
 #endif
 
+SkImageFilter::Cache* gExternalCache;
+
 SkImageFilter::SkImageFilter(int inputCount, SkImageFilter** inputs, const CropRect* cropRect)
   : fInputCount(inputCount),
     fInputs(new SkImageFilter*[inputCount]),
     fCropRect(cropRect ? *cropRect : CropRect(SkRect(), 0x0)) {
     for (int i = 0; i < inputCount; ++i) {
         fInputs[i] = inputs[i];
         SkSafeRef(fInputs[i]);
     }
 }
 
@@ skipping 255 matching lines @@
 }
 
 bool SkImageFilter::asNewEffect(GrEffectRef**, 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->setConfig(info);
     result->setPixelRef(SkNEW_ARGS(SkGrPixelRef, (info, texture)))->unref();
 }
 
 bool SkImageFilter::getInputResultGPU(SkImageFilter::Proxy* proxy,
                                       const SkBitmap& src, const Context& ctx,
@@ skipping 48 matching lines @@
 
     return hash;
 }
 
 class CacheImpl : public SkImageFilter::Cache {
 public:
     explicit CacheImpl(int minChildren) : fMinChildren(minChildren) {}
     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 compute_hash(reinterpret_cast<const uint32_t*>(&key), sizeof(Key) / sizeof(uint32_t));
         }
     };
     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 (key->getRefCnt() >= fMinChildren) {
         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;
     }
 }