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 61 matching lines @@
 public:
     EventTargetData();
     ~EventTargetData();
 
     DECLARE_TRACE();
 
     EventListenerMap eventListenerMap;
     OwnPtr<FiringEventIteratorVector> firingEventIterators;
 };
 
+enum class DispatchEventResult {
+    // Event was not canceled by event handler or default event handler.
+    NotCanceled,
+    // Event was canceled by event handler; ie. a script handler calling preventDefault.

[philipj_slow, 2016/02/25 04:21:27]

i.e. is a much more common spelling, in Source/core at least.

[dtapuska, 2016/02/25 14:20:24]

Done.

+    CanceledByEventHandler,
+    // Event was canceled by the default event handler; ie. executing the default action.
+    // This result should be used sparingly as it deviates from the DOM Event Dispatch
+    // model. Default event handlers really shouldn't be invoked inside of dispatch.
+    CanceledByDefaultEventHandler,
+    // Event was canceled but suppressed before dispatched to event handler.
+    // This result should be used sparingly; and likely its usage likely indicates

[philipj_slow, 2016/02/25 04:21:27]

two likely

[dtapuska, 2016/02/25 14:20:24]

Done.

+    // there is potential for a bug. Trusted events may return this code; but untrusted
+    // events likely should always execute the event handler the developer intends to
+    // execute.
+    CanceledBeforeDispatch,
+};
+
 // This is the base class for all DOM event targets. To make your class an
 // EventTarget, follow these steps:
 // - Make your IDL interface inherit from EventTarget.
 //   Optionally add "attribute EventHandler onfoo;" attributes.
 // - Inherit from EventTargetWithInlineData (only in rare cases should you use
 //   EventTarget directly); or, if you want YourClass to be inherited from
 //   RefCountedGarbageCollected<YourClass> in addition to EventTargetWithInlineData,
 //   inherit from RefCountedGarbageCollectedEventTargetWithInlineData<YourClass>.
 // - In your class declaration, EventTargetWithInlineData (or
 //   RefCountedGarbageCollectedEventTargetWithInlineData<>) must come first in
@@ skipping 39 matching lines @@
 
     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>);
+    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*);
+    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 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