Changeset 201734 in webkit


Ignore:
Timestamp:
Jun 6, 2016 5:36:45 PM (8 years ago)
Author:
Ryan Haddad
Message:

Unreviewed, rolling out r201730.
​https://bugs.webkit.org/show_bug.cgi?id=158453

This change caused existing LayoutTests to crash (Requested by
ryanhaddad on #webkit).

Reverted changeset:

"Implement EventListenerOptions argument to addEventListener"
​https://bugs.webkit.org/show_bug.cgi?id=149466
​http://trac.webkit.org/changeset/201730

Patch by Commit Queue <​commit-queue@webkit.org> on 2016-06-06

Location:
trunk
Files:
11 deleted
25 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r201731 r201734  
     12016-06-06  Commit Queue  <commit-queue@webkit.org>
     2
     3        Unreviewed, rolling out r201730.
     4        https://bugs.webkit.org/show_bug.cgi?id=158453
     5
     6        This change caused existing LayoutTests to crash (Requested by
     7        ryanhaddad on #webkit).
     8
     9        Reverted changeset:
     10
     11        "Implement EventListenerOptions argument to addEventListener"
     12        https://bugs.webkit.org/show_bug.cgi?id=149466
     13        http://trac.webkit.org/changeset/201730
     14
    1152016-06-02  Ryan Haddad  <ryanhaddad@apple.com>
    216

  • trunk/LayoutTests/imported/w3c/ChangeLog

    r201730 r201734  
     12016-06-06  Commit Queue  <commit-queue@webkit.org>
     2
     3        Unreviewed, rolling out r201730.
     4        https://bugs.webkit.org/show_bug.cgi?id=158453
     5
     6        This change caused existing LayoutTests to crash (Requested by
     7        ryanhaddad on #webkit).
     8
     9        Reverted changeset:
     10
     11        "Implement EventListenerOptions argument to addEventListener"
     12        https://bugs.webkit.org/show_bug.cgi?id=149466
     13        http://trac.webkit.org/changeset/201730
     14
    1152016-06-06  Chris Dumez  <cdumez@apple.com>
    216

  • trunk/Source/WebCore/ChangeLog

    r201730 r201734  
     12016-06-06  Commit Queue  <commit-queue@webkit.org>
     2
     3        Unreviewed, rolling out r201730.
     4        https://bugs.webkit.org/show_bug.cgi?id=158453
     5
     6        This change caused existing LayoutTests to crash (Requested by
     7        ryanhaddad on #webkit).
     8
     9        Reverted changeset:
     10
     11        "Implement EventListenerOptions argument to addEventListener"
     12        https://bugs.webkit.org/show_bug.cgi?id=149466
     13        http://trac.webkit.org/changeset/201730
     14
    1152016-06-06  Chris Dumez  <cdumez@apple.com>
    216

  • trunk/Source/WebCore/Modules/webaudio/AudioScheduledSourceNode.cpp

    r201730 r201734  
    202202}
    203203
    204 bool AudioScheduledSourceNode::addEventListener(const AtomicString& eventType, Ref<EventListener>&& listener, const AddEventListenerOptions& options)
    205 {
    206     bool success = AudioNode::addEventListener(eventType, WTFMove(listener), options);
     204bool AudioScheduledSourceNode::addEventListener(const AtomicString& eventType, Ref<EventListener>&& listener, bool useCapture)
     205{
     206    bool success = AudioNode::addEventListener(eventType, WTFMove(listener), useCapture);
    207207    if (success && eventType == eventNames().endedEvent)
    208208        m_hasEndedListener = hasEventListeners(eventNames().endedEvent);
    … …  
    210210}
    211211
    212 bool AudioScheduledSourceNode::removeEventListener(const AtomicString& eventType, EventListener& listener, const ListenerOptions& options)
    213 {
    214     bool success = AudioNode::removeEventListener(eventType, listener, options);
     212bool AudioScheduledSourceNode::removeEventListener(const AtomicString& eventType, EventListener& listener, bool useCapture)
     213{
     214    bool success = AudioNode::removeEventListener(eventType, listener, useCapture);
    215215    if (success && eventType == eventNames().endedEvent)
    216216        m_hasEndedListener = hasEventListeners(eventNames().endedEvent);

  • trunk/Source/WebCore/Modules/webaudio/AudioScheduledSourceNode.h

    r201730 r201734  
    102102
    103103private:
    104     bool addEventListener(const AtomicString& eventType, Ref<EventListener>&&, const AddEventListenerOptions&) override;
    105     bool removeEventListener(const AtomicString& eventType, EventListener&, const ListenerOptions&) override;
     104    bool addEventListener(const AtomicString& eventType, Ref<EventListener>&&, bool useCapture) override;
     105    bool removeEventListener(const AtomicString& eventType, EventListener&, bool useCapture) override;
    106106    void removeAllEventListeners() override;
    107107};

  • trunk/Source/WebCore/Modules/webaudio/ScriptProcessorNode.cpp

    r201730 r201734  
    274274}
    275275
    276 bool ScriptProcessorNode::addEventListener(const AtomicString& eventType, Ref<EventListener>&& listener, const AddEventListenerOptions& options)
    277 {
    278     bool success = AudioNode::addEventListener(eventType, WTFMove(listener), options);
     276bool ScriptProcessorNode::addEventListener(const AtomicString& eventType, Ref<EventListener>&& listener, bool useCapture)
     277{
     278    bool success = AudioNode::addEventListener(eventType, WTFMove(listener), useCapture);
    279279    if (success && eventType == eventNames().audioprocessEvent)
    280280        m_hasAudioProcessListener = hasEventListeners(eventNames().audioprocessEvent);
    … …  
    282282}
    283283
    284 bool ScriptProcessorNode::removeEventListener(const AtomicString& eventType, EventListener& listener, const ListenerOptions& options)
    285 {
    286     bool success = AudioNode::removeEventListener(eventType, listener, options);
     284bool ScriptProcessorNode::removeEventListener(const AtomicString& eventType, EventListener& listener, bool useCapture)
     285{
     286    bool success = AudioNode::removeEventListener(eventType, listener, useCapture);
    287287    if (success && eventType == eventNames().audioprocessEvent)
    288288        m_hasAudioProcessListener = hasEventListeners(eventNames().audioprocessEvent);

  • trunk/Source/WebCore/Modules/webaudio/ScriptProcessorNode.h

    r201730 r201734  
    7474    void fireProcessEvent();
    7575
    76     bool addEventListener(const AtomicString& eventType, Ref<EventListener>&&, const AddEventListenerOptions&) override;
    77     bool removeEventListener(const AtomicString& eventType, EventListener&, const ListenerOptions&) override;
     76    bool addEventListener(const AtomicString& eventType, Ref<EventListener>&&, bool useCapture) override;
     77    bool removeEventListener(const AtomicString& eventType, EventListener&, bool useCapture) override;
    7878    void removeAllEventListeners() override;
    7979

  • trunk/Source/WebCore/bindings/scripts/CodeGeneratorJS.pm

    r201730 r201734  
    16791679            }
    16801680            $usedArguments{$parameterIndex} = 1;
    1681         } elsif ($codeGenerator->IsDictionaryType($parameter->type)) {
    1682             push(@andExpression, "(${value}.isUndefinedOrNull() || ${value}.isObject())");
    1683             $usedArguments{$parameterIndex} = 1;
    1684         } elsif (($codeGenerator->GetArrayOrSequenceType($type) || $codeGenerator->IsTypedArrayType($type) || $codeGenerator->IsWrapperType($type)) && $type ne "EventListener") {
     1681        } elsif ($codeGenerator->GetArrayOrSequenceType($type) || $codeGenerator->IsTypedArrayType($type) || $codeGenerator->IsWrapperType($type)) {
    16851682            my $condition = "";
    16861683

  • trunk/Source/WebCore/dom/Event.h

    r201730 r201734  
    173173    void preventDefault()
    174174    {
    175         if (m_cancelable && !m_isExecutingPassiveEventListener)
     175        if (m_cancelable)
    176176            m_defaultPrevented = true;
    177177    }
    … …  
    180180    bool defaultHandled() const { return m_defaultHandled; }
    181181    void setDefaultHandled() { m_defaultHandled = true; }
    182 
    183     void setInPassiveListener(bool value) { m_isExecutingPassiveEventListener = value; }
    184182
    185183    bool cancelBubble() const { return m_cancelBubble; }
    … …  
    220218    bool m_cancelBubble { false };
    221219    bool m_isTrusted { false };
    222     bool m_isExecutingPassiveEventListener { false };
    223220
    224221    unsigned short m_eventPhase { 0 };

  • trunk/Source/WebCore/dom/EventListenerMap.cpp

    r201730 r201734  
    9696}
    9797
    98 static bool addListenerToVector(EventListenerVector* vector, Ref<EventListener>&& listener, const RegisteredEventListener::Options& options)
    99 {
    100     RegisteredEventListener registeredListener(WTFMove(listener), options);
     98static bool addListenerToVector(EventListenerVector* vector, Ref<EventListener>&& listener, bool useCapture)
     99{
     100    RegisteredEventListener registeredListener(WTFMove(listener), useCapture);
    101101
    102102    if (vector->find(registeredListener) != notFound)
    … …  
    107107}
    108108
    109 bool EventListenerMap::add(const AtomicString& eventType, Ref<EventListener>&& listener, const RegisteredEventListener::Options& options)
     109bool EventListenerMap::add(const AtomicString& eventType, Ref<EventListener>&& listener, bool useCapture)
    110110{
    111111    assertNoActiveIterators();
    … …  
    113113    for (auto& entry : m_entries) {
    114114        if (entry.first == eventType)
    115             return addListenerToVector(entry.second.get(), WTFMove(listener), options);
     115            return addListenerToVector(entry.second.get(), WTFMove(listener), useCapture);
    116116    }
    117117
    118118    m_entries.append(std::make_pair(eventType, std::make_unique<EventListenerVector>()));
    119     return addListenerToVector(m_entries.last().second.get(), WTFMove(listener), options);
     119    return addListenerToVector(m_entries.last().second.get(), WTFMove(listener), useCapture);
    120120}
    121121

  • trunk/Source/WebCore/dom/EventListenerMap.h

    r201730 r201734  
    5555
    5656    void clear();
    57 
    58     bool add(const AtomicString& eventType, Ref<EventListener>&&, const RegisteredEventListener::Options&);
     57    bool add(const AtomicString& eventType, Ref<EventListener>&&, bool useCapture);
    5958    bool remove(const AtomicString& eventType, EventListener&, bool useCapture, size_t& indexOfRemovedListener);
    6059    EventListenerVector* find(const AtomicString& eventType);

  • trunk/Source/WebCore/dom/EventTarget.cpp

    r201730 r201734  
    7676}
    7777
    78 bool EventTarget::addEventListener(const AtomicString& eventType, Ref<EventListener>&& listener, const AddEventListenerOptions& options)
    79 {
    80     return ensureEventTargetData().eventListenerMap.add(eventType, WTFMove(listener), { options.capture, options.passive, options.once });
    81 }
    82 
    83 void EventTarget::addEventListenerForBindings(const AtomicString& eventType, RefPtr<EventListener>&& listener, const AddEventListenerOptions& options)
    84 {
     78bool EventTarget::addEventListener(const AtomicString& eventType, Ref<EventListener>&& listener, bool useCapture)
     79{
     80    return ensureEventTargetData().eventListenerMap.add(eventType, WTFMove(listener), useCapture);
     81}
     82
     83void EventTarget::addEventListenerForBindings(const AtomicString& eventType, RefPtr<EventListener>&& listener, bool useCapture)
     84{
     85    // FIXME: listener is not supposed to be nullable.
    8586    if (!listener)
    8687        return;
    87     addEventListener(eventType, listener.releaseNonNull(), options);
    88 }
    89 
    90 void EventTarget::removeEventListenerForBindings(const AtomicString& eventType, RefPtr<EventListener>&& listener, const ListenerOptions& options)
    91 {
     88    addEventListener(eventType, listener.releaseNonNull(), useCapture);
     89}
     90
     91void EventTarget::removeEventListenerForBindings(const AtomicString& eventType, RefPtr<EventListener>&& listener, bool useCapture)
     92{
     93    // FIXME: listener is not supposed to be nullable.
    9294    if (!listener)
    9395        return;
    94     removeEventListener(eventType, *listener, options);
    95 }
    96 
    97 bool EventTarget::removeEventListener(const AtomicString& eventType, EventListener& listener, const ListenerOptions& options)
     96    removeEventListener(eventType, *listener, useCapture);
     97}
     98
     99bool EventTarget::removeEventListener(const AtomicString& eventType, EventListener& listener, bool useCapture)
    98100{
    99101    EventTargetData* d = eventTargetData();
    … …  
    103105    size_t indexOfRemovedListener;
    104106
    105     if (!d->eventListenerMap.remove(eventType, listener, options.capture, indexOfRemovedListener))
     107    if (!d->eventListenerMap.remove(eventType, listener, useCapture, indexOfRemovedListener))
    106108        return false;
    107109
    … …  
    130132    if (!listener)
    131133        return false;
    132     return addEventListener(eventType, listener.releaseNonNull());
     134    return addEventListener(eventType, listener.releaseNonNull(), false);
    133135}
    134136
    … …  
    259261    for (; i < size; ++i) {
    260262        RegisteredEventListener& registeredListener = entry[i];
    261 
    262         if (registeredListener.isMarkedForRemoval)
    263             continue;
    264 
    265263        if (event.eventPhase() == Event::CAPTURING_PHASE && !registeredListener.useCapture)
    266264            continue;
    … …  
    272270        if (event.immediatePropagationStopped())
    273271            break;
    274 
    275         if (registeredListener.isPassive)
    276             event.setInPassiveListener(true);
    277 
    278         // Mark listener for removal before executing the listener, in case the listener tries to
    279         // dispatch an event that would cause it to get executed again.
    280         if (registeredListener.isOnce)
    281             registeredListener.isMarkedForRemoval = true;
    282272
    283273        InspectorInstrumentationCookie cookie = InspectorInstrumentation::willHandleEvent(context, event);
    … …  
    286276        registeredListener.listener->handleEvent(context, &event);
    287277        InspectorInstrumentation::didHandleEvent(cookie);
    288 
    289         if (registeredListener.isPassive)
    290             event.setInPassiveListener(false);
    291 
    292         if (registeredListener.isOnce)
    293             removeEventListener(event.type(), *registeredListener.listener, ListenerOptions(registeredListener.useCapture));
    294     }
    295 
     278    }
    296279    d->firingEventIterators->removeLast();
    297280

  • trunk/Source/WebCore/dom/EventTarget.h

    r201730 r201734  
    122122    virtual bool isMessagePort() const;
    123123
    124     struct ListenerOptions {
    125         ListenerOptions(bool capture = false)
    126             : capture(capture)
    127         { }
    128 
    129         bool capture;
    130     };
    131 
    132     struct AddEventListenerOptions : public ListenerOptions {
    133         AddEventListenerOptions(bool capture = false, bool passive = false, bool once = false)
    134             : ListenerOptions(capture)
    135             , passive(passive)
    136             , once(once)
    137         { }
    138 
    139         bool passive;
    140         bool once;
    141     };
    142 
    143124    void addEventListenerForBindings(const AtomicString& eventType, RefPtr<EventListener>&&, bool useCapture);
    144125    void removeEventListenerForBindings(const AtomicString& eventType, RefPtr<EventListener>&&, bool useCapture);
    145     void addEventListenerForBindings(const AtomicString& eventType, RefPtr<EventListener>&&, const AddEventListenerOptions&);
    146     void removeEventListenerForBindings(const AtomicString& eventType, RefPtr<EventListener>&&, const ListenerOptions&);
    147     virtual bool addEventListener(const AtomicString& eventType, Ref<EventListener>&&, const AddEventListenerOptions& = { });
    148     virtual bool removeEventListener(const AtomicString& eventType, EventListener&, const ListenerOptions&);
     126    virtual bool addEventListener(const AtomicString& eventType, Ref<EventListener>&&, bool useCapture);
     127    virtual bool removeEventListener(const AtomicString& eventType, EventListener&, bool useCapture);
    149128
    150129    virtual void removeAllEventListeners();
    … …  
    231210}
    232211
    233 inline void EventTarget::addEventListenerForBindings(const AtomicString& eventType, RefPtr<EventListener>&& listener, bool useCapture)
    234 {
    235     addEventListenerForBindings(eventType, WTFMove(listener), AddEventListenerOptions(useCapture));
    236 }
    237 
    238 inline void EventTarget::removeEventListenerForBindings(const AtomicString& eventType, RefPtr<EventListener>&& listener, bool useCapture)
    239 {
    240     removeEventListenerForBindings(eventType, WTFMove(listener), ListenerOptions(useCapture));
    241 }
    242 
    243212} // namespace WebCore
    244213

  • trunk/Source/WebCore/dom/EventTarget.idl

    r201730 r201734  
    2626    ObjCProtocol,
    2727] interface EventTarget {
    28 #if defined(LANGUAGE_JAVASCRIPT) && LANGUAGE_JAVASCRIPT
    29     [ImplementedAs=addEventListenerForBindings] void addEventListener([AtomicString] DOMString type, EventListener? listener, optional AddEventListenerOptions options);
    30     [ImplementedAs=removeEventListenerForBindings] void removeEventListener([AtomicString] DOMString type, EventListener? listener, optional EventListenerOptions options);
    31 #endif
    32 
    3328    // FIXME: The 'type' and 'listener' parameters should not be optional.
    3429    [ObjCLegacyUnnamedParameters, ImplementedAs=addEventListenerForBindings] void addEventListener([AtomicString] optional DOMString type = "undefined", optional EventListener? listener, optional boolean useCapture = false);
    … …  
    3833    [ImplementedAs=dispatchEventForBindings, RaisesException] boolean dispatchEvent(Event? event);
    3934};
    40 
    41 dictionary EventListenerOptions {
    42     boolean capture = false;
    43 };
    44 
    45 dictionary AddEventListenerOptions {
    46     boolean capture = false;
    47     boolean passive = false;
    48     boolean once = false;
    49 };

  • trunk/Source/WebCore/dom/MessagePort.cpp

    r201730 r201734  
    222222}
    223223
    224 bool MessagePort::addEventListener(const AtomicString& eventType, Ref<EventListener>&& listener, const AddEventListenerOptions& options)
     224bool MessagePort::addEventListener(const AtomicString& eventType, Ref<EventListener>&& listener, bool useCapture)
    225225{
    226226    if (listener->isAttribute() && eventType == eventNames().messageEvent)
    227227        start();
    228     return EventTargetWithInlineData::addEventListener(eventType, WTFMove(listener), options);
     228    return EventTargetWithInlineData::addEventListener(eventType, WTFMove(listener), useCapture);
    229229}
    230230

  • trunk/Source/WebCore/dom/MessagePort.h

    r201730 r201734  
    9393        bool isNeutered() { return !m_entangledChannel; }
    9494
    95         bool addEventListener(const AtomicString& eventType, Ref<EventListener>&&, const AddEventListenerOptions&) override;
     95        bool addEventListener(const AtomicString& eventType, Ref<EventListener>&&, bool useCapture) override;
    9696
    9797    private:

  • trunk/Source/WebCore/dom/Node.cpp

    r201730 r201734  
    19081908}
    19091909
    1910 static inline bool tryAddEventListener(Node* targetNode, const AtomicString& eventType, Ref<EventListener>&& listener, const EventTarget::AddEventListenerOptions& options)
    1911 {
    1912     if (!targetNode->EventTarget::addEventListener(eventType, listener.copyRef(), options))
     1910static inline bool tryAddEventListener(Node* targetNode, const AtomicString& eventType, Ref<EventListener>&& listener, bool useCapture)
     1911{
     1912    if (!targetNode->EventTarget::addEventListener(eventType, listener.copyRef(), useCapture))
    19131913        return false;
    19141914
    … …  
    19281928    // Forward this call to addEventListener() to the window since these are window-only events.
    19291929    if (eventType == eventNames().orientationchangeEvent || eventType == eventNames().resizeEvent)
    1930         targetNode->document().domWindow()->addEventListener(eventType, WTFMove(listener), options);
     1930        targetNode->document().domWindow()->addEventListener(eventType, WTFMove(listener), useCapture);
    19311931
    19321932#if ENABLE(TOUCH_EVENTS)
    … …  
    19441944}
    19451945
    1946 bool Node::addEventListener(const AtomicString& eventType, Ref<EventListener>&& listener, const AddEventListenerOptions& options)
    1947 {
    1948     return tryAddEventListener(this, eventType, WTFMove(listener), options);
    1949 }
    1950 
    1951 static inline bool tryRemoveEventListener(Node* targetNode, const AtomicString& eventType, EventListener& listener, const EventTarget::ListenerOptions& options)
    1952 {
    1953     if (!targetNode->EventTarget::removeEventListener(eventType, listener, options))
     1946bool Node::addEventListener(const AtomicString& eventType, Ref<EventListener>&& listener, bool useCapture)
     1947{
     1948    return tryAddEventListener(this, eventType, WTFMove(listener), useCapture);
     1949}
     1950
     1951static inline bool tryRemoveEventListener(Node* targetNode, const AtomicString& eventType, EventListener& listener, bool useCapture)
     1952{
     1953    if (!targetNode->EventTarget::removeEventListener(eventType, listener, useCapture))
    19541954        return false;
    19551955
    … …  
    19691969    // Forward this call to removeEventListener() to the window since these are window-only events.
    19701970    if (eventType == eventNames().orientationchangeEvent || eventType == eventNames().resizeEvent)
    1971         targetNode->document().domWindow()->removeEventListener(eventType, listener, options);
     1971        targetNode->document().domWindow()->removeEventListener(eventType, listener, useCapture);
    19721972
    19731973#if ENABLE(TOUCH_EVENTS)
    … …  
    19851985}
    19861986
    1987 bool Node::removeEventListener(const AtomicString& eventType, EventListener& listener, const ListenerOptions& options)
    1988 {
    1989     return tryRemoveEventListener(this, eventType, listener, options);
     1987bool Node::removeEventListener(const AtomicString& eventType, EventListener& listener, bool useCapture)
     1988{
     1989    return tryRemoveEventListener(this, eventType, listener, useCapture);
    19901990}
    19911991

  • trunk/Source/WebCore/dom/Node.h

    r201730 r201734  
    508508    ScriptExecutionContext* scriptExecutionContext() const final; // Implemented in Document.h
    509509
    510     bool addEventListener(const AtomicString& eventType, Ref<EventListener>&&, const AddEventListenerOptions&) override;
    511     bool removeEventListener(const AtomicString& eventType, EventListener&, const ListenerOptions&) override;
     510    bool addEventListener(const AtomicString& eventType, Ref<EventListener>&&, bool useCapture) override;
     511    bool removeEventListener(const AtomicString& eventType, EventListener&, bool useCapture) override;
    512512
    513513    using EventTarget::dispatchEvent;

  • trunk/Source/WebCore/dom/RegisteredEventListener.h

    r201730 r201734  
    3232    class RegisteredEventListener {
    3333    public:
    34         struct Options {
    35             Options(bool capture = false, bool passive = false, bool once = false)
    36                 : capture(capture)
    37                 , passive(passive)
    38                 , once(once)
    39             { }
    40 
    41             bool capture;
    42             bool passive;
    43             bool once;
    44         };
    45 
    46         RegisteredEventListener(Ref<EventListener>&& listener, const Options& options)
    47             : listener(WTFMove(listener))
    48             , useCapture(options.capture)
    49             , isPassive(options.passive)
    50             , isOnce(options.once)
    51         {
    52         }
    53 
    5434        RegisteredEventListener(Ref<EventListener>&& listener, bool useCapture)
    5535            : listener(WTFMove(listener))
    … …  
    5939
    6040        RefPtr<EventListener> listener;
    61         bool useCapture { false };
    62         bool isPassive { false };
    63         bool isOnce { false };
    64         bool isMarkedForRemoval { false };
     41        bool useCapture;
    6542    };
    6643   
    6744    inline bool operator==(const RegisteredEventListener& a, const RegisteredEventListener& b)
    6845    {
    69         // Other data members are purposefully not checked. The DOM specification says that upon adding / removing
    70         // EventListeners, we should only check the type and the capture flag.
    7146        return *a.listener == *b.listener && a.useCapture == b.useCapture;
    7247    }

  • trunk/Source/WebCore/html/HTMLMediaElement.cpp

    r201730 r201734  
    52295229}
    52305230
    5231 bool HTMLMediaElement::addEventListener(const AtomicString& eventType, Ref<EventListener>&& listener, const AddEventListenerOptions& options)
     5231bool HTMLMediaElement::addEventListener(const AtomicString& eventType, Ref<EventListener>&& listener, bool useCapture)
    52325232{
    52335233    if (eventType != eventNames().webkitplaybacktargetavailabilitychangedEvent)
    5234         return Node::addEventListener(eventType, WTFMove(listener), options);
     5234        return Node::addEventListener(eventType, WTFMove(listener), useCapture);
    52355235
    52365236    bool isFirstAvailabilityChangedListener = !hasEventListeners(eventNames().webkitplaybacktargetavailabilitychangedEvent);
    5237     if (!Node::addEventListener(eventType, WTFMove(listener), options))
     5237    if (!Node::addEventListener(eventType, WTFMove(listener), useCapture))
    52385238        return false;
    52395239
    … …  
    52495249}
    52505250
    5251 bool HTMLMediaElement::removeEventListener(const AtomicString& eventType, EventListener& listener, const ListenerOptions& options)
     5251bool HTMLMediaElement::removeEventListener(const AtomicString& eventType, EventListener& listener, bool useCapture)
    52525252{
    52535253    if (eventType != eventNames().webkitplaybacktargetavailabilitychangedEvent)
    5254         return Node::removeEventListener(eventType, listener, options);
    5255 
    5256     if (!Node::removeEventListener(eventType, listener, options))
     5254        return Node::removeEventListener(eventType, listener, useCapture);
     5255
     5256    if (!Node::removeEventListener(eventType, listener, useCapture))
    52575257        return false;
    52585258

  • trunk/Source/WebCore/html/HTMLMediaElement.h

    r201730 r201734  
    343343#if ENABLE(WIRELESS_PLAYBACK_TARGET)
    344344    void webkitShowPlaybackTargetPicker();
    345     bool addEventListener(const AtomicString& eventType, Ref<EventListener>&&, const AddEventListenerOptions&) override;
    346     bool removeEventListener(const AtomicString& eventType, EventListener&, const ListenerOptions&) override;
     345    bool addEventListener(const AtomicString& eventType, Ref<EventListener>&&, bool useCapture) override;
     346    bool removeEventListener(const AtomicString& eventType, EventListener&, bool useCapture) override;
    347347
    348348    void wirelessRoutesAvailableDidChange() override;

  • trunk/Source/WebCore/page/DOMWindow.cpp

    r201730 r201734  
    17231723}
    17241724
    1725 bool DOMWindow::addEventListener(const AtomicString& eventType, Ref<EventListener>&& listener, const AddEventListenerOptions& options)
    1726 {
    1727     if (!EventTarget::addEventListener(eventType, WTFMove(listener), options))
     1725bool DOMWindow::addEventListener(const AtomicString& eventType, Ref<EventListener>&& listener, bool useCapture)
     1726{
     1727    if (!EventTarget::addEventListener(eventType, WTFMove(listener), useCapture))
    17281728        return false;
    17291729
    … …  
    18261826}
    18271827
    1828 bool DOMWindow::removeEventListener(const AtomicString& eventType, EventListener& listener, const ListenerOptions& options)
    1829 {
    1830     if (!EventTarget::removeEventListener(eventType, listener, options.capture))
     1828bool DOMWindow::removeEventListener(const AtomicString& eventType, EventListener& listener, bool useCapture)
     1829{
     1830    if (!EventTarget::removeEventListener(eventType, listener, useCapture))
    18311831        return false;
    18321832

  • trunk/Source/WebCore/page/DOMWindow.h

    r201730 r201734  
    280280        // Events
    281281        // EventTarget API
    282         bool addEventListener(const AtomicString& eventType, Ref<EventListener>&&, const AddEventListenerOptions&) override;
    283         bool removeEventListener(const AtomicString& eventType, EventListener&, const ListenerOptions&) override;
     282        bool addEventListener(const AtomicString& eventType, Ref<EventListener>&&, bool useCapture) override;
     283        bool removeEventListener(const AtomicString& eventType, EventListener&, bool useCapture) override;
    284284        void removeAllEventListeners() override;
    285285

  • trunk/Source/WebCore/svg/SVGElement.cpp

    r201730 r201734  
    529529}
    530530
    531 bool SVGElement::addEventListener(const AtomicString& eventType, Ref<EventListener>&& listener, const AddEventListenerOptions& options)
     531bool SVGElement::addEventListener(const AtomicString& eventType, Ref<EventListener>&& listener, bool useCapture)
    532532{   
    533533    // Add event listener to regular DOM element
    534     if (!Node::addEventListener(eventType, listener.copyRef(), options))
     534    if (!Node::addEventListener(eventType, listener.copyRef(), useCapture))
    535535        return false;
    536536
    … …  
    542542    for (auto* instance : instances()) {
    543543        ASSERT(instance->correspondingElement() == this);
    544         bool result = instance->Node::addEventListener(eventType, listener.copyRef(), options);
     544        bool result = instance->Node::addEventListener(eventType, listener.copyRef(), useCapture);
    545545        ASSERT_UNUSED(result, result);
    546546    }
    … …  
    549549}
    550550
    551 bool SVGElement::removeEventListener(const AtomicString& eventType, EventListener& listener, const ListenerOptions& options)
     551bool SVGElement::removeEventListener(const AtomicString& eventType, EventListener& listener, bool useCapture)
    552552{
    553553    if (containingShadowRoot())
    554         return Node::removeEventListener(eventType, listener, options);
     554        return Node::removeEventListener(eventType, listener, useCapture);
    555555
    556556    // EventTarget::removeEventListener creates a PassRefPtr around the given EventListener
    … …  
    562562
    563563    // Remove event listener from regular DOM element
    564     if (!Node::removeEventListener(eventType, listener, options))
     564    if (!Node::removeEventListener(eventType, listener, useCapture))
    565565        return false;
    566566
    … …  
    570570        ASSERT(instance->correspondingElement() == this);
    571571
    572         if (instance->Node::removeEventListener(eventType, listener, options))
     572        if (instance->Node::removeEventListener(eventType, listener, useCapture))
    573573            continue;
    574574

  • trunk/Source/WebCore/svg/SVGElement.h

    r201730 r201734  
    134134    virtual bool haveLoadedRequiredResources();
    135135
    136     bool addEventListener(const AtomicString& eventType, Ref<EventListener>&&, const AddEventListenerOptions&) override;
    137     bool removeEventListener(const AtomicString& eventType, EventListener&, const ListenerOptions&) override;
     136    bool addEventListener(const AtomicString& eventType, Ref<EventListener>&&, bool useCapture) override;
     137    bool removeEventListener(const AtomicString& eventType, EventListener&, bool useCapture) override;
    138138    bool hasFocusEventListeners() const;
    139139
Note: See TracChangeset for help on using the changeset viewer.