#include "config.h"
#include "core/events/EventTarget.h"
-#include "RuntimeEnabledFeatures.h"
-#include "bindings/v8/DOMWrapperWorld.h"
-#include "bindings/v8/ExceptionMessages.h"
-#include "bindings/v8/ExceptionState.h"
-#include "core/events/Event.h"
+#include "bindings/core/v8/ExceptionState.h"
+#include "bindings/core/v8/V8DOMActivityLogger.h"
#include "core/dom/ExceptionCode.h"
+#include "core/editing/Editor.h"
+#include "core/events/Event.h"
#include "core/inspector/InspectorInstrumentation.h"
-#include "core/frame/DOMWindow.h"
-#include "platform/UserGestureIndicator.h"
+#include "core/frame/LocalDOMWindow.h"
+#include "core/frame/UseCounter.h"
+#include "platform/EventDispatchForbiddenScope.h"
+#include "platform/RuntimeEnabledFeatures.h"
#include "wtf/StdLibExtras.h"
+#include "wtf/Threading.h"
#include "wtf/Vector.h"
using namespace WTF;
-namespace WebCore {
+namespace blink {
EventTargetData::EventTargetData()
{
{
}
+EventTarget::EventTarget()
+{
+}
+
EventTarget::~EventTarget()
{
}
return 0;
}
-DOMWindow* EventTarget::toDOMWindow()
+LocalDOMWindow* EventTarget::toDOMWindow()
{
return 0;
}
return 0;
}
-inline DOMWindow* EventTarget::executingWindow()
+inline LocalDOMWindow* EventTarget::executingWindow()
{
if (ExecutionContext* context = executionContext())
return context->executingWindow();
bool EventTarget::addEventListener(const AtomicString& eventType, PassRefPtr<EventListener> listener, bool useCapture)
{
+ // FIXME: listener null check should throw TypeError (and be done in
+ // generated bindings), but breaks legacy content. http://crbug.com/249598
+ if (!listener)
+ return false;
+
+ V8DOMActivityLogger* activityLogger = V8DOMActivityLogger::currentActivityLoggerIfIsolatedWorld();
+ if (activityLogger) {
+ Vector<String> argv;
+ argv.append(toNode() ? toNode()->nodeName() : interfaceName());
+ argv.append(eventType);
+ activityLogger->logEvent("blinkAddEventListener", argv.size(), argv.data());
+ }
+
return ensureEventTargetData().eventListenerMap.add(eventType, listener, useCapture);
}
-bool EventTarget::removeEventListener(const AtomicString& eventType, EventListener* listener, bool useCapture)
+bool EventTarget::removeEventListener(const AtomicString& eventType, PassRefPtr<EventListener> listener, bool useCapture)
{
+ // FIXME: listener null check should throw TypeError (and be done in
+ // generated bindings), but breaks legacy content. http://crbug.com/249598
+ if (!listener)
+ return false;
+
EventTargetData* d = eventTargetData();
if (!d)
return false;
size_t indexOfRemovedListener;
- if (!d->eventListenerMap.remove(eventType, listener, useCapture, indexOfRemovedListener))
+ if (!d->eventListenerMap.remove(eventType, listener.get(), useCapture, indexOfRemovedListener))
return false;
// Notify firing events planning to invoke the listener at 'index' that
return true;
}
-bool EventTarget::setAttributeEventListener(const AtomicString& eventType, PassRefPtr<EventListener> listener, DOMWrapperWorld* isolatedWorld)
+bool EventTarget::setAttributeEventListener(const AtomicString& eventType, PassRefPtr<EventListener> listener)
{
- clearAttributeEventListener(eventType, isolatedWorld);
+ clearAttributeEventListener(eventType);
if (!listener)
return false;
return addEventListener(eventType, listener, false);
}
-EventListener* EventTarget::getAttributeEventListener(const AtomicString& eventType, DOMWrapperWorld* isolatedWorld)
+EventListener* EventTarget::getAttributeEventListener(const AtomicString& eventType)
{
const EventListenerVector& entry = getEventListeners(eventType);
- for (size_t i = 0; i < entry.size(); ++i) {
- EventListener* listener = entry[i].listener.get();
- if (listener->isAttribute()) {
- DOMWrapperWorld* listenerWorld = listener->world();
- // Worker listener
- if (!listenerWorld) {
- ASSERT(!isolatedWorld);
- return listener;
- }
- if (listenerWorld->isMainWorld() && !isolatedWorld)
- return listener;
- if (listenerWorld == isolatedWorld)
- return listener;
- }
+ for (const auto& eventListener : entry) {
+ EventListener* listener = eventListener.listener.get();
+ if (listener->isAttribute() && listener->belongsToTheCurrentWorld())
+ return listener;
}
return 0;
}
-bool EventTarget::clearAttributeEventListener(const AtomicString& eventType, DOMWrapperWorld* isolatedWorld)
+bool EventTarget::clearAttributeEventListener(const AtomicString& eventType)
{
- EventListener* listener = getAttributeEventListener(eventType, isolatedWorld);
+ EventListener* listener = getAttributeEventListener(eventType);
if (!listener)
return false;
return removeEventListener(eventType, listener, false);
}
-bool EventTarget::dispatchEvent(PassRefPtr<Event> event, ExceptionState& es)
+bool EventTarget::dispatchEvent(PassRefPtrWillBeRawPtr<Event> event, ExceptionState& exceptionState)
{
if (!event) {
- es.throwDOMException(InvalidStateError, ExceptionMessages::failedToExecute("dispatchEvent", "EventTarget", "The event provided is null."));
+ exceptionState.throwDOMException(InvalidStateError, "The event provided is null.");
return false;
}
if (event->type().isEmpty()) {
- es.throwDOMException(InvalidStateError, ExceptionMessages::failedToExecute("dispatchEvent", "EventTarget", "The event provided is uninitialized."));
+ exceptionState.throwDOMException(InvalidStateError, "The event provided is uninitialized.");
return false;
}
if (event->isBeingDispatched()) {
- es.throwDOMException(InvalidStateError, ExceptionMessages::failedToExecute("dispatchEvent", "EventTarget", "The event is already being dispatched."));
+ exceptionState.throwDOMException(InvalidStateError, "The event is already being dispatched.");
return false;
}
return dispatchEvent(event);
}
-bool EventTarget::dispatchEvent(PassRefPtr<Event> event)
+bool EventTarget::dispatchEvent(PassRefPtrWillBeRawPtr<Event> event)
{
event->setTarget(this);
event->setCurrentTarget(this);
{
}
-static AtomicString legacyType(const Event* event)
+static const AtomicString& legacyType(const Event* event)
{
if (event->type() == EventTypeNames::transitionend)
return EventTypeNames::webkitTransitionEnd;
if (event->type() == EventTypeNames::wheel)
return EventTypeNames::mousewheel;
- return emptyString();
+ return emptyAtom;
}
void EventTarget::countLegacyEvents(const AtomicString& legacyTypeName, EventListenerVector* listenersVector, EventListenerVector* legacyListenersVector)
UseCounter::Feature unprefixedFeature;
UseCounter::Feature prefixedFeature;
UseCounter::Feature prefixedAndUnprefixedFeature;
- bool shouldCount = false;
-
if (legacyTypeName == EventTypeNames::webkitTransitionEnd) {
prefixedFeature = UseCounter::PrefixedTransitionEndEvent;
unprefixedFeature = UseCounter::UnprefixedTransitionEndEvent;
prefixedAndUnprefixedFeature = UseCounter::PrefixedAndUnprefixedTransitionEndEvent;
- shouldCount = true;
} else if (legacyTypeName == EventTypeNames::webkitAnimationEnd) {
prefixedFeature = UseCounter::PrefixedAnimationEndEvent;
unprefixedFeature = UseCounter::UnprefixedAnimationEndEvent;
prefixedAndUnprefixedFeature = UseCounter::PrefixedAndUnprefixedAnimationEndEvent;
- shouldCount = true;
} else if (legacyTypeName == EventTypeNames::webkitAnimationStart) {
prefixedFeature = UseCounter::PrefixedAnimationStartEvent;
unprefixedFeature = UseCounter::UnprefixedAnimationStartEvent;
prefixedAndUnprefixedFeature = UseCounter::PrefixedAndUnprefixedAnimationStartEvent;
- shouldCount = true;
} else if (legacyTypeName == EventTypeNames::webkitAnimationIteration) {
prefixedFeature = UseCounter::PrefixedAnimationIterationEvent;
unprefixedFeature = UseCounter::UnprefixedAnimationIterationEvent;
prefixedAndUnprefixedFeature = UseCounter::PrefixedAndUnprefixedAnimationIterationEvent;
- shouldCount = true;
+ } else {
+ return;
}
- if (shouldCount) {
- if (DOMWindow* executingWindow = this->executingWindow()) {
- if (legacyListenersVector) {
- if (listenersVector)
- UseCounter::count(executingWindow, prefixedAndUnprefixedFeature);
- else
- UseCounter::count(executingWindow, prefixedFeature);
- } else if (listenersVector) {
- UseCounter::count(executingWindow, unprefixedFeature);
- }
+ if (LocalDOMWindow* executingWindow = this->executingWindow()) {
+ if (legacyListenersVector) {
+ if (listenersVector)
+ UseCounter::count(executingWindow->document(), prefixedAndUnprefixedFeature);
+ else
+ UseCounter::count(executingWindow->document(), prefixedFeature);
+ } else if (listenersVector) {
+ UseCounter::count(executingWindow->document(), unprefixedFeature);
}
}
}
bool EventTarget::fireEventListeners(Event* event)
{
- ASSERT(!NoEventDispatchAssertion::isEventDispatchForbidden());
+ ASSERT(!EventDispatchForbiddenScope::isEventDispatchForbidden());
ASSERT(event && !event->type().isEmpty());
EventTargetData* d = eventTargetData();
EventListenerVector* listenersVector = d->eventListenerMap.find(event->type());
if (!RuntimeEnabledFeatures::cssAnimationUnprefixedEnabled() && (event->type() == EventTypeNames::animationiteration || event->type() == EventTypeNames::animationend
- || event->type() == EventTypeNames::animationstart))
+ || event->type() == EventTypeNames::animationstart)
+ // Some code out-there uses custom events to dispatch unprefixed animation events manually,
+ // we can safely remove all this block when cssAnimationUnprefixedEnabled is always on, this
+ // is really a special case. DO NOT ADD MORE EVENTS HERE.
+ && event->interfaceName() != EventNames::CustomEvent)
listenersVector = 0;
if (listenersVector) {
event->setType(unprefixedTypeName);
}
+ Editor::countEvent(executionContext(), event);
countLegacyEvents(legacyTypeName, listenersVector, legacyListenersVector);
return !event->defaultPrevented();
}
void EventTarget::fireEventListeners(Event* event, EventTargetData* d, EventListenerVector& entry)
{
- RefPtr<EventTarget> protect = this;
+ RefPtrWillBeRawPtr<EventTarget> protect(this);
// Fire all listeners registered for this event. Don't fire listeners removed
// during event dispatch. Also, don't fire event listeners added during event
// new event listeners.
if (event->type() == EventTypeNames::beforeunload) {
- if (DOMWindow* executingWindow = this->executingWindow()) {
+ if (LocalDOMWindow* executingWindow = this->executingWindow()) {
if (executingWindow->top())
- UseCounter::count(executingWindow, UseCounter::SubFrameBeforeUnloadFired);
+ UseCounter::count(executingWindow->document(), UseCounter::SubFrameBeforeUnloadFired);
+ UseCounter::count(executingWindow->document(), UseCounter::DocumentBeforeUnloadFired);
}
+ } else if (event->type() == EventTypeNames::unload) {
+ if (LocalDOMWindow* executingWindow = this->executingWindow())
+ UseCounter::count(executingWindow->document(), UseCounter::DocumentUnloadFired);
+ } else if (event->type() == EventTypeNames::DOMFocusIn || event->type() == EventTypeNames::DOMFocusOut) {
+ if (LocalDOMWindow* executingWindow = this->executingWindow())
+ UseCounter::count(executingWindow->document(), UseCounter::DOMFocusInOutEvent);
+ } else if (event->type() == EventTypeNames::focusin || event->type() == EventTypeNames::focusout) {
+ if (LocalDOMWindow* executingWindow = this->executingWindow())
+ UseCounter::count(executingWindow->document(), UseCounter::FocusInOutEvent);
}
- bool userEventWasHandled = false;
size_t i = 0;
size_t size = entry.size();
if (!d->firingEventIterators)
if (!context)
break;
- InspectorInstrumentationCookie cookie = InspectorInstrumentation::willHandleEvent(context, event);
+ InspectorInstrumentationCookie cookie = InspectorInstrumentation::willHandleEvent(this, event, registeredListener.listener.get(), registeredListener.useCapture);
// To match Mozilla, the AT_TARGET phase fires both capturing and bubbling
// event listeners, even though that violates some versions of the DOM spec.
registeredListener.listener->handleEvent(context, event);
- if (!userEventWasHandled && UserGestureIndicator::processingUserGesture())
- userEventWasHandled = true;
InspectorInstrumentation::didHandleEvent(cookie);
}
d->firingEventIterators->removeLast();
- if (userEventWasHandled) {
- if (ExecutionContext* context = executionContext())
- context->userEventWasHandled();
- }
}
const EventListenerVector& EventTarget::getEventListeners(const AtomicString& eventType)
{
- DEFINE_STATIC_LOCAL(EventListenerVector, emptyVector, ());
+ AtomicallyInitializedStatic(EventListenerVector*, emptyVector = new EventListenerVector);
EventTargetData* d = eventTargetData();
if (!d)
- return emptyVector;
+ return *emptyVector;
EventListenerVector* listenerVector = d->eventListenerMap.find(eventType);
if (!listenerVector)
- return emptyVector;
+ return *emptyVector;
return *listenerVector;
}
+Vector<AtomicString> EventTarget::eventTypes()
+{
+ EventTargetData* d = eventTargetData();
+ return d ? d->eventListenerMap.eventTypes() : Vector<AtomicString>();
+}
+
void EventTarget::removeAllEventListeners()
{
EventTargetData* d = eventTargetData();
}
}
-} // namespace WebCore
+} // namespace blink
projects / platform / framework / web / crosswalk.git / blobdiff