#include "config.h"
#include "EventTarget.h"
#include "EventException.h"
#include "InspectorInstrumentation.h"
#include "ScriptController.h"
#include "WebKitTransitionEvent.h"
#include <wtf/MainThread.h>
#include <wtf/Ref.h>
#include <wtf/StdLibExtras.h>
#include <wtf/Vector.h>
using namespace WTF;
namespace WebCore {
EventTargetData::EventTargetData()
{
}
EventTargetData::~EventTargetData()
{
}
EventTarget::~EventTarget()
{
}
Node* EventTarget::toNode()
{
return 0;
}
DOMWindow* EventTarget::toDOMWindow()
{
return 0;
}
bool EventTarget::isMessagePort() const
{
return false;
}
bool EventTarget::addEventListener(const AtomicString& eventType, PassRefPtr<EventListener> listener, bool useCapture)
{
return ensureEventTargetData().eventListenerMap.add(eventType, listener, useCapture);
}
bool EventTarget::removeEventListener(const AtomicString& eventType, EventListener* listener, bool useCapture)
{
EventTargetData* d = eventTargetData();
if (!d)
return false;
size_t indexOfRemovedListener;
if (!d->eventListenerMap.remove(eventType, listener, useCapture, indexOfRemovedListener))
return false;
if (!d->firingEventIterators)
return true;
for (size_t i = 0; i < d->firingEventIterators->size(); ++i) {
FiringEventIterator& firingIterator = d->firingEventIterators->at(i);
if (eventType != firingIterator.eventType)
continue;
if (indexOfRemovedListener >= firingIterator.size)
continue;
--firingIterator.size;
if (indexOfRemovedListener <= firingIterator.iterator)
--firingIterator.iterator;
}
return true;
}
bool EventTarget::setAttributeEventListener(const AtomicString& eventType, PassRefPtr<EventListener> listener)
{
clearAttributeEventListener(eventType);
if (!listener)
return false;
return addEventListener(eventType, listener, false);
}
EventListener* EventTarget::getAttributeEventListener(const AtomicString& eventType)
{
const EventListenerVector& entry = getEventListeners(eventType);
for (size_t i = 0; i < entry.size(); ++i) {
if (entry[i].listener->isAttribute())
return entry[i].listener.get();
}
return 0;
}
bool EventTarget::clearAttributeEventListener(const AtomicString& eventType)
{
EventListener* listener = getAttributeEventListener(eventType);
if (!listener)
return false;
return removeEventListener(eventType, listener, false);
}
bool EventTarget::dispatchEvent(PassRefPtr<Event> event, ExceptionCode& ec)
{
if (!event || event->type().isEmpty()) {
ec = EventException::UNSPECIFIED_EVENT_TYPE_ERR;
return false;
}
if (event->isBeingDispatched()) {
ec = EventException::DISPATCH_REQUEST_ERR;
return false;
}
if (!scriptExecutionContext())
return false;
return dispatchEvent(event);
}
bool EventTarget::dispatchEvent(PassRefPtr<Event> event)
{
event->setTarget(this);
event->setCurrentTarget(this);
event->setEventPhase(Event::AT_TARGET);
bool defaultPrevented = fireEventListeners(event.get());
event->setEventPhase(0);
return defaultPrevented;
}
void EventTarget::uncaughtExceptionInEventHandler()
{
}
static const AtomicString& legacyType(const Event* event)
{
if (event->type() == eventNames().transitionendEvent)
return eventNames().webkitTransitionEndEvent;
if (event->type() == eventNames().wheelEvent)
return eventNames().mousewheelEvent;
return emptyAtom;
}
bool EventTarget::fireEventListeners(Event* event)
{
ASSERT(!NoEventDispatchAssertion::isEventDispatchForbidden());
ASSERT(event && !event->type().isEmpty());
EventTargetData* d = eventTargetData();
if (!d)
return true;
EventListenerVector* legacyListenersVector = 0;
const AtomicString& legacyTypeName = legacyType(event);
if (!legacyTypeName.isEmpty())
legacyListenersVector = d->eventListenerMap.find(legacyTypeName);
EventListenerVector* listenersVector = d->eventListenerMap.find(event->type());
if (listenersVector)
fireEventListeners(event, d, *listenersVector);
else if (legacyListenersVector) {
AtomicString typeName = event->type();
event->setType(legacyTypeName);
fireEventListeners(event, d, *legacyListenersVector);
event->setType(typeName);
}
return !event->defaultPrevented();
}
void EventTarget::fireEventListeners(Event* event, EventTargetData* d, EventListenerVector& entry)
{
Ref<EventTarget> protect(*this);
bool userEventWasHandled = false;
size_t i = 0;
size_t size = entry.size();
if (!d->firingEventIterators)
d->firingEventIterators = std::make_unique<FiringEventIteratorVector>();
d->firingEventIterators->append(FiringEventIterator(event->type(), i, size));
ScriptExecutionContext* context = scriptExecutionContext();
Document* document = nullptr;
InspectorInstrumentationCookie willDispatchEventCookie;
if (context && context->isDocument()) {
document = toDocument(context);
willDispatchEventCookie = InspectorInstrumentation::willDispatchEvent(document, *event, size > 0);
}
for (; i < size; ++i) {
RegisteredEventListener& registeredListener = entry[i];
if (event->eventPhase() == Event::CAPTURING_PHASE && !registeredListener.useCapture)
continue;
if (event->eventPhase() == Event::BUBBLING_PHASE && registeredListener.useCapture)
continue;
if (event->immediatePropagationStopped())
break;
InspectorInstrumentationCookie cookie = InspectorInstrumentation::willHandleEvent(context, event);
registeredListener.listener->handleEvent(context, event);
if (!userEventWasHandled && ScriptController::processingUserGesture())
userEventWasHandled = true;
InspectorInstrumentation::didHandleEvent(cookie);
}
d->firingEventIterators->removeLast();
if (userEventWasHandled && document)
document->resetLastHandledUserGestureTimestamp();
if (document)
InspectorInstrumentation::didDispatchEvent(willDispatchEventCookie);
}
const EventListenerVector& EventTarget::getEventListeners(const AtomicString& eventType)
{
DEPRECATED_DEFINE_STATIC_LOCAL(EventListenerVector, emptyVector, ());
EventTargetData* d = eventTargetData();
if (!d)
return emptyVector;
EventListenerVector* listenerVector = d->eventListenerMap.find(eventType);
if (!listenerVector)
return emptyVector;
return *listenerVector;
}
void EventTarget::removeAllEventListeners()
{
EventTargetData* d = eventTargetData();
if (!d)
return;
d->eventListenerMap.clear();
if (d->firingEventIterators) {
for (size_t i = 0; i < d->firingEventIterators->size(); ++i) {
d->firingEventIterators->at(i).iterator = 0;
d->firingEventIterators->at(i).size = 0;
}
}
}
}