Reopened: Caching the result of readPixelsSupported

src/core/SkTHashCache.h

+/*
+ * Copyright 2014 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkTHASHCACHE_DEFINED
+#define SkTHASHCACHE_DEFINED
+
+#include "SkTypes.h"
+#include "SkTDArray.h"
+#include "SkTDynamicHash.h"
+
+template <typename T,
+          typename Key,
+          typename Traits = T,
+          int kGrowPercent = 75 >
+class SkTHashCache : public SkNoncopyable {
+public:
+
+    SkTHashCache() {
+        this->resetDict();
+    }
+
+    ~SkTHashCache() {
+        fValues.deleteAll();
+    }
+
+    bool has(const Key& key) const {
+        return NULL != this->find(key);
+    }
+
+    T* find(const Key& key) const {
+        return fDict->find(key);
+    }
+
+    // if element already in cache, return immediately the cached value
+    T& put(T* element) {
+        Key key = Traits::GetKey(*element);
+        if (T * val = this->find(key)) {
+            return *val;
+        }
+
+        T** elemptr = fValues.append();
+        *elemptr = element;
+
+        fDict->add(element);
+
+        return *element;
+    }
+
+    int size() const {
+        return fValues.count();
+    }
+
+    void clear() {
+        fValues.deleteAll();
+        fValues.reset();
+        this->resetDict();
+    }
+
+private:
+    typedef SkTDynamicHash<T, Key, Traits, kGrowPercent> DictType;
+
+    void resetDict() {
+        fDict.reset(SkNEW(DictType));
+    }
+
+    SkAutoTDelete<DictType> fDict;
+    SkTDArray<T*> fValues;

[Rémi Piotaix, 2014/07/07 18:10:17]

Note that the use of an Array here is necessary because there is no way to
iterate over the values in the DynamicHash (to be able to free all the pointers
memory).

Maybe add a way to iterate over the elements in addition to a 'clear' or 'reset'
method?

[mtklein, 2014/07/07 18:33:26]

Ah, interesting.  Going a step further, is the only reason we iterate over the
elements to delete them?  I don't mind exposing an iterator from SkTDynamicHash
(obviously as long as order doesn't matter), and I'd be even happier to restrict
this as much as possible, to say, a visitAll() method that calls a functor on
each  element in the hash in unspecified order.

If we add clear() and that visitAll(), no need for SkHashCache at all right?

+};
+
+#endif  /* SkHASHCACHE_DEFINED */
+