Change EventTarget callback APIs for add/RemoveEventListenerInternal.

third_party/WebKit/Source/core/events/EventTarget.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  *           (C) 2007, 2008 Nikolas Zimmermann <zimmermann@kde.org>
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ skipping 142 matching lines @@
         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, options);
+    RegisteredEventListener registeredListener;
+    bool added = ensureEventTargetData().eventListenerMap.add(eventType, listener, options, &registeredListener);
+    if (added)
+        addedEventListener(eventType, registeredListener);
+    return added;
 }
 
-bool EventTarget::removeEventListener(const AtomicString& eventType, EventListener* listener, bool useCapture)
+void EventTarget::addedEventListener(const AtomicString& eventType, RegisteredEventListener& registeredListener)
+{
+}
+
+bool EventTarget::removeEventListener(const AtomicString& eventType, const EventListener* listener, bool useCapture)
 {
     EventListenerOptions options;
     setDefaultEventListenerOptionsLegacy(options, useCapture);
     return removeEventListenerInternal(eventType, listener, options);
 }
 
-bool EventTarget::removeEventListener(const AtomicString& eventType, EventListener* listener, const EventListenerOptionsOrBoolean& optionsUnion)
+bool EventTarget::removeEventListener(const AtomicString& eventType, const EventListener* listener, const EventListenerOptionsOrBoolean& optionsUnion)
 {
     if (optionsUnion.isBoolean())
         return removeEventListener(eventType, listener, optionsUnion.getAsBoolean());
     if (optionsUnion.isEventListenerOptions()) {
         EventListenerOptions options = optionsUnion.getAsEventListenerOptions();
         return removeEventListener(eventType, listener, options);
     }
     return removeEventListener(eventType, listener);
 }
 
-bool EventTarget::removeEventListener(const AtomicString& eventType, EventListener* listener, EventListenerOptions& options)
+bool EventTarget::removeEventListener(const AtomicString& eventType, const EventListener* listener, EventListenerOptions& options)
 {
     setDefaultEventListenerOptions(options);
     return removeEventListenerInternal(eventType, listener, options);
 }
 
-bool EventTarget::removeEventListenerInternal(const AtomicString& eventType, EventListener* listener, const EventListenerOptions& options)
+bool EventTarget::removeEventListenerInternal(const AtomicString& eventType, const EventListener* listener, const EventListenerOptions& options)
 {
     if (!listener)
         return false;
 
     EventTargetData* d = eventTargetData();
     if (!d)
         return false;
 
     size_t indexOfRemovedListener;
+    RegisteredEventListener registeredListener;
 
-    if (!d->eventListenerMap.remove(eventType, listener, options, indexOfRemovedListener))
+    if (!d->eventListenerMap.remove(eventType, listener, options, &indexOfRemovedListener, &registeredListener))
         return false;
 
     // Notify firing events planning to invoke the listener at 'index' that
     // they have one less listener to invoke.
-    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 (d->firingEventIterators) {
+        for (size_t i = 0; i < d->firingEventIterators->size(); ++i) {
+            FiringEventIterator& firingIterator = d->firingEventIterators->at(i);
+            if (eventType != firingIterator.eventType)
+                continue;
 
-        if (indexOfRemovedListener >= firingIterator.end)
-            continue;
+            if (indexOfRemovedListener >= firingIterator.end)
+                continue;
 
-        --firingIterator.end;
-        // Note that when firing an event listener,
-        // firingIterator.iterator indicates the next event listener
-        // that would fire, not the currently firing event
-        // listener. See EventTarget::fireEventListeners.
-        if (indexOfRemovedListener < firingIterator.iterator)
-            --firingIterator.iterator;
+            --firingIterator.end;
+            // Note that when firing an event listener,
+            // firingIterator.iterator indicates the next event listener
+            // that would fire, not the currently firing event
+            // listener. See EventTarget::fireEventListeners.
+            if (indexOfRemovedListener < firingIterator.iterator)
+                --firingIterator.iterator;
+        }
     }
+    removedEventListener(eventType, registeredListener);
+    return true;
+}
 
-    return true;
+void EventTarget::removedEventListener(const AtomicString& eventType, const RegisteredEventListener& registeredListener)
+{
 }
 
 bool EventTarget::setAttributeEventListener(const AtomicString& eventType, EventListener* listener)
 {
     clearAttributeEventListener(eventType);
     if (!listener)
         return false;
     return addEventListener(eventType, listener, false);
 }
 
 EventListener* EventTarget::getAttributeEventListener(const AtomicString& eventType)
 {
     EventListenerVector* listenerVector = getEventListeners(eventType);
     if (!listenerVector)
         return nullptr;
-    for (const auto& eventListener : *listenerVector) {
-        EventListener* listener = eventListener.listener.get();
+    for (auto& eventListener : *listenerVector) {
+        EventListener* listener = eventListener.listener();
         if (listener->isAttribute() && listener->belongsToTheCurrentWorld())
             return listener;
     }
     return nullptr;
 }
 
 bool EventTarget::clearAttributeEventListener(const AtomicString& eventType)
 {
     EventListener* listener = getAttributeEventListener(eventType);
     if (!listener)
@@ skipping 169 matching lines @@
         d->firingEventIterators = adoptPtr(new FiringEventIteratorVector);
     d->firingEventIterators->append(FiringEventIterator(event->type(), i, size));
     while (i < size) {
         RegisteredEventListener& registeredListener = entry[i];
 
         // Move the iterator past this event listener. This must match
         // the handling of the FiringEventIterator::iterator in
         // EventTarget::removeEventListener.
         ++i;
 
-        if (event->eventPhase() == Event::CAPTURING_PHASE && !registeredListener.useCapture)
+        if (event->eventPhase() == Event::CAPTURING_PHASE && !registeredListener.capture())
             continue;
-        if (event->eventPhase() == Event::BUBBLING_PHASE && registeredListener.useCapture)
+        if (event->eventPhase() == Event::BUBBLING_PHASE && registeredListener.capture())
             continue;
 
         // If stopImmediatePropagation has been called, we just break out immediately, without
         // handling any more events on this target.
         if (event->immediatePropagationStopped())
             break;
 
         ExecutionContext* context = getExecutionContext();
         if (!context)
             break;
 
-        event->setHandlingPassive(registeredListener.passive);
+        event->setHandlingPassive(registeredListener.passive());
 
         InspectorInstrumentation::NativeBreakpoint nativeBreakpoint(context, this, event);
 
         // 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);
+        registeredListener.listener()->handleEvent(context, event);
         event->setHandlingPassive(false);
 
         RELEASE_ASSERT(i <= size);
     }
     d->firingEventIterators->removeLast();
 }
 
 DispatchEventResult EventTarget::dispatchEventResult(const Event& event)
 {
     if (event.defaultPrevented())
@@ skipping 28 matching lines @@
     // they have one less listener to invoke.
     if (d->firingEventIterators) {
         for (size_t i = 0; i < d->firingEventIterators->size(); ++i) {
             d->firingEventIterators->at(i).iterator = 0;
             d->firingEventIterators->at(i).end = 0;
         }
     }
 }
 
 } // namespace blink