#ifndef V8DOMMap_h
#define V8DOMMap_h
#include <wtf/HashMap.h>
#include <wtf/OwnPtr.h>
#include <v8.h>
namespace WebCore {
class DOMDataStore;
class Node;
template <class KeyType, class ValueType> class AbstractWeakReferenceMap {
public:
AbstractWeakReferenceMap(v8::WeakReferenceCallback callback) : m_weakReferenceCallback(callback) { }
virtual ~AbstractWeakReferenceMap() { }
class Visitor {
public:
virtual void startMap() { }
virtual void endMap() { }
virtual void visitDOMWrapper(DOMDataStore* store, KeyType* key, v8::Persistent<ValueType> object) = 0;
protected:
virtual ~Visitor() { }
};
virtual v8::Persistent<ValueType> get(KeyType* obj) = 0;
virtual void set(KeyType* obj, v8::Persistent<ValueType> wrapper) = 0;
virtual bool contains(KeyType* obj) = 0;
virtual void visit(DOMDataStore* store, Visitor* visitor) = 0;
virtual bool removeIfPresent(KeyType*, v8::Persistent<ValueType>) = 0;
virtual void clear() = 0;
v8::WeakReferenceCallback weakReferenceCallback() { return m_weakReferenceCallback; }
private:
v8::WeakReferenceCallback m_weakReferenceCallback;
};
typedef AbstractWeakReferenceMap<Node, v8::Object> DOMNodeMapping;
template<class KeyType, class ValueType> class WeakReferenceMap : public AbstractWeakReferenceMap<KeyType, ValueType> {
public:
typedef AbstractWeakReferenceMap<KeyType, ValueType> Parent;
WeakReferenceMap(v8::WeakReferenceCallback callback) : Parent(callback) { }
virtual ~WeakReferenceMap() { }
virtual v8::Persistent<ValueType> get(KeyType* obj)
{
ValueType* wrapper = m_map.get(obj);
return wrapper ? v8::Persistent<ValueType>(wrapper) : v8::Persistent<ValueType>();
}
virtual void set(KeyType* obj, v8::Persistent<ValueType> wrapper)
{
ASSERT(!m_map.contains(obj));
wrapper.MakeWeak(obj, Parent::weakReferenceCallback());
m_map.set(obj, *wrapper);
}
virtual void forget(KeyType* obj)
{
ASSERT(obj);
ValueType* wrapper = m_map.take(obj);
if (!wrapper)
return;
v8::Persistent<ValueType> handle(wrapper);
handle.Dispose();
handle.Clear();
}
bool removeIfPresent(KeyType* key, v8::Persistent<ValueType> value)
{
typename HashMap<KeyType*, ValueType*>::iterator it = m_map.find(key);
if (it == m_map.end() || it->second != *value)
return false;
m_map.remove(it);
value.Dispose();
return true;
}
void clear()
{
m_map.clear();
}
bool contains(KeyType* obj) { return m_map.contains(obj); }
virtual void visit(DOMDataStore* store, typename Parent::Visitor* visitor)
{
visitor->startMap();
typename HashMap<KeyType*, ValueType*>::iterator it = m_map.begin();
for (; it != m_map.end(); ++it)
visitor->visitDOMWrapper(store, it->first, v8::Persistent<ValueType>(it->second));
visitor->endMap();
}
protected:
HashMap<KeyType*, ValueType*> m_map;
};
template <class KeyType> class DOMWrapperMap : public WeakReferenceMap<KeyType, v8::Object> {
public:
DOMWrapperMap(v8::WeakReferenceCallback callback) : WeakReferenceMap<KeyType, v8::Object>(callback) { }
};
class DOMDataStoreHandle {
public:
DOMDataStoreHandle();
~DOMDataStoreHandle();
DOMDataStore* getStore() const { return m_store.get(); }
private:
OwnPtr<DOMDataStore> m_store;
};
DOMNodeMapping& getDOMNodeMap(v8::Isolate* = 0);
DOMNodeMapping& getActiveDOMNodeMap(v8::Isolate* = 0);
void visitDOMNodes(DOMWrapperMap<Node>::Visitor*);
void visitActiveDOMNodes(DOMWrapperMap<Node>::Visitor*);
DOMWrapperMap<void>& getDOMObjectMap(v8::Isolate* = 0);
void visitDOMObjects(DOMWrapperMap<void>::Visitor*);
DOMWrapperMap<void>& getActiveDOMObjectMap(v8::Isolate* = 0);
void visitActiveDOMObjects(DOMWrapperMap<void>::Visitor*);
void removeAllDOMObjects();
void enableFasterDOMStoreAccess();
}
#endif // V8DOMMap_h