EventListenerMap.cpp [plain text]
#include "config.h"
#include "EventListenerMap.h"
#include "Event.h"
#include "EventTarget.h"
#include <wtf/MainThread.h>
#include <wtf/NeverDestroyed.h>
#include <wtf/StdLibExtras.h>
#include <wtf/Vector.h>
using namespace WTF;
namespace WebCore {
#ifndef NDEBUG
void EventListenerMap::assertNoActiveIterators()
{
ASSERT(!m_activeIteratorCount);
}
#endif
EventListenerMap::EventListenerMap()
{
}
bool EventListenerMap::contains(const AtomicString& eventType) const
{
for (auto& entry : m_entries) {
if (entry.first == eventType)
return true;
}
return false;
}
bool EventListenerMap::containsCapturing(const AtomicString& eventType) const
{
for (auto& entry : m_entries) {
if (entry.first == eventType) {
for (auto& eventListener : *entry.second) {
if (eventListener.useCapture)
return true;
}
}
}
return false;
}
bool EventListenerMap::containsActive(const AtomicString& eventType) const
{
for (auto& entry : m_entries) {
if (entry.first == eventType) {
for (auto& eventListener : *entry.second) {
if (!eventListener.isPassive)
return true;
}
}
}
return false;
}
void EventListenerMap::clear()
{
assertNoActiveIterators();
m_entries.clear();
}
Vector<AtomicString> EventListenerMap::eventTypes() const
{
Vector<AtomicString> types;
types.reserveInitialCapacity(m_entries.size());
for (auto& entry : m_entries)
types.uncheckedAppend(entry.first);
return types;
}
static bool addListenerToVector(EventListenerVector* vector, Ref<EventListener>&& listener, const RegisteredEventListener::Options& options)
{
RegisteredEventListener registeredListener(WTFMove(listener), options);
if (vector->find(registeredListener) != notFound)
return false;
vector->append(registeredListener);
return true;
}
bool EventListenerMap::add(const AtomicString& eventType, Ref<EventListener>&& listener, const RegisteredEventListener::Options& options)
{
assertNoActiveIterators();
for (auto& entry : m_entries) {
if (entry.first == eventType)
return addListenerToVector(entry.second.get(), WTFMove(listener), options);
}
m_entries.append(std::make_pair(eventType, std::make_unique<EventListenerVector>()));
return addListenerToVector(m_entries.last().second.get(), WTFMove(listener), options);
}
static bool removeListenerFromVector(EventListenerVector* listenerVector, EventListener& listener, bool useCapture, size_t& indexOfRemovedListener)
{
RegisteredEventListener registeredListener(listener, useCapture);
indexOfRemovedListener = listenerVector->find(registeredListener);
if (indexOfRemovedListener == notFound)
return false;
listenerVector->remove(indexOfRemovedListener);
return true;
}
bool EventListenerMap::remove(const AtomicString& eventType, EventListener& listener, bool useCapture, size_t& indexOfRemovedListener)
{
assertNoActiveIterators();
for (unsigned i = 0; i < m_entries.size(); ++i) {
if (m_entries[i].first == eventType) {
bool wasRemoved = removeListenerFromVector(m_entries[i].second.get(), listener, useCapture, indexOfRemovedListener);
if (m_entries[i].second->isEmpty())
m_entries.remove(i);
return wasRemoved;
}
}
return false;
}
EventListenerVector* EventListenerMap::find(const AtomicString& eventType)
{
assertNoActiveIterators();
for (auto& entry : m_entries) {
if (entry.first == eventType)
return entry.second.get();
}
return nullptr;
}
static void removeFirstListenerCreatedFromMarkup(EventListenerVector& listenerVector)
{
bool foundListener = listenerVector.removeFirstMatching([] (const RegisteredEventListener& listener) {
return listener.listener->wasCreatedFromMarkup();
});
ASSERT_UNUSED(foundListener, foundListener);
}
void EventListenerMap::removeFirstEventListenerCreatedFromMarkup(const AtomicString& eventType)
{
assertNoActiveIterators();
for (unsigned i = 0; i < m_entries.size(); ++i) {
if (m_entries[i].first == eventType) {
removeFirstListenerCreatedFromMarkup(*m_entries[i].second);
if (m_entries[i].second->isEmpty())
m_entries.remove(i);
return;
}
}
}
static void copyListenersNotCreatedFromMarkupToTarget(const AtomicString& eventType, EventListenerVector* listenerVector, EventTarget* target)
{
for (auto& listener : *listenerVector) {
if (listener.listener->wasCreatedFromMarkup())
continue;
target->addEventListener(eventType, *listener.listener, listener.useCapture);
}
}
void EventListenerMap::copyEventListenersNotCreatedFromMarkupToTarget(EventTarget* target)
{
assertNoActiveIterators();
for (auto& entry : m_entries)
copyListenersNotCreatedFromMarkupToTarget(entry.first, entry.second.get(), target);
}
EventListenerIterator::EventListenerIterator(EventTarget* target)
{
ASSERT(target);
EventTargetData* data = target->eventTargetData();
if (!data)
return;
m_map = &data->eventListenerMap;
#ifndef NDEBUG
m_map->m_activeIteratorCount++;
#endif
}
#ifndef NDEBUG
EventListenerIterator::~EventListenerIterator()
{
if (m_map)
m_map->m_activeIteratorCount--;
}
#endif
EventListener* EventListenerIterator::nextListener()
{
if (!m_map)
return 0;
for (; m_entryIndex < m_map->m_entries.size(); ++m_entryIndex) {
EventListenerVector& listeners = *m_map->m_entries[m_entryIndex].second;
if (m_index < listeners.size())
return listeners[m_index++].listener.get();
m_index = 0;
}
return 0;
}
}