Support "once" event listener option

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 597 matching lines @@
 
         // Move the iterator past this event listener. This must match
         // the handling of the FiringEventIterator::iterator in
         // EventTarget::removeEventListener.
         ++i;
 
         if (event->eventPhase() == Event::kCapturingPhase && !registeredListener.capture())
             continue;
         if (event->eventPhase() == Event::kBubblingPhase && registeredListener.capture())
             continue;
+        if (registeredListener.onceBeingRemoved())

[dtapuska, 2016/08/12 18:44:02]

Is it possible to change the RegisteredListener not to be a reference but a copy
on the stack in this method and call removeEventListener before you dispatch the
event to the listener. That should prevent the re-entrancy problem the
onceBeingRemoved is trying to fix. I just wonder if it is over complicated and
could be fixed in an alternate fashion.

[Anton Obzhirov, 2016/08/15 22:18:01]

Hm, I will need to add new method to EventListenerVector to swap content of the
RegisteredEventListener instance in the vector with the new instance on stack
and then remove empty registered listener from EventListenerVector. Should be
possible to do, let me try.

+            continue;
 
         // If stopImmediatePropagation has been called, we just break out immediately, without
         // handling any more events on this target.
         if (event->immediatePropagationStopped())
             break;
 
         event->setHandlingPassive(registeredListener.passive());
         bool passiveForced = registeredListener.passiveForcedForDocumentTarget();
 
+        // Mark listener for removal before executing the listener, in case the listener tries to
+        // dispatch an event that would cause it to get executed again.
+        if (registeredListener.once())
+            registeredListener.setOnceBeingRemoved();
+
         InspectorInstrumentation::NativeBreakpoint nativeBreakpoint(context, this, event);
 
         EventListener* listener = registeredListener.listener();
 
         // To match Mozilla, the AT_TARGET phase fires both capturing and bubbling
         // event listeners, even though that violates some versions of the DOM spec.
         listener->handleEvent(context, event);
         firedListener = true;
 
         // If we're about to report this event listener as blocking, make sure it wasn't
         // removed while handling the event.
         if (shouldReportBlockedEvent && i > 0 && entry[i - 1].listener() == listener
             && !entry[i - 1].passive() && !entry[i - 1].blockedEventWarningEmitted() && !event->defaultPrevented()) {
             reportBlockedEvent(context, event, &entry[i - 1], now - event->platformTimeStamp());
         }
 
         if (passiveForced) {
             DEFINE_STATIC_LOCAL(EnumerationHistogram, passiveForcedHistogram, ("Event.PassiveForcedEventDispatchCancelled", PassiveForcedListenerResultTypeMax));
             PassiveForcedListenerResultType breakageType = PreventDefaultNotCalled;
             if (event->preventDefaultCalledDuringPassive())
                 breakageType = DocumentLevelTouchPreventDefaultCalled;
 
             passiveForcedHistogram.count(breakageType);
         }
 
         event->setHandlingPassive(false);
-
+        if (registeredListener.once())
+            removeEventListener(event->type(), listener, registeredListener.capture());
         RELEASE_ASSERT(i <= size);
     }
     d->firingEventIterators->removeLast();
     return firedListener;
 }
 
 DispatchEventResult EventTarget::dispatchEventResult(const Event& event)
 {
     if (event.defaultPrevented())
         return DispatchEventResult::CanceledByEventHandler;
@@ skipping 27 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