void EventListenerMap::copyEventListenersNotCreatedFromMarkupToTarget(EventTarget* target)
{
assertNoActiveIterators();
for (auto& entry : m_entries)
copyListenersNotCreatedFromMarkupToTarget(entry.first, *entry.second, target);
}
void EventListenerMap::copyEventListenersNotCreatedFromMarkupToTarget(EventTarget* target)
{
assertNoActiveIterators();
for (unsigned i = 0; i < m_entries.size(); ++i)
copyListenersNotCreatedFromMarkupToTarget(m_entries[i].first, m_entries[i].second.get(), target);
}
void EventListenerMap::clear()
{
auto locker = holdLock(m_lock);
assertNoActiveIterators();
m_entries.clear();
}
EventListenerVector* EventListenerMap::find(const AtomicString& eventType) const
{
assertNoActiveIterators();
for (auto& entry : m_entries) {
if (entry.first == eventType)
return entry.second.get();
}
return nullptr;
}
EventListenerVector* EventListenerMap::find(const AtomicString& eventType)
{
assertNoActiveIterators();
for (unsigned i = 0; i < m_entries.size(); ++i) {
if (m_entries[i].first == eventType)
return m_entries[i].second.get();
}
return nullptr;
}
void EventListenerMap::replace(const AtomicString& eventType, EventListener& oldListener, Ref<EventListener>&& newListener, const RegisteredEventListener::Options& options)
{
assertNoActiveIterators();
auto* listeners = find(eventType);
ASSERT(listeners);
size_t index = findListener(*listeners, oldListener, options.capture);
ASSERT(index != notFound);
auto& registeredListener = listeners->at(index);
registeredListener->markAsRemoved();
registeredListener = RegisteredEventListener::create(WTFMove(newListener), options);
}
bool EventListenerMap::add(const AtomicString& eventType, PassRefPtr<EventListener> listener, bool useCapture)
{
assertNoActiveIterators();
for (unsigned i = 0; i < m_entries.size(); ++i) {
if (m_entries[i].first == eventType)
return addListenerToVector(m_entries[i].second.get(), listener, useCapture);
}
m_entries.append(std::make_pair(eventType, std::make_unique<EventListenerVector>()));
return addListenerToVector(m_entries.last().second.get(), listener, useCapture);
}
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;
}
}
}
bool EventListenerMap::remove(const AtomicString& eventType, EventListener& listener, bool useCapture)
{
assertNoActiveIterators();
for (unsigned i = 0; i < m_entries.size(); ++i) {
if (m_entries[i].first == eventType) {
bool wasRemoved = removeListenerFromVector(*m_entries[i].second, listener, useCapture);
if (m_entries[i].second->isEmpty())
m_entries.remove(i);
return wasRemoved;
}
}
return false;
}
bool EventListenerMap::add(const AtomicString& eventType, Ref<EventListener>&& listener, const RegisteredEventListener::Options& options)
{
assertNoActiveIterators();
if (auto* listeners = find(eventType)) {
if (findListener(*listeners, listener, options.capture) != notFound)
return false; // Duplicate listener.
listeners->append(RegisteredEventListener::create(WTFMove(listener), options));
return true;
}
auto listeners = std::make_unique<EventListenerVector>();
listeners->uncheckedAppend(RegisteredEventListener::create(WTFMove(listener), options));
m_entries.append({ eventType, WTFMove(listeners) });
return true;
}
void EventListenerMap::clear()
{
assertNoActiveIterators();
m_entries.clear();
}
