#define SkImageFilter_DEFINED
#include "../private/SkTemplates.h"
+#include "../private/SkMutex.h"
#include "SkFilterQuality.h"
#include "SkFlattenable.h"
#include "SkMatrix.h"
#include "SkRect.h"
#include "SkSurfaceProps.h"
+#include "SkTArray.h"
class GrFragmentProcessor;
class GrTexture;
virtual bool get(const Key& key, SkBitmap* result, SkIPoint* offset) const = 0;
virtual void set(const Key& key, const SkBitmap& result, const SkIPoint& offset) = 0;
virtual void purge() {}
- virtual void purgeByImageFilterId(uint32_t) {}
+ virtual void purgeByKeys(const Key[], int) {}
};
class Context {
bool fUsesSrcInput;
CropRect fCropRect;
uint32_t fUniqueID; // Globally unique
+ mutable SkTArray<Cache::Key> fCacheKeys;
+ mutable SkMutex fMutex;
};
/**
#include "SkDevice.h"
#include "SkLocalMatrixImageFilter.h"
#include "SkMatrixImageFilter.h"
-#include "SkMutex.h"
#include "SkOncePtr.h"
#include "SkReadBuffer.h"
#include "SkRect.h"
#include "SkTDynamicHash.h"
-#include "SkTHash.h"
#include "SkTInternalLList.h"
#include "SkValidationUtils.h"
#include "SkWriteBuffer.h"
SkSafeUnref(fInputs[i]);
}
delete[] fInputs;
- Cache::Get()->purgeByImageFilterId(fUniqueID);
+ Cache::Get()->purgeByKeys(fCacheKeys.begin(), fCacheKeys.count());
}
SkImageFilter::SkImageFilter(int inputCount, SkReadBuffer& buffer)
this->onFilterImage(proxy, src, context, result, offset)) {
if (context.cache()) {
context.cache()->set(key, *result, *offset);
+ SkAutoMutexAcquire mutex(fMutex);
+ fCacheKeys.push_back(key);
}
return true;
}
++iter;
delete v;
}
- fIdToKeys.foreach([](uint32_t, SkTArray<Key>** array) { delete *array; });
}
struct Value {
Value(const Key& key, const SkBitmap& bitmap, const SkIPoint& offset)
removeInternal(v);
}
Value* v = new Value(key, result, offset);
- if (SkTArray<Key>** array = fIdToKeys.find(key.fUniqueID)) {
- (*array)->push_back(key);
- } else {
- SkTArray<Key>* keyArray = new SkTArray<Key>();
- keyArray->push_back(key);
- fIdToKeys.set(key.fUniqueID, keyArray);
- }
fLookup.add(v);
fLRU.addToHead(v);
fCurrentBytes += result.getSize();
}
}
- void purgeByImageFilterId(uint32_t uniqueID) override {
+ void purgeByKeys(const Key keys[], int count) override {
SkAutoMutexAcquire mutex(fMutex);
- if (SkTArray<Key>** array = fIdToKeys.find(uniqueID)) {
- for (auto& key : **array) {
- if (Value* v = fLookup.find(key)) {
- this->removeInternal(v);
- }
+ for (int i = 0; i < count; i++) {
+ if (Value* v = fLookup.find(keys[i])) {
+ this->removeInternal(v);
}
- fIdToKeys.remove(uniqueID);
- delete *array; // This can be deleted outside the lock
}
}
}
private:
SkTDynamicHash<Value, Key> fLookup;
- SkTHashMap<uint32_t, SkTArray<Key>*> fIdToKeys;
mutable SkTInternalLList<Value> fLRU;
size_t fMaxBytes;
size_t fCurrentBytes;