Pass in IsComposed flag to Event constructors
authorrniwa@webkit.org <rniwa@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 24 Aug 2018 20:14:50 +0000 (20:14 +0000)
committerrniwa@webkit.org <rniwa@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 24 Aug 2018 20:14:50 +0000 (20:14 +0000)
https://bugs.webkit.org/show_bug.cgi?id=188720
<rdar://problem/43580387>

Reviewed by Simon Fraser.

Source/WebCore:

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.

Source/WebKit:

* WebProcess/WebPage/WebPage.cpp:
(WebKit::WebPage::navigateToPDFLinkWithSimulatedClick): A trusted click event is composed regardless of
whether it's simulated or not.

Source/WebKitLegacy/ios:

* WebView/WebPDFViewPlaceholder.mm:
(-[WebPDFViewPlaceholder simulateClickOnLinkToURL:]): A trusted click event is composed regardless
of whether it's simulated or not.

Source/WebKitLegacy/mac:

* WebView/WebPDFView.mm:
(-[WebPDFView PDFViewWillClickOnLink:withURL:]): A trusted click event is composed regardless of
whether it's simulated or not.

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@235331 268f45cc-cd09-0410-ab3c-d52691b4dbfc

34 files changed:
Source/WebCore/ChangeLog
Source/WebCore/dom/ClipboardEvent.cpp
Source/WebCore/dom/ClipboardEvent.h
Source/WebCore/dom/CompositionEvent.cpp
Source/WebCore/dom/CompositionEvent.h
Source/WebCore/dom/Element.cpp
Source/WebCore/dom/Event.cpp
Source/WebCore/dom/Event.h
Source/WebCore/dom/FocusEvent.cpp
Source/WebCore/dom/FocusEvent.h
Source/WebCore/dom/InputEvent.cpp
Source/WebCore/dom/InputEvent.h
Source/WebCore/dom/KeyboardEvent.cpp
Source/WebCore/dom/KeyboardEvent.h
Source/WebCore/dom/MouseEvent.cpp
Source/WebCore/dom/MouseEvent.h
Source/WebCore/dom/MouseRelatedEvent.cpp
Source/WebCore/dom/MouseRelatedEvent.h
Source/WebCore/dom/Node.cpp
Source/WebCore/dom/SimulatedClick.cpp
Source/WebCore/dom/TextEvent.cpp
Source/WebCore/dom/UIEvent.cpp
Source/WebCore/dom/UIEvent.h
Source/WebCore/dom/UIEventWithKeyState.h
Source/WebCore/dom/WheelEvent.cpp
Source/WebCore/dom/WheelEvent.h
Source/WebCore/editing/Editor.cpp
Source/WebCore/page/EventHandler.cpp
Source/WebKit/ChangeLog
Source/WebKit/WebProcess/WebPage/WebPage.cpp
Source/WebKitLegacy/ios/ChangeLog
Source/WebKitLegacy/ios/WebView/WebPDFViewPlaceholder.mm
Source/WebKitLegacy/mac/ChangeLog
Source/WebKitLegacy/mac/WebView/WebPDFView.mm

index 769fcc2..f0358cd 100644 (file)
@@ -1,5 +1,90 @@
 2018-08-24  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 Simon Fraser.
+
+        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-24  Ryosuke Niwa  <rniwa@webkit.org>
+
         Add getModifierState to MouseEvent
         https://bugs.webkit.org/show_bug.cgi?id=188913
         <rdar://problem/43668772>
index b9ae45d..3caadcf 100644 (file)
 
 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 c499355..7906be0 100644 (file)
