Enumerate the return value of dispatchEvent so it is clear.

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

 /*
  * 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, 2008 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 96 matching lines @@
 //   or the document you're in.
 // - Your trace() method will need to call EventTargetWithInlineData::trace
 //   or RefCountedGarbageCollectedEventTargetWithInlineData<YourClass>::trace,
 //   depending on the base class of your class.
 //
 // Optionally, add a FooEvent.idl class, but that's outside the scope of this
 // comment (and much more straightforward).
 class CORE_EXPORT EventTarget : public NoBaseWillBeGarbageCollectedFinalized<EventTarget>, public ScriptWrappable {
     DEFINE_WRAPPERTYPEINFO();
 public:
+    enum class DispatchEventResult {

[tkent, 2016/02/22 01:40:22]

nit: You may move this out from EventTarget for code simplicity.

[dtapuska, 2016/02/23 19:14:40]

Done.

+        // Event was not consumed by application or system.
+        NotHandled,

[philipj_slow, 2016/02/22 07:30:18]

In order to bring this closer to the
https://dom.spec.whatwg.org/#concept-event-dispatch model, can you put the two
cases corresponding to the true/false return values of dispatchEvent at the top,
and give the other two long and scary names as well as comments that they should
not be used?

Maybe NotCanceled, Canceled(ByEventHandler), CanceledByDefaultEventHandler and
CanceledBeforeDispatch, if that's accurate?

[Rick Byers, 2016/02/22 15:16:14]

+1.  This is the place to describe how we want the usage of these to evolve over
time to better match the spec.

[dtapuska, 2016/02/23 19:14:40]

Done.

[dtapuska, 2016/02/23 19:14:40]

Done.

+        // Event was consumed but suppressed before dispatched to application.
+        HandledSuppressed,
+        // Event was consumed by application itself; ie. a script handler calling preventDefault.
+        HandledApplication,
+        // Event was consumed by the system; ie. executing the default action.
+        HandledSystem,
+    };
+
     virtual ~EventTarget();
 
 #if !ENABLE(OILPAN)
     void ref() { refEventTarget(); }
     void deref() { derefEventTarget(); }
 #endif
 
     virtual const AtomicString& interfaceName() const = 0;
     virtual ExecutionContext* executionContext() const = 0;
 
     virtual Node* toNode();
     virtual const LocalDOMWindow* toDOMWindow() const;
     virtual LocalDOMWindow* toDOMWindow();
     virtual MessagePort* toMessagePort();
 
     bool addEventListener(const AtomicString& eventType, PassRefPtrWillBeRawPtr<EventListener>, bool useCapture = false);
     bool addEventListener(const AtomicString& eventType, PassRefPtrWillBeRawPtr<EventListener>, const EventListenerOptionsOrBoolean&);
     bool addEventListener(const AtomicString& eventType, PassRefPtrWillBeRawPtr<EventListener>, EventListenerOptions&);
 
     bool removeEventListener(const AtomicString& eventType, PassRefPtrWillBeRawPtr<EventListener>, bool useCapture = false);
     bool removeEventListener(const AtomicString& eventType, PassRefPtrWillBeRawPtr<EventListener>, const EventListenerOptionsOrBoolean&);
     bool removeEventListener(const AtomicString& eventType, PassRefPtrWillBeRawPtr<EventListener>, EventListenerOptions&);
     virtual void removeAllEventListeners();
 
-    bool dispatchEvent(PassRefPtrWillBeRawPtr<Event>);
+    EventTarget::DispatchEventResult dispatchEvent(PassRefPtrWillBeRawPtr<Event>);
 
     // dispatchEventForBindings is intended to only be called from
     // javascript originated calls. This method will validate and may adjust
     // the Event object before dispatching.
     bool dispatchEventForBindings(PassRefPtrWillBeRawPtr<Event>, ExceptionState&);
     virtual void uncaughtExceptionInEventHandler();
 
     // Used for legacy "onEvent" attribute APIs.
     bool setAttributeEventListener(const AtomicString& eventType, PassRefPtrWillBeRawPtr<EventListener>);
     EventListener* getAttributeEventListener(const AtomicString& eventType);
 
     bool hasEventListeners() const;
     bool hasEventListeners(const AtomicString& eventType) const;
     bool hasCapturingEventListeners(const AtomicString& eventType);
     EventListenerVector* getEventListeners(const AtomicString& eventType);
     Vector<AtomicString> eventTypes();
 
-    bool fireEventListeners(Event*);
+    EventTarget::DispatchEventResult fireEventListeners(Event*);
 
     DEFINE_INLINE_VIRTUAL_TRACE() { }
 
     virtual bool keepEventInNode(Event*) { return false; }
 
 protected:
     EventTarget();
 
     virtual bool addEventListenerInternal(const AtomicString& eventType, PassRefPtrWillBeRawPtr<EventListener>, const EventListenerOptions&);
     virtual bool removeEventListenerInternal(const AtomicString& eventType, PassRefPtrWillBeRawPtr<EventListener>, const EventListenerOptions&);
-    virtual bool dispatchEventInternal(PassRefPtrWillBeRawPtr<Event>);
+    virtual EventTarget::DispatchEventResult dispatchEventInternal(PassRefPtrWillBeRawPtr<Event>);
 
     // Subclasses should likely not override these themselves; instead, they should subclass EventTargetWithInlineData.
     virtual EventTargetData* eventTargetData() = 0;
     virtual EventTargetData& ensureEventTargetData() = 0;
 
 private:
 #if !ENABLE(OILPAN)
     // Subclasses should likely not override these themselves; instead, they should use the REFCOUNTED_EVENT_TARGET() macro.
     virtual void refEventTarget() = 0;
     virtual void derefEventTarget() = 0;
@@ skipping 138 matching lines @@
     using baseClass::deref; \
 private: \
     void refEventTarget() final { ref(); } \
     void derefEventTarget() final { deref(); } \
     typedef int thisIsHereToForceASemiColonAfterThisEventTargetMacro
 #define REFCOUNTED_EVENT_TARGET(baseClass) DEFINE_EVENT_TARGET_REFCOUNTING(RefCounted<baseClass>)
 #define REFCOUNTED_GARBAGE_COLLECTED_EVENT_TARGET(baseClass) DEFINE_EVENT_TARGET_REFCOUNTING(RefCountedGarbageCollected<baseClass>)
 #endif // ENABLE(OILPAN)
 
 #endif // EventTarget_h