Attachment 347986 Details for Bug 188720 – Cleanup

[patch] Cleanup

bug-188720-20180823211248.patch (text/plain), 58.12 KB, created by Ryosuke Niwa on 2018-08-23 21:12:49 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Ryosuke Niwa

Created: 2018-08-23 21:12:49 PDT

Size: 58.12 KB

patch

obsolete

>Index: Source/WebCore/ChangeLog
>===================================================================
>--- Source/WebCore/ChangeLog	(revision 235200)
>+++ Source/WebCore/ChangeLog	(working copy)
>@@ -1,3 +1,88 @@
>+2018-08-23  Ryosuke Niwa  <rniwa@webkit.org>
>+
>+        Pass in IsComposed flag to Event constructors
>+        https://bugs.webkit.org/show_bug.cgi?id=188720
>+        <rdar://problem/43580387>
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        This patch replaces the logic in Event::isComposed to decide whether an event is composed or not by
>+        explicitly passing IsComposed flag to Event constructor. This decouples being composed from whether
>+        an event is trusted and of a partciular event type, paving our way to make synthetic click event
>+        dispatched by an author script composable in webkit.org/b/170211.
>+
>+        This patch also removes IsTrusted from the argument list of event constructors and create functions
>+        to systematically eliminate the possibility of this patch making an event uncomposed by not setting
>+        IsComposed flag.
>+
>+        No new tests since there should be no behavioral change.
>+
>+        * dom/ClipboardEvent.cpp:
>+        (WebCore::ClipboardEvent::ClipboardEvent): A trusted ClipboardEvent is composed.
>+        * dom/ClipboardEvent.h:
>+        (WebCore::ClipboardEvent::ClipboardEvent): Removed IsTrusted from the variant which takes Init object
>+        to make sure this refactoring is correct.
>+        (WebCore::ClipboardEvent::create): Ditto.
>+        * dom/CompositionEvent.cpp:
>+        (WebCore::CompositionEvent::CompositionEvent): A trusted CompositionEvent is composed.
>+        * dom/CompositionEvent.h:
>+        * dom/Element.cpp:
>+        (WebCore::Element::dispatchMouseEvent): A trusted dblclick event is composed (this is a non-standard
>+        event but virtually every mouse event is composed so it makes sense to make this composed).
>+        * dom/Event.cpp:
>+        (WebCore::Event::Event):
>+        (WebCore::Event::create):
>+        (WebCore::Event::composed const): Deleted. The trival implementation moved to the header file.
>+        * dom/Event.h:
>+        (WebCore::Event::composed const):
>+        * dom/FocusEvent.cpp:
>+        (WebCore::FocusEvent::FocusEvent): A trusted Focus event is composed.
>+        * dom/FocusEvent.h:
>+        (WebCore::FocusEvent::create): Removed IsTrusted from Init variant for the correctness guarantee.
>+        (WebCore::FocusEvent::FocusEvent): Ditto.
>+        * dom/InputEvent.cpp:
>+        (WebCore::InputEvent::create): Removed IsTrusted from Init variant for the correctness guarantee.
>+        (WebCore::InputEvent::InputEvent): A trsuted InputEvent is composed.
>+        * dom/InputEvent.h:
>+        * dom/KeyboardEvent.cpp:
>+        (WebCore::KeyboardEvent::KeyboardEvent): A trsuted KeyboardEvent is composed.
>+        (WebCore::KeyboardEvent::create): Removed IsTrusted from Init variant for the correctness guarantee.
>+        * dom/KeyboardEvent.h:
>+        * dom/MouseEvent.cpp:
>+        (WebCore::MouseEvent::create): Removed IsTrusted from Init variant for the correctness guarantee.
>+        (WebCore::MouseEvent::MouseEvent): Explicitly take IsComposed flag from subclasses since simulated click
>+        does not currently compose.
>+        * dom/MouseEvent.h:
>+        * dom/MouseRelatedEvent.cpp:
>+        (WebCore::MouseRelatedEvent::MouseRelatedEvent): A trusted touch event is composed.
>+        * dom/MouseRelatedEvent.h:
>+        * dom/Node.cpp:
>+        (WebCore::Node::dispatchDOMActivateEvent): A trusted DOMActivateEvent event is composed.
>+        (WebCore::Node::dispatchInputEvent): A trusted input event is composed.
>+        * dom/SimulatedClick.cpp:
>+        (SimulatedMouseEvent::SimulatedMouseEvent): A simulated click is composed if it's a trusted event for now.
>+        This is the bug to be fixed in webkit.org/b/170211.
>+        * dom/TextEvent.cpp:
>+        (WebCore::TextEvent::TextEvent): A trsuted textInput event is composed.
>+        * dom/UIEvent.cpp:
>+        (WebCore::UIEvent::UIEvent): Added IsComposed as an argument to the variant which creates a trusted event,
>+        and removed IsTrusted from Init variant for the correctness guarantee.
>+        * dom/UIEvent.h:
>+        (WebCore::UIEvent::create): Ditto.
>+        * dom/UIEventWithKeyState.h:
>+        (WebCore::UIEventWithKeyState::UIEventWithKeyState): Ditto.
>+        * dom/WheelEvent.cpp:
>+        (WebCore::WheelEvent::WheelEvent): A trusted Wheel event, which is a subclass of MouseEvent, is composed.
>+        (WebCore::WheelEvent::create): Removed IsTrusted from Init variant for the correctness guarantee.
>+        * dom/WheelEvent.h:
>+        * editing/Editor.cpp:
>+        (WebCore::dispatchBeforeInputEvent):
>+        (WebCore::dispatchInputEvent):
>+        (WebCore::dispatchClipboardEvent): Call the newly added variant which takes DataTransfer directly so that
>+        we can remove IsTrusted from the variant which takes Init for the correctness guarantee.
>+        * page/EventHandler.cpp:
>+        (WebCore::EventHandler::dispatchDragEvent): A trusted mouse event is composed.
>+
> 2018-08-22  Eric Carlson  <eric.carlson@apple.com>
> 
>         Log more often during AirPlay state changes
>Index: Source/WebCore/dom/ClipboardEvent.cpp
>===================================================================
>--- Source/WebCore/dom/ClipboardEvent.cpp	(revision 235200)
>+++ Source/WebCore/dom/ClipboardEvent.cpp	(working copy)
>@@ -27,8 +27,14 @@
> 
> namespace WebCore {
> 
>-ClipboardEvent::ClipboardEvent(const AtomicString& type, const Init& init, IsTrusted isTrusted)
>-    : Event(type, init, isTrusted)
>+ClipboardEvent::ClipboardEvent(const AtomicString& type, Ref<DataTransfer>&& dataTransfer)
>+    : Event(type, CanBubble::Yes, IsCancelable::Yes, IsComposed::Yes)
>+    , m_clipboardData(WTFMove(dataTransfer))
>+{
>+}
>+
>+ClipboardEvent::ClipboardEvent(const AtomicString& type, const Init& init)
>+    : Event(type, init, IsTrusted::No)
>     , m_clipboardData(init.clipboardData)
> {
> }
>Index: Source/WebCore/dom/ClipboardEvent.h
>===================================================================
>--- Source/WebCore/dom/ClipboardEvent.h	(revision 235200)
>+++ Source/WebCore/dom/ClipboardEvent.h	(working copy)
>@@ -37,16 +37,21 @@ public:
>         RefPtr<DataTransfer> clipboardData;
>     };
> 
>-    static Ref<ClipboardEvent> create(const AtomicString& type, const Init& init, IsTrusted isTrusted = IsTrusted::No)
>+    static Ref<ClipboardEvent> create(const AtomicString& type, Ref<DataTransfer>&& dataTransfer)
>     {
>-        auto event = adoptRef(*new ClipboardEvent(type, init, isTrusted));
>-        return event;
>+        return adoptRef(*new ClipboardEvent(type, WTFMove(dataTransfer)));
>+    }
>+
>+    static Ref<ClipboardEvent> create(const AtomicString& type, const Init& init)
>+    {
>+        return adoptRef(*new ClipboardEvent(type, init));
>     }
> 
>     DataTransfer* clipboardData() const { return m_clipboardData.get(); }
> 
> private:
>-    ClipboardEvent(const AtomicString& type, const Init&, IsTrusted);
>+    ClipboardEvent(const AtomicString& type, Ref<DataTransfer>&&);
>+    ClipboardEvent(const AtomicString& type, const Init&);
> 
>     EventInterface eventInterface() const final;
>     bool isClipboardEvent() const final;
>Index: Source/WebCore/dom/CompositionEvent.cpp
>===================================================================
>--- Source/WebCore/dom/CompositionEvent.cpp	(revision 235200)
>+++ Source/WebCore/dom/CompositionEvent.cpp	(working copy)
>@@ -32,13 +32,13 @@ namespace WebCore {
> CompositionEvent::CompositionEvent() = default;
> 
> CompositionEvent::CompositionEvent(const AtomicString& type, RefPtr<WindowProxy>&& view, const String& data)
>-    : UIEvent(type, CanBubble::Yes, IsCancelable::Yes, WTFMove(view), 0)
>+    : UIEvent(type, CanBubble::Yes, IsCancelable::Yes, IsComposed::Yes, WTFMove(view), 0)
>     , m_data(data)
> {
> }
> 
>-CompositionEvent::CompositionEvent(const AtomicString& type, const Init& initializer, IsTrusted isTrusted)
>-    : UIEvent(type, initializer, isTrusted)
>+CompositionEvent::CompositionEvent(const AtomicString& type, const Init& initializer)
>+    : UIEvent(type, initializer)
>     , m_data(initializer.data)
> {
> }
>Index: Source/WebCore/dom/CompositionEvent.h
>===================================================================
>--- Source/WebCore/dom/CompositionEvent.h	(revision 235200)
>+++ Source/WebCore/dom/CompositionEvent.h	(working copy)
>@@ -46,9 +46,9 @@ public:
>         String data;
>     };
> 
>-    static Ref<CompositionEvent> create(const AtomicString& type, const Init& initializer, IsTrusted isTrusted = IsTrusted::No)
>+    static Ref<CompositionEvent> create(const AtomicString& type, const Init& initializer)
>     {
>-        return adoptRef(*new CompositionEvent(type, initializer, isTrusted));
>+        return adoptRef(*new CompositionEvent(type, initializer));
>     }
> 
>     virtual ~CompositionEvent();
>@@ -62,7 +62,7 @@ public:
> private:
>     CompositionEvent();
>     CompositionEvent(const AtomicString& type, RefPtr<WindowProxy>&&, const String&);
>-    CompositionEvent(const AtomicString& type, const Init&, IsTrusted);
>+    CompositionEvent(const AtomicString& type, const Init&);
> 
>     bool isCompositionEvent() const override;
> 
>Index: Source/WebCore/dom/Element.cpp
>===================================================================
>--- Source/WebCore/dom/Element.cpp	(revision 235200)
>+++ Source/WebCore/dom/Element.cpp	(working copy)
>@@ -292,7 +292,9 @@ bool Element::dispatchMouseEvent(const P
>         // as a separate event in other DOM-compliant browsers like Firefox, and so we do the same.
>         // FIXME: Is it okay that mouseEvent may have been mutated by scripts via initMouseEvent in dispatchEvent above?
>         Ref<MouseEvent> doubleClickEvent = MouseEvent::create(eventNames().dblclickEvent,
>-            mouseEvent->bubbles() ? Event::CanBubble::Yes : Event::CanBubble::No, mouseEvent->cancelable() ? Event::IsCancelable::Yes : Event::IsCancelable::No,
>+            mouseEvent->bubbles() ? Event::CanBubble::Yes : Event::CanBubble::No,
>+            mouseEvent->cancelable() ? Event::IsCancelable::Yes : Event::IsCancelable::No,
>+            Event::IsComposed::Yes,
>             mouseEvent->view(), mouseEvent->detail(),
>             mouseEvent->screenX(), mouseEvent->screenY(), mouseEvent->clientX(), mouseEvent->clientY(),
>             mouseEvent->modifierKeys(), mouseEvent->button(), mouseEvent->buttons(), mouseEvent->syntheticClickType(), relatedTarget);
>Index: Source/WebCore/dom/Event.cpp
>===================================================================
>--- Source/WebCore/dom/Event.cpp	(revision 235200)
>+++ Source/WebCore/dom/Event.cpp	(working copy)
>@@ -57,14 +57,14 @@ Event::Event(IsTrusted isTrusted)
> {
> }
> 
>-Event::Event(const AtomicString& eventType, CanBubble canBubble, IsCancelable isCancelable)
>-    : Event { MonotonicTime::now(), eventType, IsTrusted::Yes, canBubble, isCancelable, IsComposed::No }
>+Event::Event(const AtomicString& eventType, CanBubble canBubble, IsCancelable isCancelable, IsComposed isComposed)
>+    : Event { MonotonicTime::now(), eventType, IsTrusted::Yes, canBubble, isCancelable, isComposed }
> {
>     ASSERT(!eventType.isNull());
> }
> 
>-Event::Event(const AtomicString& eventType, CanBubble canBubble, IsCancelable isCancelable, MonotonicTime timestamp)
>-    : Event { timestamp, eventType, IsTrusted::Yes, canBubble, isCancelable, IsComposed::No }
>+Event::Event(const AtomicString& eventType, CanBubble canBubble, IsCancelable isCancelable, IsComposed isComposed, MonotonicTime timestamp)
>+    : Event { timestamp, eventType, IsTrusted::Yes, canBubble, isCancelable, isComposed }
> {
>     ASSERT(!eventType.isNull());
> }
>@@ -80,9 +80,9 @@ Event::Event(const AtomicString& eventTy
> 
> Event::~Event() = default;
> 
>-Ref<Event> Event::create(const AtomicString& type, CanBubble canBubble, IsCancelable isCancelable)
>+Ref<Event> Event::create(const AtomicString& type, CanBubble canBubble, IsCancelable isCancelable, IsComposed isComposed)
> {
>-    return adoptRef(*new Event(type, canBubble, isCancelable));
>+    return adoptRef(*new Event(type, canBubble, isCancelable, isComposed));
> }
> 
> Ref<Event> Event::createForBindings()
>@@ -113,27 +113,6 @@ void Event::initEvent(const AtomicString
>     m_underlyingEvent = nullptr;
> }
> 
>-bool Event::composed() const
>-{
>-    if (m_composed)
>-        return true;
>-
>-    // http://w3c.github.io/webcomponents/spec/shadow/#scoped-flag
>-    if (!isTrusted())
>-        return false;
>-
>-    return m_type == eventNames().inputEvent
>-        || m_type == eventNames().textInputEvent
>-        || m_type == eventNames().DOMActivateEvent
>-        || isCompositionEvent()
>-        || isClipboardEvent()
>-        || isFocusEvent()
>-        || isKeyboardEvent()
>-        || isMouseEvent()
>-        || isTouchEvent()
>-        || isInputEvent();
>-}
>-
> void Event::setTarget(RefPtr<EventTarget>&& target)
> {
>     if (m_target == target)
>Index: Source/WebCore/dom/Event.h
>===================================================================
>--- Source/WebCore/dom/Event.h	(revision 235200)
>+++ Source/WebCore/dom/Event.h	(working copy)
>@@ -52,7 +52,7 @@ public:
>         BUBBLING_PHASE = 3
>     };
> 
>-    WEBCORE_EXPORT static Ref<Event> create(const AtomicString& type, CanBubble, IsCancelable);
>+    WEBCORE_EXPORT static Ref<Event> create(const AtomicString& type, CanBubble, IsCancelable, IsComposed = IsComposed::No);
>     static Ref<Event> createForBindings();
>     static Ref<Event> create(const AtomicString& type, const EventInit&, IsTrusted = IsTrusted::No);
> 
>@@ -76,7 +76,7 @@ public:
> 
>     bool bubbles() const { return m_canBubble; }
>     bool cancelable() const { return m_cancelable; }
>-    WEBCORE_EXPORT bool composed() const;
>+    bool composed() const { return m_composed; }
> 
>     DOMHighResTimeStamp timeStampForBindings(ScriptExecutionContext&) const;
>     MonotonicTime timeStamp() const { return m_createTime; }
>@@ -142,8 +142,8 @@ public:
> 
> protected:
>     explicit Event(IsTrusted = IsTrusted::No);
>-    Event(const AtomicString& type, CanBubble, IsCancelable);
>-    Event(const AtomicString& type, CanBubble, IsCancelable, MonotonicTime timestamp);
>+    Event(const AtomicString& type, CanBubble, IsCancelable, IsComposed = IsComposed::No);
>+    Event(const AtomicString& type, CanBubble, IsCancelable, IsComposed, MonotonicTime timestamp);
>     Event(const AtomicString& type, const EventInit&, IsTrusted);
> 
>     virtual void receivedTarget() { }
>Index: Source/WebCore/dom/FocusEvent.cpp
>===================================================================
>--- Source/WebCore/dom/FocusEvent.cpp	(revision 235200)
>+++ Source/WebCore/dom/FocusEvent.cpp	(working copy)
>@@ -40,14 +40,14 @@ bool FocusEvent::isFocusEvent() const
>     return true;
> }
> 
>-FocusEvent::FocusEvent(const AtomicString& type, CanBubble canBubble, IsCancelable cancelable, RefPtr<WindowProxy>&& view, int detail, RefPtr<EventTarget>&& relatedTarget)
>-    : UIEvent(type, canBubble, cancelable, WTFMove(view), detail)
>+FocusEvent::FocusEvent(const AtomicString& type, CanBubble canBubble, IsCancelable isCancelable, RefPtr<WindowProxy>&& view, int detail, RefPtr<EventTarget>&& relatedTarget)
>+    : UIEvent(type, canBubble, isCancelable, IsComposed::Yes, WTFMove(view), detail)
>     , m_relatedTarget(WTFMove(relatedTarget))
> {
> }
> 
>-FocusEvent::FocusEvent(const AtomicString& type, const Init& initializer, IsTrusted isTrusted)
>-    : UIEvent(type, initializer, isTrusted)
>+FocusEvent::FocusEvent(const AtomicString& type, const Init& initializer)
>+    : UIEvent(type, initializer)
>     , m_relatedTarget(initializer.relatedTarget)
> {
> }
>Index: Source/WebCore/dom/FocusEvent.h
>===================================================================
>--- Source/WebCore/dom/FocusEvent.h	(revision 235200)
>+++ Source/WebCore/dom/FocusEvent.h	(working copy)
>@@ -49,9 +49,9 @@ public:
>         RefPtr<EventTarget> relatedTarget;
>     };
> 
>-    static Ref<FocusEvent> create(const AtomicString& type, const Init& initializer, IsTrusted isTrusted = IsTrusted::No)
>+    static Ref<FocusEvent> create(const AtomicString& type, const Init& initializer)
>     {
>-        return adoptRef(*new FocusEvent(type, initializer, isTrusted));
>+        return adoptRef(*new FocusEvent(type, initializer));
>     }
> 
>     EventTarget* relatedTarget() const final { return m_relatedTarget.get(); }
>@@ -59,7 +59,7 @@ public:
> private:
>     FocusEvent() = default;
>     FocusEvent(const AtomicString& type, CanBubble, IsCancelable, RefPtr<WindowProxy>&&, int, RefPtr<EventTarget>&&);
>-    FocusEvent(const AtomicString& type, const Init&, IsTrusted);
>+    FocusEvent(const AtomicString& type, const Init&);
> 
>     EventInterface eventInterface() const final;
>     bool isFocusEvent() const final;
>Index: Source/WebCore/dom/InputEvent.cpp
>===================================================================
>--- Source/WebCore/dom/InputEvent.cpp	(revision 235200)
>+++ Source/WebCore/dom/InputEvent.cpp	(working copy)
>@@ -33,13 +33,13 @@
> 
> namespace WebCore {
> 
>-Ref<InputEvent> InputEvent::create(const AtomicString& eventType, const String& inputType, CanBubble canBubble, IsCancelable cancelable, RefPtr<WindowProxy>&& view, const String& data, RefPtr<DataTransfer>&& dataTransfer, const Vector<RefPtr<StaticRange>>& targetRanges, int detail)
>+Ref<InputEvent> InputEvent::create(const AtomicString& eventType, const String& inputType, IsCancelable cancelable, RefPtr<WindowProxy>&& view, const String& data, RefPtr<DataTransfer>&& dataTransfer, const Vector<RefPtr<StaticRange>>& targetRanges, int detail)
> {
>-    return adoptRef(*new InputEvent(eventType, inputType, canBubble, cancelable, WTFMove(view), data, WTFMove(dataTransfer), targetRanges, detail));
>+    return adoptRef(*new InputEvent(eventType, inputType, cancelable, WTFMove(view), data, WTFMove(dataTransfer), targetRanges, detail));
> }
> 
>-InputEvent::InputEvent(const AtomicString& eventType, const String& inputType, CanBubble canBubble, IsCancelable cancelable, RefPtr<WindowProxy>&& view, const String& data, RefPtr<DataTransfer>&& dataTransfer, const Vector<RefPtr<StaticRange>>& targetRanges, int detail)
>-    : UIEvent(eventType, canBubble, cancelable, WTFMove(view), detail)
>+InputEvent::InputEvent(const AtomicString& eventType, const String& inputType, IsCancelable cancelable, RefPtr<WindowProxy>&& view, const String& data, RefPtr<DataTransfer>&& dataTransfer, const Vector<RefPtr<StaticRange>>& targetRanges, int detail)
>+    : UIEvent(eventType, CanBubble::Yes, cancelable, IsComposed::Yes, WTFMove(view), detail)
>     , m_inputType(inputType)
>     , m_data(data)
>     , m_dataTransfer(dataTransfer)
>@@ -47,8 +47,8 @@ InputEvent::InputEvent(const AtomicStrin
> {
> }
> 
>-InputEvent::InputEvent(const AtomicString& eventType, const Init& initializer, IsTrusted isTrusted)
>-    : UIEvent(eventType, initializer, isTrusted)
>+InputEvent::InputEvent(const AtomicString& eventType, const Init& initializer)
>+    : UIEvent(eventType, initializer)
>     , m_inputType(emptyString())
>     , m_data(initializer.data)
> {
>Index: Source/WebCore/dom/InputEvent.h
>===================================================================
>--- Source/WebCore/dom/InputEvent.h	(revision 235200)
>+++ Source/WebCore/dom/InputEvent.h	(working copy)
>@@ -39,17 +39,14 @@ public:
>         String data;
>     };
> 
>-    static Ref<InputEvent> create(const AtomicString& eventType, const String& inputType, CanBubble, IsCancelable, RefPtr<WindowProxy>&& view,
>+    static Ref<InputEvent> create(const AtomicString& eventType, const String& inputType, IsCancelable, RefPtr<WindowProxy>&& view,
>         const String& data, RefPtr<DataTransfer>&&, const Vector<RefPtr<StaticRange>>& targetRanges, int detail);
> 
>-    static Ref<InputEvent> create(const AtomicString& type, const Init& initializer, IsTrusted isTrusted = IsTrusted::No)
>+    static Ref<InputEvent> create(const AtomicString& type, const Init& initializer)
>     {
>-        return adoptRef(*new InputEvent(type, initializer, isTrusted));
>+        return adoptRef(*new InputEvent(type, initializer));
>     }
> 
>-    InputEvent(const AtomicString& eventType, const String& inputType, CanBubble, IsCancelable, RefPtr<WindowProxy>&&, const String& data, RefPtr<DataTransfer>&&, const Vector<RefPtr<StaticRange>>& targetRanges, int detail);
>-    InputEvent(const AtomicString& eventType, const Init&, IsTrusted);
>-
>     bool isInputEvent() const override { return true; }
>     EventInterface eventInterface() const final { return InputEventInterfaceType; }
>     const String& inputType() const { return m_inputType; }
>@@ -58,6 +55,9 @@ public:
>     const Vector<RefPtr<StaticRange>>& getTargetRanges() { return m_targetRanges; }
> 
> private:
>+    InputEvent(const AtomicString& eventType, const String& inputType, IsCancelable, RefPtr<WindowProxy>&&, const String& data, RefPtr<DataTransfer>&&, const Vector<RefPtr<StaticRange>>& targetRanges, int detail);
>+    InputEvent(const AtomicString& eventType, const Init&);
>+
>     String m_inputType;
>     String m_data;
>     RefPtr<DataTransfer> m_dataTransfer;
>Index: Source/WebCore/dom/KeyboardEvent.cpp
>===================================================================
>--- Source/WebCore/dom/KeyboardEvent.cpp	(revision 235200)
>+++ Source/WebCore/dom/KeyboardEvent.cpp	(working copy)
>@@ -94,7 +94,7 @@ static inline KeyboardEvent::KeyLocation
> inline KeyboardEvent::KeyboardEvent() = default;
> 
> inline KeyboardEvent::KeyboardEvent(const PlatformKeyboardEvent& key, RefPtr<WindowProxy>&& view)
>-    : UIEventWithKeyState(eventTypeForKeyboardEventType(key.type()), CanBubble::Yes, IsCancelable::Yes,
>+    : UIEventWithKeyState(eventTypeForKeyboardEventType(key.type()), CanBubble::Yes, IsCancelable::Yes, IsComposed::Yes,
>         key.timestamp().approximateMonotonicTime(), view.copyRef(), 0, key.modifiers())
>     , m_underlyingPlatformEvent(std::make_unique<PlatformKeyboardEvent>(key))
> #if ENABLE(KEYBOARD_KEY_ATTRIBUTE)
>@@ -114,8 +114,8 @@ inline KeyboardEvent::KeyboardEvent(cons
> {
> }
> 
>-inline KeyboardEvent::KeyboardEvent(const AtomicString& eventType, const Init& initializer, IsTrusted isTrusted)
>-    : UIEventWithKeyState(eventType, initializer, isTrusted)
>+inline KeyboardEvent::KeyboardEvent(const AtomicString& eventType, const Init& initializer)
>+    : UIEventWithKeyState(eventType, initializer)
> #if ENABLE(KEYBOARD_KEY_ATTRIBUTE)
>     , m_key(initializer.key)
> #endif
>@@ -144,9 +144,9 @@ Ref<KeyboardEvent> KeyboardEvent::create
>     return adoptRef(*new KeyboardEvent);
> }
> 
>-Ref<KeyboardEvent> KeyboardEvent::create(const AtomicString& type, const Init& initializer, IsTrusted isTrusted)
>+Ref<KeyboardEvent> KeyboardEvent::create(const AtomicString& type, const Init& initializer)
> {
>-    return adoptRef(*new KeyboardEvent(type, initializer, isTrusted));
>+    return adoptRef(*new KeyboardEvent(type, initializer));
> }
> 
> void KeyboardEvent::initKeyboardEvent(const AtomicString& type, bool canBubble, bool cancelable, RefPtr<WindowProxy>&& view,
>Index: Source/WebCore/dom/KeyboardEvent.h
>===================================================================
>--- Source/WebCore/dom/KeyboardEvent.h	(revision 235200)
>+++ Source/WebCore/dom/KeyboardEvent.h	(working copy)
>@@ -61,7 +61,7 @@ public:
>         unsigned which;
>     };
> 
>-    static Ref<KeyboardEvent> create(const AtomicString& type, const Init&, IsTrusted = IsTrusted::No);
>+    static Ref<KeyboardEvent> create(const AtomicString& type, const Init&);
> 
>     virtual ~KeyboardEvent();
>     
>@@ -103,7 +103,7 @@ public:
> private:
>     KeyboardEvent();
>     KeyboardEvent(const PlatformKeyboardEvent&, RefPtr<WindowProxy>&&);
>-    KeyboardEvent(const AtomicString&, const Init&, IsTrusted);
>+    KeyboardEvent(const AtomicString&, const Init&);
> 
>     std::unique_ptr<PlatformKeyboardEvent> m_underlyingPlatformEvent;
> #if ENABLE(KEYBOARD_KEY_ATTRIBUTE)
>Index: Source/WebCore/dom/MouseEvent.cpp
>===================================================================
>--- Source/WebCore/dom/MouseEvent.cpp	(revision 235200)
>+++ Source/WebCore/dom/MouseEvent.cpp	(working copy)
>@@ -39,9 +39,9 @@ namespace WebCore {
> 
> using namespace JSC;
> 
>-Ref<MouseEvent> MouseEvent::create(const AtomicString& type, const MouseEventInit& initializer, IsTrusted isTrusted)
>+Ref<MouseEvent> MouseEvent::create(const AtomicString& type, const MouseEventInit& initializer)
> {
>-    return adoptRef(*new MouseEvent(type, initializer, isTrusted));
>+    return adoptRef(*new MouseEvent(type, initializer));
> }
> 
> Ref<MouseEvent> MouseEvent::create(const AtomicString& eventType, RefPtr<WindowProxy>&& view, const PlatformMouseEvent& event, int detail, Node* relatedTarget)
>@@ -50,7 +50,7 @@ Ref<MouseEvent> MouseEvent::create(const
>     auto isCancelable = eventType != eventNames().mousemoveEvent && !isMouseEnterOrLeave ? IsCancelable::Yes : IsCancelable::No;
>     auto canBubble = !isMouseEnterOrLeave ? CanBubble::Yes : CanBubble::No;
> 
>-    return MouseEvent::create(eventType, canBubble, isCancelable, event.timestamp().approximateMonotonicTime(), WTFMove(view), detail,
>+    return MouseEvent::create(eventType, canBubble, isCancelable, IsComposed::Yes, event.timestamp().approximateMonotonicTime(), WTFMove(view), detail,
>         event.globalPosition(), event.position(),
> #if ENABLE(POINTER_LOCK)
>         event.movementDelta(),
>@@ -60,27 +60,28 @@ Ref<MouseEvent> MouseEvent::create(const
>         event.modifiers(), event.button(), event.buttons(), relatedTarget, event.force(), event.syntheticClickType());
> }
> 
>-Ref<MouseEvent> MouseEvent::create(const AtomicString& type, CanBubble canBubble, IsCancelable cancelable, MonotonicTime timestamp, RefPtr<WindowProxy>&& view, int detail,
>+Ref<MouseEvent> MouseEvent::create(const AtomicString& type, CanBubble canBubble, IsCancelable isCancelable, IsComposed isComposed, MonotonicTime timestamp, RefPtr<WindowProxy>&& view, int detail,
>     const IntPoint& screenLocation, const IntPoint& windowLocation, const IntPoint& movementDelta, OptionSet<Modifier> modifiers, unsigned short button, unsigned short buttons,
>     EventTarget* relatedTarget, double force, unsigned short syntheticClickType, DataTransfer* dataTransfer, IsSimulated isSimulated)
> {
>-    return adoptRef(*new MouseEvent(type, canBubble, cancelable, timestamp, WTFMove(view), detail,
>+    return adoptRef(*new MouseEvent(type, canBubble, isCancelable, isComposed, timestamp, WTFMove(view), detail,
>         screenLocation, windowLocation, movementDelta, modifiers, button, buttons, relatedTarget, force, syntheticClickType, dataTransfer, isSimulated));
> }
> 
>-Ref<MouseEvent> MouseEvent::create(const AtomicString& eventType, CanBubble canBubble, IsCancelable cancelable, RefPtr<WindowProxy>&& view, int detail,
>+Ref<MouseEvent> MouseEvent::create(const AtomicString& eventType, CanBubble canBubble, IsCancelable isCancelable, IsComposed isComposed, RefPtr<WindowProxy>&& view, int detail,
>     int screenX, int screenY, int clientX, int clientY, OptionSet<Modifier> modifiers, unsigned short button, unsigned short buttons,
>     unsigned short syntheticClickType, EventTarget* relatedTarget)
> {
>-    return adoptRef(*new MouseEvent(eventType, canBubble, cancelable, WTFMove(view), detail, { screenX, screenY }, { clientX, clientY }, modifiers, button, buttons, syntheticClickType, relatedTarget));
>+    return adoptRef(*new MouseEvent(eventType, canBubble, isCancelable, isComposed, WTFMove(view), detail, { screenX, screenY }, { clientX, clientY }, modifiers, button, buttons, syntheticClickType, relatedTarget));
> }
> 
> MouseEvent::MouseEvent() = default;
> 
>-MouseEvent::MouseEvent(const AtomicString& eventType, CanBubble canBubble, IsCancelable cancelable, MonotonicTime timestamp, RefPtr<WindowProxy>&& view, int detail,
>+MouseEvent::MouseEvent(const AtomicString& eventType, CanBubble canBubble, IsCancelable isCancelable, IsComposed isComposed,
>+    MonotonicTime timestamp, RefPtr<WindowProxy>&& view, int detail,
>     const IntPoint& screenLocation, const IntPoint& windowLocation, const IntPoint& movementDelta, OptionSet<Modifier> modifiers, unsigned short button, unsigned short buttons,
>     EventTarget* relatedTarget, double force, unsigned short syntheticClickType, DataTransfer* dataTransfer, IsSimulated isSimulated)
>-    : MouseRelatedEvent(eventType, canBubble, cancelable, timestamp, WTFMove(view), detail, screenLocation, windowLocation, movementDelta, modifiers, isSimulated)
>+    : MouseRelatedEvent(eventType, canBubble, isCancelable, isComposed, timestamp, WTFMove(view), detail, screenLocation, windowLocation, movementDelta, modifiers, isSimulated)
>     , m_button(button == (unsigned short)-1 ? 0 : button)
>     , m_buttons(buttons)
>     , m_syntheticClickType(button == (unsigned short)-1 ? 0 : syntheticClickType)
>@@ -91,9 +92,10 @@ MouseEvent::MouseEvent(const AtomicStrin
> {
> }
> 
>-MouseEvent::MouseEvent(const AtomicString& eventType, CanBubble canBubble, IsCancelable cancelable, RefPtr<WindowProxy>&& view, int detail,
>-    const IntPoint& screenLocation, const IntPoint& clientLocation, OptionSet<Modifier> modifiers, unsigned short button, unsigned short buttons, unsigned short syntheticClickType, EventTarget* relatedTarget)
>-    : MouseRelatedEvent(eventType, canBubble, cancelable, MonotonicTime::now(), WTFMove(view), detail, screenLocation, { }, { }, modifiers, IsSimulated::No)
>+MouseEvent::MouseEvent(const AtomicString& eventType, CanBubble canBubble, IsCancelable isCancelable, IsComposed isComposed,
>+    RefPtr<WindowProxy>&& view, int detail, const IntPoint& screenLocation, const IntPoint& clientLocation,
>+    OptionSet<Modifier> modifiers, unsigned short button, unsigned short buttons, unsigned short syntheticClickType, EventTarget* relatedTarget)
>+    : MouseRelatedEvent(eventType, canBubble, isCancelable, isComposed, MonotonicTime::now(), WTFMove(view), detail, screenLocation, { }, { }, modifiers, IsSimulated::No)
>     , m_button(button == (unsigned short)-1 ? 0 : button)
>     , m_buttons(buttons)
>     , m_syntheticClickType(button == (unsigned short)-1 ? 0 : syntheticClickType)
>@@ -103,8 +105,8 @@ MouseEvent::MouseEvent(const AtomicStrin
>     initCoordinates(clientLocation);
> }
> 
>-MouseEvent::MouseEvent(const AtomicString& eventType, const MouseEventInit& initializer, IsTrusted isTrusted)
>-    : MouseRelatedEvent(eventType, initializer, isTrusted)
>+MouseEvent::MouseEvent(const AtomicString& eventType, const MouseEventInit& initializer)
>+    : MouseRelatedEvent(eventType, initializer)
>     , m_button(initializer.button == (unsigned short)-1 ? 0 : initializer.button)
>     , m_buttons(initializer.buttons)
>     , m_buttonDown(initializer.button != (unsigned short)-1)
>Index: Source/WebCore/dom/MouseEvent.h
>===================================================================
>--- Source/WebCore/dom/MouseEvent.h	(revision 235200)
>+++ Source/WebCore/dom/MouseEvent.h	(working copy)
>@@ -34,19 +34,19 @@ class PlatformMouseEvent;
> 
> class MouseEvent : public MouseRelatedEvent {
> public:
>-    WEBCORE_EXPORT static Ref<MouseEvent> create(const AtomicString& type, CanBubble, IsCancelable, MonotonicTime timestamp, RefPtr<WindowProxy>&&, int detail,
>+    WEBCORE_EXPORT static Ref<MouseEvent> create(const AtomicString& type, CanBubble, IsCancelable, IsComposed, MonotonicTime timestamp, RefPtr<WindowProxy>&&, int detail,
>         const IntPoint& screenLocation, const IntPoint& windowLocation, const IntPoint& movementDelta, OptionSet<Modifier>, unsigned short button, unsigned short buttons,
>         EventTarget* relatedTarget, double force, unsigned short syntheticClickType, DataTransfer* = nullptr, IsSimulated = IsSimulated::No);
> 
>     WEBCORE_EXPORT static Ref<MouseEvent> create(const AtomicString& eventType, RefPtr<WindowProxy>&&, const PlatformMouseEvent&, int detail, Node* relatedTarget);
> 
>-    static Ref<MouseEvent> create(const AtomicString& eventType, CanBubble, IsCancelable, RefPtr<WindowProxy>&&,
>-        int detail, int screenX, int screenY, int clientX, int clientY, OptionSet<Modifier>,
>-        unsigned short button, unsigned short buttons, unsigned short syntheticClickType, EventTarget* relatedTarget);
>+    static Ref<MouseEvent> create(const AtomicString& eventType, CanBubble, IsCancelable, IsComposed, RefPtr<WindowProxy>&&, int detail,
>+        int screenX, int screenY, int clientX, int clientY, OptionSet<Modifier>, unsigned short button, unsigned short buttons,
>+        unsigned short syntheticClickType, EventTarget* relatedTarget);
> 
>     static Ref<MouseEvent> createForBindings() { return adoptRef(*new MouseEvent); }
> 
>-    static Ref<MouseEvent> create(const AtomicString& eventType, const MouseEventInit&, IsTrusted = IsTrusted::No);
>+    static Ref<MouseEvent> create(const AtomicString& eventType, const MouseEventInit&);
> 
>     virtual ~MouseEvent();
> 
>@@ -76,15 +76,15 @@ public:
>     int which() const final;
> 
> protected:
>-    MouseEvent(const AtomicString& type, CanBubble, IsCancelable, MonotonicTime timestamp, RefPtr<WindowProxy>&&, int detail,
>+    MouseEvent(const AtomicString& type, CanBubble, IsCancelable, IsComposed, MonotonicTime timestamp, RefPtr<WindowProxy>&&, int detail,
>         const IntPoint& screenLocation, const IntPoint& windowLocation, const IntPoint& movementDelta, OptionSet<Modifier>, unsigned short button, unsigned short buttons,
>         EventTarget* relatedTarget, double force, unsigned short syntheticClickType, DataTransfer*, IsSimulated);
> 
>-    MouseEvent(const AtomicString& type, CanBubble, IsCancelable, RefPtr<WindowProxy>&&,
>-        int detail, const IntPoint& screenLocation, const IntPoint& clientLocation,
>-        OptionSet<Modifier>, unsigned short button, unsigned short buttons, unsigned short syntheticClickType, EventTarget* relatedTarget);
>+    MouseEvent(const AtomicString& type, CanBubble, IsCancelable, IsComposed, RefPtr<WindowProxy>&&, int detail,
>+        const IntPoint& screenLocation, const IntPoint& clientLocation, OptionSet<Modifier>, unsigned short button, unsigned short buttons,
>+        unsigned short syntheticClickType, EventTarget* relatedTarget);
> 
>-    MouseEvent(const AtomicString& type, const MouseEventInit&, IsTrusted);
>+    MouseEvent(const AtomicString& type, const MouseEventInit&);
> 
>     MouseEvent();
> 
>Index: Source/WebCore/dom/MouseRelatedEvent.cpp
>===================================================================
>--- Source/WebCore/dom/MouseRelatedEvent.cpp	(revision 235200)
>+++ Source/WebCore/dom/MouseRelatedEvent.cpp	(working copy)
>@@ -33,9 +33,10 @@
> 
> namespace WebCore {
> 
>-MouseRelatedEvent::MouseRelatedEvent(const AtomicString& eventType, CanBubble canBubble, IsCancelable isCancelable, MonotonicTime timestamp, RefPtr<WindowProxy>&& view, int detail,
>+MouseRelatedEvent::MouseRelatedEvent(const AtomicString& eventType, CanBubble canBubble, IsCancelable isCancelable, IsComposed isComposed,
>+    MonotonicTime timestamp, RefPtr<WindowProxy>&& view, int detail,
>     const IntPoint& screenLocation, const IntPoint& windowLocation, const IntPoint& movementDelta, OptionSet<Modifier> modifiers, IsSimulated isSimulated)
>-    : UIEventWithKeyState(eventType, canBubble, isCancelable, timestamp, WTFMove(view), detail, modifiers)
>+    : UIEventWithKeyState(eventType, canBubble, isCancelable, isComposed, timestamp, WTFMove(view), detail, modifiers)
>     , m_screenLocation(screenLocation)
> #if ENABLE(POINTER_LOCK)
>     , m_movementDelta(movementDelta)
>@@ -49,17 +50,19 @@ MouseRelatedEvent::MouseRelatedEvent(con
> }
> 
> MouseRelatedEvent::MouseRelatedEvent(const AtomicString& type, IsCancelable isCancelable, MonotonicTime timestamp, RefPtr<WindowProxy>&& view, const IntPoint& globalLocation, OptionSet<Modifier> modifiers)
>-    : MouseRelatedEvent(type, CanBubble::Yes, isCancelable, timestamp, WTFMove(view), 0, globalLocation, globalLocation /* Converted in init */, { }, modifiers, IsSimulated::No)
>+    : MouseRelatedEvent(type, CanBubble::Yes, isCancelable, IsComposed::Yes, timestamp,
>+        WTFMove(view), 0, globalLocation, globalLocation /* Converted in init */, { }, modifiers, IsSimulated::No)
> {
> }
> 
> MouseRelatedEvent::MouseRelatedEvent(const AtomicString& eventType, const MouseRelatedEventInit& initializer, IsTrusted isTrusted)
>-    : UIEventWithKeyState(eventType, initializer, isTrusted)
>+    : UIEventWithKeyState(eventType, initializer)
>     , m_screenLocation(IntPoint(initializer.screenX, initializer.screenY))
> #if ENABLE(POINTER_LOCK)
>     , m_movementDelta(IntPoint(0, 0))
> #endif
> {
>+    ASSERT_UNUSED(isTrusted, isTrusted == IsTrusted::No);
>     init(false, IntPoint(0, 0));
> }
> 
>Index: Source/WebCore/dom/MouseRelatedEvent.h
>===================================================================
>--- Source/WebCore/dom/MouseRelatedEvent.h	(revision 235200)
>+++ Source/WebCore/dom/MouseRelatedEvent.h	(working copy)
>@@ -76,7 +76,7 @@ public:
> 
> protected:
>     MouseRelatedEvent() = default;
>-    MouseRelatedEvent(const AtomicString& type, CanBubble, IsCancelable, MonotonicTime, RefPtr<WindowProxy>&&, int detail,
>+    MouseRelatedEvent(const AtomicString& type, CanBubble, IsCancelable, IsComposed, MonotonicTime, RefPtr<WindowProxy>&&, int detail,
>         const IntPoint& screenLocation, const IntPoint& windowLocation, const IntPoint& movementDelta, OptionSet<Modifier> modifiers, IsSimulated = IsSimulated::No);
>     MouseRelatedEvent(const AtomicString& type, IsCancelable, MonotonicTime, RefPtr<WindowProxy>&&, const IntPoint& globalLocation, OptionSet<Modifier>);
>     MouseRelatedEvent(const AtomicString& type, const MouseRelatedEventInit&, IsTrusted = IsTrusted::No);
>Index: Source/WebCore/dom/Node.cpp
>===================================================================
>--- Source/WebCore/dom/Node.cpp	(revision 235200)
>+++ Source/WebCore/dom/Node.cpp	(working copy)
>@@ -2349,7 +2349,7 @@ void Node::dispatchDOMActivateEvent(Even
> {
>     ASSERT_WITH_SECURITY_IMPLICATION(ScriptDisallowedScope::InMainThread::isScriptAllowed());
>     int detail = is<UIEvent>(underlyingClickEvent) ? downcast<UIEvent>(underlyingClickEvent).detail() : 0;
>-    auto event = UIEvent::create(eventNames().DOMActivateEvent, Event::CanBubble::Yes, Event::IsCancelable::Yes, document().windowProxy(), detail);
>+    auto event = UIEvent::create(eventNames().DOMActivateEvent, Event::CanBubble::Yes, Event::IsCancelable::Yes, Event::IsComposed::Yes, document().windowProxy(), detail);
>     event->setUnderlyingEvent(&underlyingClickEvent);
>     dispatchScopedEvent(event);
>     if (event->defaultHandled())
>@@ -2369,7 +2369,7 @@ bool Node::dispatchBeforeLoadEvent(const
> 
> void Node::dispatchInputEvent()
> {
>-    dispatchScopedEvent(Event::create(eventNames().inputEvent, Event::CanBubble::Yes, Event::IsCancelable::No));
>+    dispatchScopedEvent(Event::create(eventNames().inputEvent, Event::CanBubble::Yes, Event::IsCancelable::No, Event::IsComposed::Yes));
> }
> 
> void Node::defaultEventHandler(Event& event)
>Index: Source/WebCore/dom/SimulatedClick.cpp
>===================================================================
>--- Source/WebCore/dom/SimulatedClick.cpp	(revision 235200)
>+++ Source/WebCore/dom/SimulatedClick.cpp	(working copy)
>@@ -44,7 +44,8 @@ public:
> 
> private:
>     SimulatedMouseEvent(const AtomicString& eventType, RefPtr<WindowProxy>&& view, RefPtr<Event>&& underlyingEvent, Element& target, SimulatedClickSource source)
>-        : MouseEvent(eventType, CanBubble::Yes, IsCancelable::Yes, underlyingEvent ? underlyingEvent->timeStamp() : MonotonicTime::now(), WTFMove(view), /* detail */ 0,
>+        : MouseEvent(eventType, CanBubble::Yes, IsCancelable::Yes, source == SimulatedClickSource::Bindings ? IsComposed::No : IsComposed::Yes,
>+            underlyingEvent ? underlyingEvent->timeStamp() : MonotonicTime::now(), WTFMove(view), /* detail */ 0,
>             { }, { }, { }, modifiersFromUnderlyingEvent(underlyingEvent), 0, 0, nullptr, 0, 0, nullptr, IsSimulated::Yes)
>     {
>         if (source == SimulatedClickSource::Bindings)
>Index: Source/WebCore/dom/TextEvent.cpp
>===================================================================
>--- Source/WebCore/dom/TextEvent.cpp	(revision 235200)
>+++ Source/WebCore/dom/TextEvent.cpp	(working copy)
>@@ -72,7 +72,7 @@ TextEvent::TextEvent()
> }
> 
> TextEvent::TextEvent(RefPtr<WindowProxy>&& view, const String& data, TextEventInputType inputType)
>-    : UIEvent(eventNames().textInputEvent, CanBubble::Yes, IsCancelable::Yes, WTFMove(view), 0)
>+    : UIEvent(eventNames().textInputEvent, CanBubble::Yes, IsCancelable::Yes, IsComposed::Yes, WTFMove(view), 0)
>     , m_inputType(inputType)
>     , m_data(data)
>     , m_shouldSmartReplace(false)
>@@ -82,7 +82,7 @@ TextEvent::TextEvent(RefPtr<WindowProxy>
> }
> 
> TextEvent::TextEvent(RefPtr<WindowProxy>&& view, const String& data, RefPtr<DocumentFragment>&& pastingFragment, bool shouldSmartReplace, bool shouldMatchStyle, MailBlockquoteHandling mailBlockquoteHandling)
>-    : UIEvent(eventNames().textInputEvent, CanBubble::Yes, IsCancelable::Yes, WTFMove(view), 0)
>+    : UIEvent(eventNames().textInputEvent, CanBubble::Yes, IsCancelable::Yes, IsComposed::Yes, WTFMove(view), 0)
>     , m_inputType(TextEventInputPaste)
>     , m_data(data)
>     , m_pastingFragment(WTFMove(pastingFragment))
>@@ -93,7 +93,7 @@ TextEvent::TextEvent(RefPtr<WindowProxy>
> }
> 
> TextEvent::TextEvent(RefPtr<WindowProxy>&& view, const String& data, const Vector<DictationAlternative>& dictationAlternatives)
>-    : UIEvent(eventNames().textInputEvent, CanBubble::Yes, IsCancelable::Yes, WTFMove(view), 0)
>+    : UIEvent(eventNames().textInputEvent, CanBubble::Yes, IsCancelable::Yes, IsComposed::Yes, WTFMove(view), 0)
>     , m_inputType(TextEventInputDictation)
>     , m_data(data)
>     , m_shouldSmartReplace(false)
>Index: Source/WebCore/dom/UIEvent.cpp
>===================================================================
>--- Source/WebCore/dom/UIEvent.cpp	(revision 235200)
>+++ Source/WebCore/dom/UIEvent.cpp	(working copy)
>@@ -32,22 +32,22 @@ UIEvent::UIEvent()
> {
> }
> 
>-UIEvent::UIEvent(const AtomicString& eventType, CanBubble canBubble, IsCancelable cancelable, RefPtr<WindowProxy>&& viewArg, int detailArg)
>-    : Event(eventType, canBubble, cancelable)
>+UIEvent::UIEvent(const AtomicString& eventType, CanBubble canBubble, IsCancelable isCancelable, IsComposed isComposed, RefPtr<WindowProxy>&& viewArg, int detailArg)
>+    : Event(eventType, canBubble, isCancelable, isComposed)
>     , m_view(WTFMove(viewArg))
>     , m_detail(detailArg)
> {
> }
> 
>-UIEvent::UIEvent(const AtomicString& eventType, CanBubble canBubble, IsCancelable cancelable, MonotonicTime timestamp, RefPtr<WindowProxy>&& viewArg, int detailArg)
>-    : Event(eventType, canBubble, cancelable, timestamp)
>+UIEvent::UIEvent(const AtomicString& eventType, CanBubble canBubble, IsCancelable isCancelable, IsComposed isComposed, MonotonicTime timestamp, RefPtr<WindowProxy>&& viewArg, int detailArg)
>+    : Event(eventType, canBubble, isCancelable, isComposed, timestamp)
>     , m_view(WTFMove(viewArg))
>     , m_detail(detailArg)
> {
> }
> 
>-UIEvent::UIEvent(const AtomicString& eventType, const UIEventInit& initializer, IsTrusted isTrusted)
>-    : Event(eventType, initializer, isTrusted)
>+UIEvent::UIEvent(const AtomicString& eventType, const UIEventInit& initializer)
>+    : Event(eventType, initializer, IsTrusted::No)
>     , m_view(initializer.view.get())
>     , m_detail(initializer.detail)
> {
>Index: Source/WebCore/dom/UIEvent.h
>===================================================================
>--- Source/WebCore/dom/UIEvent.h	(revision 235200)
>+++ Source/WebCore/dom/UIEvent.h	(working copy)
>@@ -34,17 +34,17 @@ typedef WindowProxy AbstractView;
> 
> class UIEvent : public Event {
> public:
>-    static Ref<UIEvent> create(const AtomicString& type, CanBubble canBubble, IsCancelable cancelable, RefPtr<WindowProxy>&& view, int detail)
>+    static Ref<UIEvent> create(const AtomicString& type, CanBubble canBubble, IsCancelable isCancelable, IsComposed isComposed, RefPtr<WindowProxy>&& view, int detail)
>     {
>-        return adoptRef(*new UIEvent(type, canBubble, cancelable, WTFMove(view), detail));
>+        return adoptRef(*new UIEvent(type, canBubble, isCancelable, isComposed, WTFMove(view), detail));
>     }
>     static Ref<UIEvent> createForBindings()
>     {
>         return adoptRef(*new UIEvent);
>     }
>-    static Ref<UIEvent> create(const AtomicString& type, const UIEventInit& initializer, IsTrusted isTrusted = IsTrusted::No)
>+    static Ref<UIEvent> create(const AtomicString& type, const UIEventInit& initializer)
>     {
>-        return adoptRef(*new UIEvent(type, initializer, isTrusted));
>+        return adoptRef(*new UIEvent(type, initializer));
>     }
>     virtual ~UIEvent();
> 
>@@ -65,9 +65,10 @@ public:
> 
> protected:
>     UIEvent();
>-    UIEvent(const AtomicString& type, CanBubble, IsCancelable, RefPtr<WindowProxy>&&, int detail);
>-    UIEvent(const AtomicString& type, CanBubble, IsCancelable, MonotonicTime timestamp, RefPtr<WindowProxy>&&, int detail);
>-    UIEvent(const AtomicString&, const UIEventInit&, IsTrusted);
>+
>+    UIEvent(const AtomicString& type, CanBubble, IsCancelable, IsComposed, RefPtr<WindowProxy>&&, int detail);
>+    UIEvent(const AtomicString& type, CanBubble, IsCancelable, IsComposed, MonotonicTime timestamp, RefPtr<WindowProxy>&&, int detail);
>+    UIEvent(const AtomicString&, const UIEventInit&);
> 
> private:
>     bool isUIEvent() const final;
>Index: Source/WebCore/dom/UIEventWithKeyState.h
>===================================================================
>--- Source/WebCore/dom/UIEventWithKeyState.h	(revision 235200)
>+++ Source/WebCore/dom/UIEventWithKeyState.h	(working copy)
>@@ -45,20 +45,22 @@ public:
> protected:
>     UIEventWithKeyState() = default;
> 
>-    UIEventWithKeyState(const AtomicString& type, CanBubble canBubble, IsCancelable cancelable, RefPtr<WindowProxy>&& view, int detail, OptionSet<Modifier> modifiers)
>-        : UIEvent(type, canBubble, cancelable, WTFMove(view), detail)
>+    UIEventWithKeyState(const AtomicString& type, CanBubble canBubble, IsCancelable cancelable, IsComposed isComposed,
>+        RefPtr<WindowProxy>&& view, int detail, OptionSet<Modifier> modifiers)
>+        : UIEvent(type, canBubble, cancelable, isComposed, WTFMove(view), detail)
>         , m_modifiers(modifiers)
>     {
>     }
> 
>-    UIEventWithKeyState(const AtomicString& type, CanBubble canBubble, IsCancelable cancelable, MonotonicTime timestamp, RefPtr<WindowProxy>&& view, int detail, OptionSet<Modifier> modifiers)
>-        : UIEvent(type, canBubble, cancelable, timestamp, WTFMove(view), detail)
>+    UIEventWithKeyState(const AtomicString& type, CanBubble canBubble, IsCancelable cancelable, IsComposed isComposed,
>+        MonotonicTime timestamp, RefPtr<WindowProxy>&& view, int detail, OptionSet<Modifier> modifiers)
>+        : UIEvent(type, canBubble, cancelable, isComposed, timestamp, WTFMove(view), detail)
>         , m_modifiers(modifiers)
>     {
>     }
> 
>-    UIEventWithKeyState(const AtomicString& type, const EventModifierInit& initializer, IsTrusted isTrusted)
>-        : UIEvent(type, initializer, isTrusted)
>+    UIEventWithKeyState(const AtomicString& type, const EventModifierInit& initializer)
>+        : UIEvent(type, initializer)
>         , m_modifiers(modifiersFromInitializer(initializer))
>     {
>     }
>Index: Source/WebCore/dom/WheelEvent.cpp
>===================================================================
>--- Source/WebCore/dom/WheelEvent.cpp	(revision 235200)
>+++ Source/WebCore/dom/WheelEvent.cpp	(working copy)
>@@ -37,8 +37,8 @@ inline static unsigned determineDeltaMod
> 
> inline WheelEvent::WheelEvent() = default;
> 
>-inline WheelEvent::WheelEvent(const AtomicString& type, const Init& initializer, IsTrusted isTrusted)
>-    : MouseEvent(type, initializer, isTrusted)
>+inline WheelEvent::WheelEvent(const AtomicString& type, const Init& initializer)
>+    : MouseEvent(type, initializer)
>     , m_wheelDelta(initializer.wheelDeltaX ? initializer.wheelDeltaX : -initializer.deltaX, initializer.wheelDeltaY ? initializer.wheelDeltaY : -initializer.deltaY)
>     , m_deltaX(initializer.deltaX ? initializer.deltaX : -initializer.wheelDeltaX)
>     , m_deltaY(initializer.deltaY ? initializer.deltaY : -initializer.wheelDeltaY)
>@@ -48,7 +48,7 @@ inline WheelEvent::WheelEvent(const Atom
> }
> 
> inline WheelEvent::WheelEvent(const PlatformWheelEvent& event, RefPtr<WindowProxy>&& view)
>-    : MouseEvent(eventNames().wheelEvent, CanBubble::Yes, IsCancelable::Yes, event.timestamp().approximateMonotonicTime(), WTFMove(view), 0, event.globalPosition(), event.position() , { }
>+    : MouseEvent(eventNames().wheelEvent, CanBubble::Yes, IsCancelable::Yes, IsComposed::Yes, event.timestamp().approximateMonotonicTime(), WTFMove(view), 0, event.globalPosition(), event.position() , { }
>         , event.modifiers(), 0, 0, nullptr, 0, 0, nullptr, IsSimulated::No)
>     , m_wheelDelta(event.wheelTicksX() * TickMultiplier, event.wheelTicksY() * TickMultiplier)
>     , m_deltaX(-event.deltaX())
>@@ -68,9 +68,9 @@ Ref<WheelEvent> WheelEvent::createForBin
>     return adoptRef(*new WheelEvent);
> }
> 
>-Ref<WheelEvent> WheelEvent::create(const AtomicString& type, const Init& initializer, IsTrusted isTrusted)
>+Ref<WheelEvent> WheelEvent::create(const AtomicString& type, const Init& initializer)
> {
>-    return adoptRef(*new WheelEvent(type, initializer, isTrusted));
>+    return adoptRef(*new WheelEvent(type, initializer));
> }
> 
> void WheelEvent::initWebKitWheelEvent(int rawDeltaX, int rawDeltaY, RefPtr<WindowProxy>&& view, int screenX, int screenY, int pageX, int pageY, bool ctrlKey, bool altKey, bool shiftKey, bool metaKey)
>Index: Source/WebCore/dom/WheelEvent.h
>===================================================================
>--- Source/WebCore/dom/WheelEvent.h	(revision 235200)
>+++ Source/WebCore/dom/WheelEvent.h	(working copy)
>@@ -51,7 +51,7 @@ public:
>         int wheelDeltaY { 0 }; // Deprecated.
>     };
> 
>-    static Ref<WheelEvent> create(const AtomicString& type, const Init&, IsTrusted = IsTrusted::No);
>+    static Ref<WheelEvent> create(const AtomicString& type, const Init&);
> 
>     WEBCORE_EXPORT void initWebKitWheelEvent(int rawDeltaX, int rawDeltaY, RefPtr<WindowProxy>&&, int screenX, int screenY, int pageX, int pageY, bool ctrlKey, bool altKey, bool shiftKey, bool metaKey);
> 
>@@ -74,7 +74,7 @@ public:
> 
> private:
>     WheelEvent();
>-    WheelEvent(const AtomicString&, const Init&, IsTrusted);
>+    WheelEvent(const AtomicString&, const Init&);
>     WheelEvent(const PlatformWheelEvent&, RefPtr<WindowProxy>&&);
> 
>     EventInterface eventInterface() const final;
>Index: Source/WebCore/editing/Editor.cpp
>===================================================================
>--- Source/WebCore/editing/Editor.cpp	(revision 235200)
>+++ Source/WebCore/editing/Editor.cpp	(working copy)
>@@ -115,7 +115,7 @@ static bool dispatchBeforeInputEvent(Ele
>     if (!element.document().settings().inputEventsEnabled())
>         return true;
> 
>-    auto event = InputEvent::create(eventNames().beforeinputEvent, inputType, Event::CanBubble::Yes, cancelable, element.document().windowProxy(), data, WTFMove(dataTransfer), targetRanges, 0);
>+    auto event = InputEvent::create(eventNames().beforeinputEvent, inputType, cancelable, element.document().windowProxy(), data, WTFMove(dataTransfer), targetRanges, 0);
>     element.dispatchEvent(event);
>     return !event->defaultPrevented();
> }
>@@ -127,7 +127,7 @@ static void dispatchInputEvent(Element& 
>         // but TypingCommands are special in that existing TypingCommands that are applied again fire input events *from within* the scope by calling typingAddedToOpenCommand.
>         // Instead, TypingCommands should always dispatch events synchronously after the end of the scoped queue in CompositeEditCommand::apply. To work around this for the
>         // time being, just revert back to calling dispatchScopedEvent.
>-        element.dispatchScopedEvent(InputEvent::create(eventNames().inputEvent, inputType, Event::CanBubble::Yes, Event::IsCancelable::No,
>+        element.dispatchScopedEvent(InputEvent::create(eventNames().inputEvent, inputType, Event::IsCancelable::No,
>             element.document().windowProxy(), data, WTFMove(dataTransfer), targetRanges, 0));
>     } else
>         element.dispatchInputEvent();
>@@ -390,11 +390,7 @@ static bool dispatchClipboardEvent(RefPt
> 
>     auto dataTransfer = createDataTransferForClipboardEvent(target->document(), kind);
> 
>-    ClipboardEvent::Init init;
>-    init.bubbles = true;
>-    init.cancelable = true;
>-    init.clipboardData = dataTransfer.ptr();
>-    auto event = ClipboardEvent::create(eventNameForClipboardEvent(kind), init, Event::IsTrusted::Yes);
>+    auto event = ClipboardEvent::create(eventNameForClipboardEvent(kind), dataTransfer.copyRef());
> 
>     target->dispatchEvent(event);
>     bool noDefaultProcessing = event->defaultPrevented();
>Index: Source/WebCore/page/EventHandler.cpp
>===================================================================
>--- Source/WebCore/page/EventHandler.cpp	(revision 235200)
>+++ Source/WebCore/page/EventHandler.cpp	(working copy)
>@@ -2214,7 +2214,8 @@ bool EventHandler::dispatchDragEvent(con
> 
>     view->disableLayerFlushThrottlingTemporarilyForInteraction();
>     // FIXME: Use MouseEvent::create which takes PlatformMouseEvent.
>-    Ref<MouseEvent> me = MouseEvent::create(eventType, Event::CanBubble::Yes, Event::IsCancelable::Yes, event.timestamp().approximateMonotonicTime(), &m_frame.windowProxy(), 0,
>+    Ref<MouseEvent> me = MouseEvent::create(eventType, Event::CanBubble::Yes, Event::IsCancelable::Yes, Event::IsComposed::Yes,
>+        event.timestamp().approximateMonotonicTime(), &m_frame.windowProxy(), 0,
>         event.globalPosition(), event.position(),
> #if ENABLE(POINTER_LOCK)
>         event.movementDelta(),
>Index: Source/WebKit/ChangeLog
>===================================================================
>--- Source/WebKit/ChangeLog	(revision 235269)
>+++ Source/WebKit/ChangeLog	(working copy)
>@@ -1,3 +1,15 @@
>+2018-08-23  Ryosuke Niwa  <rniwa@webkit.org>
>+
>+        Pass in IsComposed flag to Event constructors
>+        https://bugs.webkit.org/show_bug.cgi?id=188720
>+        <rdar://problem/43580387>
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        * WebProcess/WebPage/WebPage.cpp:
>+        (WebKit::WebPage::navigateToPDFLinkWithSimulatedClick): A trusted click event is composed regardless of
>+        whether it's simulated or not.
>+
> 2018-08-23  Tim Horton  <timothy_horton@apple.com>
> 
>         Use unified build for UIProcess
>Index: Source/WebKit/WebProcess/WebPage/WebPage.cpp
>===================================================================
>--- Source/WebKit/WebProcess/WebPage/WebPage.cpp	(revision 235200)
>+++ Source/WebKit/WebProcess/WebPage/WebPage.cpp	(working copy)
>@@ -1337,7 +1337,7 @@ void WebPage::navigateToPDFLinkWithSimul
>     const int singleClick = 1;
>     // FIXME: Set modifier keys.
>     // FIXME: This should probably set IsSimulated::Yes.
>-    RefPtr<MouseEvent> mouseEvent = MouseEvent::create(eventNames().clickEvent, Event::CanBubble::Yes, Event::IsCancelable::Yes,
>+    RefPtr<MouseEvent> mouseEvent = MouseEvent::create(eventNames().clickEvent, Event::CanBubble::Yes, Event::IsCancelable::Yes, Event::IsComposed::Yes,
>         MonotonicTime::now(), nullptr, singleClick, screenPoint, documentPoint, { }, { }, 0, 0, nullptr, 0, WebCore::NoTap, nullptr);
> 
>     mainFrame->loader().urlSelected(mainFrameDocument->completeURL(url), emptyString(), mouseEvent.get(), LockHistory::No, LockBackForwardList::No, ShouldSendReferrer::MaybeSendReferrer, ShouldOpenExternalURLsPolicy::ShouldNotAllow);
>Index: Source/WebKitLegacy/ios/ChangeLog
>===================================================================
>--- Source/WebKitLegacy/ios/ChangeLog	(revision 235200)
>+++ Source/WebKitLegacy/ios/ChangeLog	(working copy)
>@@ -1,3 +1,15 @@
>+2018-08-23  Ryosuke Niwa  <rniwa@webkit.org>
>+
>+        Pass in IsComposed flag to Event constructors
>+        https://bugs.webkit.org/show_bug.cgi?id=188720
>+        <rdar://problem/43580387>
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        * WebView/WebPDFViewPlaceholder.mm:
>+        (-[WebPDFViewPlaceholder simulateClickOnLinkToURL:]): A trusted click event is composed regardless
>+        of whether it's simulated or not.
>+
> 2018-08-21  Ryosuke Niwa  <rniwa@webkit.org>
> 
>         Replace booleans for modifier keys in UIEventWithKeyState with OptionSet<Modifier>
>Index: Source/WebKitLegacy/ios/WebView/WebPDFViewPlaceholder.mm
>===================================================================
>--- Source/WebKitLegacy/ios/WebView/WebPDFViewPlaceholder.mm	(revision 235200)
>+++ Source/WebKitLegacy/ios/WebView/WebPDFViewPlaceholder.mm	(working copy)
>@@ -478,9 +478,9 @@ - (void)simulateClickOnLinkToURL:(NSURL 
>     if (!URL)
>         return;
> 
>-    // Construct an event to simulate a click.
>-    RefPtr<Event> event = MouseEvent::create(eventNames().clickEvent, Event::CanBubble::Yes, Event::IsCancelable::Yes, MonotonicTime::now(), nullptr, 1,
>-        { }, { }, { }, { }, 0, 0, nullptr, 0, 0, nullptr, MouseEvent::IsSimulated::Yes);
>+    RefPtr<Event> event = MouseEvent::create(eventNames().clickEvent,
>+        Event::CanBubble::Yes, Event::IsCancelable::Yes, Event::IsCancelable::Yes, Event::IsComposed::Yes,
>+        MonotonicTime::now(), nullptr, 1, { }, { }, { }, { }, 0, 0, nullptr, 0, 0, nullptr, MouseEvent::IsSimulated::Yes);
> 
>     // Call to the frame loader because this is where our security checks are made.
>     Frame* frame = core([_dataSource webFrame]);
>Index: Source/WebKitLegacy/mac/ChangeLog
>===================================================================
>--- Source/WebKitLegacy/mac/ChangeLog	(revision 235200)
>+++ Source/WebKitLegacy/mac/ChangeLog	(working copy)
>@@ -1,3 +1,15 @@
>+2018-08-23  Ryosuke Niwa  <rniwa@webkit.org>
>+
>+        Pass in IsComposed flag to Event constructors
>+        https://bugs.webkit.org/show_bug.cgi?id=188720
>+        <rdar://problem/43580387>
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        * WebView/WebPDFView.mm:
>+        (-[WebPDFView PDFViewWillClickOnLink:withURL:]): A trusted click event is composed regardless of
>+        whether it's simulated or not.
>+
> 2018-08-21  Ryosuke Niwa  <rniwa@webkit.org>
> 
>         Replace booleans for modifier keys in UIEventWithKeyState with OptionSet<Modifier>
>Index: Source/WebKitLegacy/mac/WebView/WebPDFView.mm
>===================================================================
>--- Source/WebKitLegacy/mac/WebView/WebPDFView.mm	(revision 235200)
>+++ Source/WebKitLegacy/mac/WebView/WebPDFView.mm	(working copy)
>@@ -1031,8 +1031,9 @@ - (void)PDFViewWillClickOnLink:(PDFView 
>     }
>     if (button != noButton) {
>         // FIXME: Use createPlatformMouseEvent instead.
>-        event = MouseEvent::create(eventNames().clickEvent, Event::CanBubble::Yes, Event::IsCancelable::Yes, MonotonicTime::now(), nullptr, [nsEvent clickCount], { }, { }, { },
>-            modifiersForEvent(nsEvent), button, [NSEvent pressedMouseButtons], nullptr, WebCore::ForceAtClick, 0, nullptr, MouseEvent::IsSimulated::Yes);
>+        event = MouseEvent::create(eventNames().clickEvent, Event::CanBubble::Yes, Event::IsCancelable::Yes, Event::IsComposed::Yes,
>+            MonotonicTime::now(), nullptr, [nsEvent clickCount], { }, { }, { }, modifiersForEvent(nsEvent),
>+            button, [NSEvent pressedMouseButtons], nullptr, WebCore::ForceAtClick, 0, nullptr, MouseEvent::IsSimulated::Yes);
>     }
> 
>     // Call to the frame loader because this is where our security checks are made.

Actions: View | Formatted Diff | Diff

Attachments on bug 188720: 347439 | 347447 | 347910 | 347986 | 347990