@@ -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 b7125fc..1d04795 100644 (file)
@@ -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 3b1c46d..223b860 100644 (file)
@@ -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 d9cbf38..9481ce9 100644 (file)
@@ -292,7 +292,9 @@ bool Element::dispatchMouseEvent(const PlatformMouseEvent& platformEvent, const
         // 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 008417c..fa44644 100644 (file)
@@ -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& eventType, const EventInit& initializer, IsTrus
 
 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& eventTypeArg, bool canBubbleArg, bool
     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 f4b7afe..9554eef 100644 (file)
@@ -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 1ea55fc..8263615 100644 (file)
@@ -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 ddd5311..867a008 100644 (file)
@@ -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 8556203..040e5d5 100644 (file)
 
 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 AtomicString& eventType, const String& inputType, C
 {
 }
 
-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 631dc6d..b333bfe 100644 (file)
@@ -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 eaa17c4..ce1f340 100644 (file)
@@ -94,7 +94,7 @@ static inline KeyboardEvent::KeyLocationCode keyLocationCode(const PlatformKeybo
 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(const PlatformKeyboardEvent& key, RefPtr<Win
 {
 }
 
-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::createForBindings()
     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 c36377e..07a32da 100644 (file)
@@ -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();
     
@@ -101,7 +101,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 7f84764..632e13d 100644 (file)
@@ -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 AtomicString& eventType, RefPtr<WindowP
     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 AtomicString& eventType, RefPtr<WindowP
         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 AtomicString& eventType, CanBubble canBubble, IsCan
 {
 }
 
-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 AtomicString& eventType, CanBubble canBubble, IsCan
     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 02d35c6..8849911 100644 (file)
@@ -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 893cc28..3b8ddf5 100644 (file)
 
 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(const AtomicString& eventType, CanBubble ca
 }
 
 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 7663a1a..132c167 100644 (file)
@@ -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 6b4f204..2fb001a 100644 (file)
@@ -2349,7 +2349,7 @@ void Node::dispatchDOMActivateEvent(Event& underlyingClickEvent)
 {
     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 String& sourceURL)
 
 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 f506faf..3e37469 100644 (file)
@@ -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 225db42..6a041e8 100644 (file)
@@ -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>&& view, const String& data, TextEventIn
 }
 
 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>&& view, const String& data, RefPtr<Docu
 }
 
 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 00a00cb..3c9ac43 100644 (file)
@@ -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 d5c26a4..6ffbb51 100644 (file)
@@ -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 6e1d3b3..17e98c4 100644 (file)
@@ -47,20 +47,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 07223b9..81f0729 100644 (file)
@@ -37,8 +37,8 @@ inline static unsigned determineDeltaMode(const PlatformWheelEvent& event)
 
 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 AtomicString& type, const Init& initializer,
 }
 
 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::createForBindings()
     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 10b62e0..66997df 100644 (file)
@@ -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 0700948..176a4a0 100644 (file)
@@ -115,7 +115,7 @@ static bool dispatchBeforeInputEvent(Element& element, const AtomicString& input
     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& element, const AtomicString& inputType,
         // 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(RefPtr<Element>&& target, ClipboardEventKind
 
     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 fe66ecb..3650476 100644 (file)
@@ -2214,7 +2214,8 @@ bool EventHandler::dispatchDragEvent(const AtomicString& eventType, Element& dra
 
     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 83097a1..49fdfd5 100644 (file)
@@ -1,3 +1,15 @@
+2018-08-24  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 Simon Fraser.
+
+        * WebProcess/WebPage/WebPage.cpp:
+        (WebKit::WebPage::navigateToPDFLinkWithSimulatedClick): A trusted click event is composed regardless of
+        whether it's simulated or not.
+
 2018-08-24  Alex Christensen  <achristensen@webkit.org>
 
         Add WKWebView._mainFrame SPI
index de29f95..9af688c 100644 (file)
@@ -1337,7 +1337,7 @@ void WebPage::navigateToPDFLinkWithSimulatedClick(const String& url, IntPoint do
     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 8043219..565a20d 100644 (file)
@@ -1,3 +1,15 @@
+2018-08-24  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 Simon Fraser.
+
+        * 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 4adf2f7..bf68f3a 100644 (file)
@@ -478,9 +478,8 @@ static const float PAGE_HEIGHT_INSET = 4.0f * 2.0f;
     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::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 dee686d..b28f3b4 100644 (file)
@@ -1,3 +1,15 @@
+2018-08-24  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 Simon Fraser.
+
+        * WebView/WebPDFView.mm:
+        (-[WebPDFView PDFViewWillClickOnLink:withURL:]): A trusted click event is composed regardless of
+        whether it's simulated or not.
+
 2018-08-23  Mark Lam  <mark.lam@apple.com>
 
         Move vmEntryGlobalObject() to VM from CallFrame.
index 3e12dfb..24dac9e 100644 (file)
@@ -1031,8 +1031,9 @@ static BOOL isFrameInRange(WebFrame *frame, DOMRange *range)
     }
     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.