Diff
Modified: trunk/Source/WebCore/ChangeLog (235330 => 235331)
--- trunk/Source/WebCore/ChangeLog 2018-08-24 20:12:43 UTC (rev 235330)
+++ trunk/Source/WebCore/ChangeLog 2018-08-24 20:14:50 UTC (rev 235331)
@@ -1,5 +1,90 @@
2018-08-24 Ryosuke Niwa <rn...@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 <rn...@webkit.org>
+
Add getModifierState to MouseEvent
https://bugs.webkit.org/show_bug.cgi?id=188913
<rdar://problem/43668772>
Modified: trunk/Source/WebCore/dom/ClipboardEvent.cpp (235330 => 235331)
--- trunk/Source/WebCore/dom/ClipboardEvent.cpp 2018-08-24 20:12:43 UTC (rev 235330)
+++ trunk/Source/WebCore/dom/ClipboardEvent.cpp 2018-08-24 20:14:50 UTC (rev 235331)
@@ -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)
{
}
Modified: trunk/Source/WebCore/dom/ClipboardEvent.h (235330 => 235331)
--- trunk/Source/WebCore/dom/ClipboardEvent.h 2018-08-24 20:12:43 UTC (rev 235330)
+++ trunk/Source/WebCore/dom/ClipboardEvent.h 2018-08-24 20:14:50 UTC (rev 235331)
@@ -37,16 +37,21 @@
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;
Modified: trunk/Source/WebCore/dom/CompositionEvent.cpp (235330 => 235331)
--- trunk/Source/WebCore/dom/CompositionEvent.cpp 2018-08-24 20:12:43 UTC (rev 235330)
+++ trunk/Source/WebCore/dom/CompositionEvent.cpp 2018-08-24 20:14:50 UTC (rev 235331)
@@ -32,13 +32,13 @@
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)
{
}
Modified: trunk/Source/WebCore/dom/CompositionEvent.h (235330 => 235331)
--- trunk/Source/WebCore/dom/CompositionEvent.h 2018-08-24 20:12:43 UTC (rev 235330)
+++ trunk/Source/WebCore/dom/CompositionEvent.h 2018-08-24 20:14:50 UTC (rev 235331)
@@ -46,9 +46,9 @@
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 @@
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;
Modified: trunk/Source/WebCore/dom/Element.cpp (235330 => 235331)
--- trunk/Source/WebCore/dom/Element.cpp 2018-08-24 20:12:43 UTC (rev 235330)
+++ trunk/Source/WebCore/dom/Element.cpp 2018-08-24 20:14:50 UTC (rev 235331)
@@ -292,7 +292,9 @@
// 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);
Modified: trunk/Source/WebCore/dom/Event.cpp (235330 => 235331)
--- trunk/Source/WebCore/dom/Event.cpp 2018-08-24 20:12:43 UTC (rev 235330)
+++ trunk/Source/WebCore/dom/Event.cpp 2018-08-24 20:14:50 UTC (rev 235331)
@@ -57,14 +57,14 @@
{
}
-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() = 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 @@
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)
Modified: trunk/Source/WebCore/dom/Event.h (235330 => 235331)
--- trunk/Source/WebCore/dom/Event.h 2018-08-24 20:12:43 UTC (rev 235330)
+++ trunk/Source/WebCore/dom/Event.h 2018-08-24 20:14:50 UTC (rev 235331)
@@ -52,7 +52,7 @@
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 @@
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 @@
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() { }
Modified: trunk/Source/WebCore/dom/FocusEvent.cpp (235330 => 235331)
--- trunk/Source/WebCore/dom/FocusEvent.cpp 2018-08-24 20:12:43 UTC (rev 235330)
+++ trunk/Source/WebCore/dom/FocusEvent.cpp 2018-08-24 20:14:50 UTC (rev 235331)
@@ -40,14 +40,14 @@
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)
{
}
Modified: trunk/Source/WebCore/dom/FocusEvent.h (235330 => 235331)
--- trunk/Source/WebCore/dom/FocusEvent.h 2018-08-24 20:12:43 UTC (rev 235330)
+++ trunk/Source/WebCore/dom/FocusEvent.h 2018-08-24 20:14:50 UTC (rev 235331)
@@ -49,9 +49,9 @@
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 @@
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;
Modified: trunk/Source/WebCore/dom/InputEvent.cpp (235330 => 235331)
--- trunk/Source/WebCore/dom/InputEvent.cpp 2018-08-24 20:12:43 UTC (rev 235330)
+++ trunk/Source/WebCore/dom/InputEvent.cpp 2018-08-24 20:14:50 UTC (rev 235331)
@@ -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 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)
{
Modified: trunk/Source/WebCore/dom/InputEvent.h (235330 => 235331)
--- trunk/Source/WebCore/dom/InputEvent.h 2018-08-24 20:12:43 UTC (rev 235330)
+++ trunk/Source/WebCore/dom/InputEvent.h 2018-08-24 20:14:50 UTC (rev 235331)
@@ -39,17 +39,14 @@
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 @@
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;
Modified: trunk/Source/WebCore/dom/KeyboardEvent.cpp (235330 => 235331)
--- trunk/Source/WebCore/dom/KeyboardEvent.cpp 2018-08-24 20:12:43 UTC (rev 235330)
+++ trunk/Source/WebCore/dom/KeyboardEvent.cpp 2018-08-24 20:14:50 UTC (rev 235331)
@@ -94,7 +94,7 @@
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 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 @@
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,
Modified: trunk/Source/WebCore/dom/KeyboardEvent.h (235330 => 235331)
--- trunk/Source/WebCore/dom/KeyboardEvent.h 2018-08-24 20:12:43 UTC (rev 235330)
+++ trunk/Source/WebCore/dom/KeyboardEvent.h 2018-08-24 20:14:50 UTC (rev 235331)
@@ -61,7 +61,7 @@
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 @@
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)
Modified: trunk/Source/WebCore/dom/MouseEvent.cpp (235330 => 235331)
--- trunk/Source/WebCore/dom/MouseEvent.cpp 2018-08-24 20:12:43 UTC (rev 235330)
+++ trunk/Source/WebCore/dom/MouseEvent.cpp 2018-08-24 20:14:50 UTC (rev 235331)
@@ -39,9 +39,9 @@
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 @@
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 @@
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, 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 @@
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)
Modified: trunk/Source/WebCore/dom/MouseEvent.h (235330 => 235331)
--- trunk/Source/WebCore/dom/MouseEvent.h 2018-08-24 20:12:43 UTC (rev 235330)
+++ trunk/Source/WebCore/dom/MouseEvent.h 2018-08-24 20:14:50 UTC (rev 235331)
@@ -34,19 +34,19 @@
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 @@
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();
Modified: trunk/Source/WebCore/dom/MouseRelatedEvent.cpp (235330 => 235331)
--- trunk/Source/WebCore/dom/MouseRelatedEvent.cpp 2018-08-24 20:12:43 UTC (rev 235330)
+++ trunk/Source/WebCore/dom/MouseRelatedEvent.cpp 2018-08-24 20:14:50 UTC (rev 235331)
@@ -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(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));
}
Modified: trunk/Source/WebCore/dom/MouseRelatedEvent.h (235330 => 235331)
--- trunk/Source/WebCore/dom/MouseRelatedEvent.h 2018-08-24 20:12:43 UTC (rev 235330)
+++ trunk/Source/WebCore/dom/MouseRelatedEvent.h 2018-08-24 20:14:50 UTC (rev 235331)
@@ -76,7 +76,7 @@
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);
Modified: trunk/Source/WebCore/dom/Node.cpp (235330 => 235331)
--- trunk/Source/WebCore/dom/Node.cpp 2018-08-24 20:12:43 UTC (rev 235330)
+++ trunk/Source/WebCore/dom/Node.cpp 2018-08-24 20:14:50 UTC (rev 235331)
@@ -2349,7 +2349,7 @@
{
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 @@
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)
Modified: trunk/Source/WebCore/dom/SimulatedClick.cpp (235330 => 235331)
--- trunk/Source/WebCore/dom/SimulatedClick.cpp 2018-08-24 20:12:43 UTC (rev 235330)
+++ trunk/Source/WebCore/dom/SimulatedClick.cpp 2018-08-24 20:14:50 UTC (rev 235331)
@@ -44,7 +44,8 @@
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)
Modified: trunk/Source/WebCore/dom/TextEvent.cpp (235330 => 235331)
--- trunk/Source/WebCore/dom/TextEvent.cpp 2018-08-24 20:12:43 UTC (rev 235330)
+++ trunk/Source/WebCore/dom/TextEvent.cpp 2018-08-24 20:14:50 UTC (rev 235331)
@@ -72,7 +72,7 @@
}
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, 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, 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)
Modified: trunk/Source/WebCore/dom/UIEvent.cpp (235330 => 235331)
--- trunk/Source/WebCore/dom/UIEvent.cpp 2018-08-24 20:12:43 UTC (rev 235330)
+++ trunk/Source/WebCore/dom/UIEvent.cpp 2018-08-24 20:14:50 UTC (rev 235331)
@@ -32,22 +32,22 @@
{
}
-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)
{
Modified: trunk/Source/WebCore/dom/UIEvent.h (235330 => 235331)
--- trunk/Source/WebCore/dom/UIEvent.h 2018-08-24 20:12:43 UTC (rev 235330)
+++ trunk/Source/WebCore/dom/UIEvent.h 2018-08-24 20:14:50 UTC (rev 235331)
@@ -34,17 +34,17 @@
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,10 +65,11 @@
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;
Modified: trunk/Source/WebCore/dom/UIEventWithKeyState.h (235330 => 235331)
--- trunk/Source/WebCore/dom/UIEventWithKeyState.h 2018-08-24 20:12:43 UTC (rev 235330)
+++ trunk/Source/WebCore/dom/UIEventWithKeyState.h 2018-08-24 20:14:50 UTC (rev 235331)
@@ -47,20 +47,22 @@
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))
{
}
Modified: trunk/Source/WebCore/dom/WheelEvent.cpp (235330 => 235331)
--- trunk/Source/WebCore/dom/WheelEvent.cpp 2018-08-24 20:12:43 UTC (rev 235330)
+++ trunk/Source/WebCore/dom/WheelEvent.cpp 2018-08-24 20:14:50 UTC (rev 235331)
@@ -37,8 +37,8 @@
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 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 @@
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)
Modified: trunk/Source/WebCore/dom/WheelEvent.h (235330 => 235331)
--- trunk/Source/WebCore/dom/WheelEvent.h 2018-08-24 20:12:43 UTC (rev 235330)
+++ trunk/Source/WebCore/dom/WheelEvent.h 2018-08-24 20:14:50 UTC (rev 235331)
@@ -51,7 +51,7 @@
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 @@
private:
WheelEvent();
- WheelEvent(const AtomicString&, const Init&, IsTrusted);
+ WheelEvent(const AtomicString&, const Init&);
WheelEvent(const PlatformWheelEvent&, RefPtr<WindowProxy>&&);
EventInterface eventInterface() const final;
Modified: trunk/Source/WebCore/editing/Editor.cpp (235330 => 235331)
--- trunk/Source/WebCore/editing/Editor.cpp 2018-08-24 20:12:43 UTC (rev 235330)
+++ trunk/Source/WebCore/editing/Editor.cpp 2018-08-24 20:14:50 UTC (rev 235331)
@@ -115,7 +115,7 @@
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 @@
// 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 @@
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();
Modified: trunk/Source/WebCore/page/EventHandler.cpp (235330 => 235331)
--- trunk/Source/WebCore/page/EventHandler.cpp 2018-08-24 20:12:43 UTC (rev 235330)
+++ trunk/Source/WebCore/page/EventHandler.cpp 2018-08-24 20:14:50 UTC (rev 235331)
@@ -2214,7 +2214,8 @@
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(),
Modified: trunk/Source/WebKit/ChangeLog (235330 => 235331)
--- trunk/Source/WebKit/ChangeLog 2018-08-24 20:12:43 UTC (rev 235330)
+++ trunk/Source/WebKit/ChangeLog 2018-08-24 20:14:50 UTC (rev 235331)
@@ -1,3 +1,15 @@
+2018-08-24 Ryosuke Niwa <rn...@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 <achristen...@webkit.org>
Add WKWebView._mainFrame SPI
Modified: trunk/Source/WebKit/WebProcess/WebPage/WebPage.cpp (235330 => 235331)
--- trunk/Source/WebKit/WebProcess/WebPage/WebPage.cpp 2018-08-24 20:12:43 UTC (rev 235330)
+++ trunk/Source/WebKit/WebProcess/WebPage/WebPage.cpp 2018-08-24 20:14:50 UTC (rev 235331)
@@ -1337,7 +1337,7 @@
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);
Modified: trunk/Source/WebKitLegacy/ios/ChangeLog (235330 => 235331)
--- trunk/Source/WebKitLegacy/ios/ChangeLog 2018-08-24 20:12:43 UTC (rev 235330)
+++ trunk/Source/WebKitLegacy/ios/ChangeLog 2018-08-24 20:14:50 UTC (rev 235331)
@@ -1,3 +1,15 @@
+2018-08-24 Ryosuke Niwa <rn...@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 <rn...@webkit.org>
Replace booleans for modifier keys in UIEventWithKeyState with OptionSet<Modifier>
Modified: trunk/Source/WebKitLegacy/ios/WebView/WebPDFViewPlaceholder.mm (235330 => 235331)
--- trunk/Source/WebKitLegacy/ios/WebView/WebPDFViewPlaceholder.mm 2018-08-24 20:12:43 UTC (rev 235330)
+++ trunk/Source/WebKitLegacy/ios/WebView/WebPDFViewPlaceholder.mm 2018-08-24 20:14:50 UTC (rev 235331)
@@ -478,9 +478,8 @@
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]);
Modified: trunk/Source/WebKitLegacy/mac/ChangeLog (235330 => 235331)
--- trunk/Source/WebKitLegacy/mac/ChangeLog 2018-08-24 20:12:43 UTC (rev 235330)
+++ trunk/Source/WebKitLegacy/mac/ChangeLog 2018-08-24 20:14:50 UTC (rev 235331)
@@ -1,3 +1,15 @@
+2018-08-24 Ryosuke Niwa <rn...@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....@apple.com>
Move vmEntryGlobalObject() to VM from CallFrame.
Modified: trunk/Source/WebKitLegacy/mac/WebView/WebPDFView.mm (235330 => 235331)
--- trunk/Source/WebKitLegacy/mac/WebView/WebPDFView.mm 2018-08-24 20:12:43 UTC (rev 235330)
+++ trunk/Source/WebKitLegacy/mac/WebView/WebPDFView.mm 2018-08-24 20:14:50 UTC (rev 235331)
@@ -1031,8 +1031,9 @@
}
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.
