Remove WebMouseEvent from MouseEvent.h

Remove the WebMouseEvent dependency in MouseEvent
and all its subclasses like DragEvent and WheelEvent.

Bug: 820249
Change-Id: Icc62baea6862901cb91a531f7b649c6858ee94dd
Reviewed-on: https://chromium-review.googlesource.com/956543
Commit-Queue: Navid Zolghadr <nzolghadr@chromium.org>
Reviewed-by: Ella Ge <eirage@chromium.org>
Reviewed-by: Mustaq Ahmed <mustaq@chromium.org>
Reviewed-by: Dave Tapuska <dtapuska@chromium.org>
Cr-Commit-Position: refs/heads/master@{#546103}

third_party/WebKit/LayoutTests/fast/events/pointerevents/pointer-event-properties-in-iframe-expected.txt

@@ -12,137 +12,281 @@ TEST COMPLETE
 pointermove of mouse is received:
 clientX = 150
 clientY = 100
+pageX = 175
+pageY = 200
+screenX = 200
+screenY = 200
 view.name = innerFrame
 mousemove is received:
 clientX = 150
 clientY = 100
+pageX = 175
+pageY = 200
+screenX = 200
+screenY = 200
 pointerdown of mouse is received:
 clientX = 150
 clientY = 100
+pageX = 175
+pageY = 200
+screenX = 200
+screenY = 200
 view.name = innerFrame
 mousedown is received:
 clientX = 150
 clientY = 100
+pageX = 175
+pageY = 200
+screenX = 200
+screenY = 200
 pointerup of mouse is received:
 clientX = 150
 clientY = 100
+pageX = 175
+pageY = 200
+screenX = 200
+screenY = 200
 view.name = innerFrame
 mouseup is received:
 clientX = 150
 clientY = 100
+pageX = 175
+pageY = 200
+screenX = 200
+screenY = 200
  *** Touch events inside iframe ***
 pointerdown of touch is received:
 clientX = 150
 clientY = 100
+pageX = 175
+pageY = 200
+screenX = 200
+screenY = 200
 view.name = innerFrame
 touchstart is received:
 clientX = 150
 clientY = 100
+pageX = 175
+pageY = 200
+screenX = 200
+screenY = 200
 pointermove of touch is received:
 clientX = 150
 clientY = 100
+pageX = 175
+pageY = 200
+screenX = 200
+screenY = 200
 view.name = innerFrame
 touchmove is received:
 clientX = 150
 clientY = 100
+pageX = 175
+pageY = 200
+screenX = 200
+screenY = 200
 pointerup of touch is received:
 clientX = 150
 clientY = 100
+pageX = 175
+pageY = 200
+screenX = 200
+screenY = 200
 view.name = innerFrame
 touchend is received:
 clientX = 150
 clientY = 100
+pageX = 175
+pageY = 200
+screenX = 200
+screenY = 200
 
 ===== scrollX=40, scrollY=140, zoomFactor=1
  *** Mouse events inside iframe ***
 pointermove of mouse is received:
 clientX = 150
 clientY = 100
+pageX = 190
+pageY = 240
+screenX = 200
+screenY = 200
 view.name = innerFrame
 mousemove is received:
 clientX = 150
 clientY = 100
+pageX = 190
+pageY = 240
+screenX = 200
+screenY = 200
 pointerdown of mouse is received:
 clientX = 150
 clientY = 100
+pageX = 190
+pageY = 240
+screenX = 200
+screenY = 200
 view.name = innerFrame
 mousedown is received:
 clientX = 150
 clientY = 100
+pageX = 190
+pageY = 240
+screenX = 200
+screenY = 200
 pointerup of mouse is received:
 clientX = 150
 clientY = 100
+pageX = 190
+pageY = 240
+screenX = 200
+screenY = 200
 view.name = innerFrame
 mouseup is received:
 clientX = 150
 clientY = 100
+pageX = 190
+pageY = 240
+screenX = 200
+screenY = 200
  *** Touch events inside iframe ***
 pointerdown of touch is received:
 clientX = 150
 clientY = 100
+pageX = 190
+pageY = 240
+screenX = 200
+screenY = 200
 view.name = innerFrame
 touchstart is received:
 clientX = 150
 clientY = 100
+pageX = 190
+pageY = 240
+screenX = 200
+screenY = 200
 pointermove of touch is received:
 clientX = 150
 clientY = 100
+pageX = 190
+pageY = 240
+screenX = 200
+screenY = 200
 view.name = innerFrame
 touchmove is received:
 clientX = 150
 clientY = 100
+pageX = 190
+pageY = 240
+screenX = 200
+screenY = 200
 pointerup of touch is received:
 clientX = 150
 clientY = 100
+pageX = 190
+pageY = 240
+screenX = 200
+screenY = 200
 view.name = innerFrame
 touchend is received:
 clientX = 150
 clientY = 100
+pageX = 190
+pageY = 240
+screenX = 200
+screenY = 200
 
 ===== scrollX=40, scrollY=140, zoomFactor=2
  *** Mouse events inside iframe ***
 pointermove of mouse is received:
 clientX = 50
 clientY = 0
+pageX = 90
+pageY = 140
+screenX = 200
+screenY = 200
 view.name = innerFrame
 mousemove is received:
 clientX = 50
 clientY = 0
+pageX = 90
+pageY = 140
+screenX = 200
+screenY = 200
 pointerdown of mouse is received:
 clientX = 50
 clientY = 0
+pageX = 90
+pageY = 140
+screenX = 200
+screenY = 200
 view.name = innerFrame
 mousedown is received:
 clientX = 50
 clientY = 0
+pageX = 90
+pageY = 140
+screenX = 200
+screenY = 200
 pointerup of mouse is received:
 clientX = 50
 clientY = 0
+pageX = 90
+pageY = 140
+screenX = 200
+screenY = 200
 view.name = innerFrame
 mouseup is received:
 clientX = 50
 clientY = 0
+pageX = 90
+pageY = 140
+screenX = 200
+screenY = 200
  *** Touch events inside iframe ***
 pointerdown of touch is received:
 clientX = 50
 clientY = 0
+pageX = 90
+pageY = 140
+screenX = 200
+screenY = 200
 view.name = innerFrame
 touchstart is received:
 clientX = 50
 clientY = 0
+pageX = 90
+pageY = 140
+screenX = 200
+screenY = 200
 pointermove of touch is received:
 clientX = 50
 clientY = 0
+pageX = 90
+pageY = 140
+screenX = 200
+screenY = 200
 view.name = innerFrame
 touchmove is received:
 clientX = 50
 clientY = 0
+pageX = 90
+pageY = 140
+screenX = 200
+screenY = 200
 pointerup of touch is received:
 clientX = 50
 clientY = 0
+pageX = 90
+pageY = 140
+screenX = 200
+screenY = 200
 view.name = innerFrame
 touchend is received:
 clientX = 50
 clientY = 0
+pageX = 90
+pageY = 140
+screenX = 200
+screenY = 200
 
 

third_party/WebKit/LayoutTests/fast/events/pointerevents/pointer-event-properties-in-iframe.html

@@ -34,7 +34,11 @@ window.name = 'outerFrame';
 
 var attributes = [
     'clientX',
-    'clientY'
+    'clientY',
+    'pageX',
+    'pageY',
+    'screenX',
+    'screenY'
 ];
 
 document.events = [];

third_party/WebKit/Source/core/dom/Node.cpp

@@ -91,6 +91,7 @@
 #include "core/html/custom/CustomElement.h"
 #include "core/html_names.h"
 #include "core/input/EventHandler.h"
+#include "core/input/InputDeviceCapabilities.h"
 #include "core/layout/LayoutBox.h"
 #include "core/layout/LayoutEmbeddedContent.h"
 #include "core/mathml_names.h"
@@ -2351,16 +2352,47 @@ void Node::CreateAndDispatchPointerEvent(const AtomicString& mouse_event_name,
   DispatchEvent(PointerEvent::Create(pointer_event_name, pointer_event_init));
 }
 
-void Node::DispatchMouseEvent(const WebMouseEvent& native_event,
+// TODO(crbug.com/665924): This function bypasses all Blink event path.
+// It should be using that flow instead of creating/sending events directly.
+void Node::DispatchMouseEvent(const WebMouseEvent& event,
                               const AtomicString& mouse_event_type,
                               int detail,
                               const String& canvas_region_id,
                               Node* related_target) {
-  CreateAndDispatchPointerEvent(mouse_event_type, native_event,
+  CreateAndDispatchPointerEvent(mouse_event_type, event,
                                 GetDocument().domWindow());
-  DispatchEvent(MouseEvent::Create(mouse_event_type, GetDocument().domWindow(),
-                                   native_event, detail, canvas_region_id,
-                                   related_target));
+
+  bool is_mouse_enter_or_leave =
+      mouse_event_type == EventTypeNames::mouseenter ||
+      mouse_event_type == EventTypeNames::mouseleave;
+  MouseEventInit initializer;
+  initializer.setBubbles(!is_mouse_enter_or_leave);
+  initializer.setCancelable(!is_mouse_enter_or_leave);
+  MouseEvent::SetCoordinatesFromWebPointerProperties(
+      event.FlattenTransform(), GetDocument().domWindow(), initializer);
+  initializer.setButton(static_cast<short>(event.button));
+  initializer.setButtons(
+      MouseEvent::WebInputEventModifiersToButtons(event.GetModifiers()));
+  initializer.setView(GetDocument().domWindow());
+  initializer.setDetail(detail);
+  initializer.setComposed(true);
+  initializer.setRegion(canvas_region_id);
+  initializer.setRelatedTarget(related_target);
+  UIEventWithKeyState::SetFromWebInputEventModifiers(
+      initializer, static_cast<WebInputEvent::Modifiers>(event.GetModifiers()));
+  initializer.setSourceCapabilities(
+      GetDocument().domWindow() ? GetDocument()
+                                      .domWindow()
+                                      ->GetInputDeviceCapabilities()
+                                      ->FiresTouchEvents(event.FromTouch())
+                                : nullptr);
+
+  DispatchEvent(MouseEvent::Create(
+      mouse_event_type, initializer,
+      TimeTicksFromSeconds(event.TimeStampSeconds()),
+      event.FromTouch() ? MouseEvent::kFromTouch
+                        : MouseEvent::kRealOrIndistinguishable,
+      event.menu_source_type));
 }
 
 void Node::DispatchSimulatedClick(Event* underlying_event,

third_party/WebKit/Source/core/events/DragEvent.cpp

@@ -10,80 +10,13 @@
 
 namespace blink {
 
-DragEvent* DragEvent::Create(const AtomicString& type,
-                             Bubbles bubbles,
-                             Cancelable cancelable,
-                             AbstractView* view,
-                             int detail,
-                             double screen_x,
-                             double screen_y,
-                             double window_x,
-                             double window_y,
-                             double movement_x,
-                             double movement_y,
-                             WebInputEvent::Modifiers modifiers,
-                             short button,
-                             unsigned short buttons,
-                             EventTarget* related_target,
-                             TimeTicks platform_time_stamp,
-                             DataTransfer* data_transfer,
-                             SyntheticEventType synthetic_event_type) {
-  return new DragEvent(
-      type, bubbles, cancelable, view, detail, screen_x, screen_y, window_x,
-      window_y, movement_x, movement_y, modifiers, button, buttons,
-      related_target, platform_time_stamp, data_transfer, synthetic_event_type);
-}
-
 DragEvent::DragEvent() : data_transfer_(nullptr) {}
 
-DragEvent::DragEvent(DataTransfer* data_transfer)
-    : data_transfer_(data_transfer) {}
-
-DragEvent::DragEvent(const AtomicString& event_type,
-                     Bubbles bubbles,
-                     Cancelable cancelable,
-                     AbstractView* view,
-                     int detail,
-                     double screen_x,
-                     double screen_y,
-                     double window_x,
-                     double window_y,
-                     double movement_x,
-                     double movement_y,
-                     WebInputEvent::Modifiers modifiers,
-                     short button,
-                     unsigned short buttons,
-                     EventTarget* related_target,
+DragEvent::DragEvent(const AtomicString& type,
+                     const DragEventInit& initializer,
                      TimeTicks platform_time_stamp,
-                     DataTransfer* data_transfer,
                      SyntheticEventType synthetic_event_type)
-    : MouseEvent(
-          event_type,
-          bubbles,
-          cancelable,
-          view,
-          detail,
-          screen_x,
-          screen_y,
-          window_x,
-          window_y,
-          movement_x,
-          movement_y,
-          modifiers,
-          button,
-          buttons,
-          related_target,
-          platform_time_stamp,
-          synthetic_event_type,
-          // TODO(zino): Should support canvas hit region because the drag event
-          // is a kind of mouse event. Please see http://crbug.com/594073
-          String()),
-      data_transfer_(data_transfer)
-
-{}
-
-DragEvent::DragEvent(const AtomicString& type, const DragEventInit& initializer)
-    : MouseEvent(type, initializer),
+    : MouseEvent(type, initializer, platform_time_stamp, synthetic_event_type),
       data_transfer_(initializer.getDataTransfer()) {}
 
 bool DragEvent::IsDragEvent() const {

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

@@ -19,32 +19,18 @@ class CORE_EXPORT DragEvent final : public MouseEvent {
  public:
   static DragEvent* Create() { return new DragEvent; }
 
-  static DragEvent* Create(DataTransfer* data_transfer) {
-    return new DragEvent(data_transfer);
-  }
-
   static DragEvent* Create(const AtomicString& type,
-                           Bubbles,
-                           Cancelable,
-                           AbstractView*,
-                           int detail,
-                           double screen_x,
-                           double screen_y,
-                           double window_x,
-                           double window_y,
-                           double movement_x,
-                           double movement_y,
-                           WebInputEvent::Modifiers,
-                           short button,
-                           unsigned short buttons,
-                           EventTarget* related_target,
+                           const DragEventInit& initializer,
                            TimeTicks platform_time_stamp,
-                           DataTransfer*,
-                           SyntheticEventType = kRealOrIndistinguishable);
+                           SyntheticEventType synthetic_event_type) {
+    return new DragEvent(type, initializer, platform_time_stamp,
+                         synthetic_event_type);
+  }
 
   static DragEvent* Create(const AtomicString& type,
                            const DragEventInit& initializer) {
-    return new DragEvent(type, initializer);
+    return new DragEvent(type, initializer, CurrentTimeTicks(),
+                         kRealOrIndistinguishable);
   }
 
   DataTransfer* getDataTransfer() const override {
@@ -60,28 +46,11 @@ class CORE_EXPORT DragEvent final : public MouseEvent {
 
  private:
   DragEvent();
-  DragEvent(DataTransfer*);
   DragEvent(const AtomicString& type,
-            Bubbles,
-            Cancelable,
-            AbstractView*,
-            int detail,
-            double screen_x,
-            double screen_y,
-            double window_x,
-            double window_y,
-            double movement_x,
-            double movement_y,
-            WebInputEvent::Modifiers,
-            short button,
-            unsigned short buttons,
-            EventTarget* related_target,
+            const DragEventInit&,
             TimeTicks platform_time_stamp,
-            DataTransfer*,
             SyntheticEventType);
 
-  DragEvent(const AtomicString& type, const DragEventInit&);
-
   Member<DataTransfer> data_transfer_;
 };
 

third_party/WebKit/Source/core/events/MouseEvent.cpp

@@ -94,18 +94,12 @@ MouseEvent* MouseEvent::Create(ScriptState* script_state,
 }
 
 MouseEvent* MouseEvent::Create(const AtomicString& event_type,
-                               AbstractView* view,
-                               const WebMouseEvent& event,
-                               int detail,
-                               const String& canvas_region_id,
-                               Node* related_target) {
-  bool is_mouse_enter_or_leave = event_type == EventTypeNames::mouseenter ||
-                                 event_type == EventTypeNames::mouseleave;
-  Cancelable cancelable =
-      (!is_mouse_enter_or_leave) ? Cancelable::kYes : Cancelable::kNo;
-  Bubbles bubbles = (!is_mouse_enter_or_leave) ? Bubbles::kYes : Bubbles::kNo;
-  return new MouseEvent(event_type, bubbles, cancelable, view, event, detail,
-                        canvas_region_id, related_target);
+                               const MouseEventInit& initializer,
+                               TimeTicks platform_time_stamp,
+                               SyntheticEventType synthetic_event_type,
+                               WebMenuSourceType menu_source_type) {
+  return new MouseEvent(event_type, initializer, platform_time_stamp,
+                        synthetic_event_type, menu_source_type);
 }
 
 MouseEvent* MouseEvent::Create(const AtomicString& event_type,
@@ -128,12 +122,19 @@ MouseEvent* MouseEvent::Create(const AtomicString& event_type,
     screen_y = mouse_event->screenY();
   }
 
+  MouseEventInit initializer;
+  initializer.setBubbles(true);
+  initializer.setCancelable(true);
+  initializer.setScreenX(screen_x);
+  initializer.setScreenY(screen_y);
+  initializer.setView(view);
+  initializer.setComposed(true);
+  UIEventWithKeyState::SetFromWebInputEventModifiers(initializer, modifiers);
+
   TimeTicks timestamp = underlying_event ? underlying_event->PlatformTimeStamp()
                                          : CurrentTimeTicks();
   MouseEvent* created_event =
-      new MouseEvent(event_type, Bubbles::kYes, Cancelable::kYes, view, 0,
-                     screen_x, screen_y, 0, 0, 0, 0, modifiers, 0, 0, nullptr,
-                     timestamp, synthetic_type, String());
+      new MouseEvent(event_type, initializer, timestamp, synthetic_type);
 
   created_event->SetTrusted(creation_scope ==
                             SimulatedClickCreationScope::kFromUserAgent);
@@ -156,97 +157,24 @@ MouseEvent::MouseEvent()
       synthetic_event_type_(kRealOrIndistinguishable) {}
 
 MouseEvent::MouseEvent(const AtomicString& event_type,
-                       Bubbles bubbles,
-                       Cancelable cancelable,
-                       AbstractView* abstract_view,
-                       const WebMouseEvent& event,
-                       int detail,
-                       const String& region,
-                       EventTarget* related_target)
-    : UIEventWithKeyState(
-          event_type,
-          bubbles,
-          cancelable,
-          abstract_view,
-          detail,
-          static_cast<WebInputEvent::Modifiers>(event.GetModifiers()),
-          TimeTicksFromSeconds(event.TimeStampSeconds()),
-          abstract_view
-              ? abstract_view->GetInputDeviceCapabilities()->FiresTouchEvents(
-                    event.FromTouch())
-              : nullptr),
-      screen_location_(event.PositionInScreen().x, event.PositionInScreen().y),
-      movement_delta_(event.MovementInRootFrame()),
-      position_type_(PositionType::kPosition),
-      button_(static_cast<short>(event.button)),
-      buttons_(WebInputEventModifiersToButtons(event.GetModifiers())),
-      related_target_(related_target),
-      synthetic_event_type_(event.FromTouch() ? kFromTouch
-                                              : kRealOrIndistinguishable),
-      region_(region),
-      menu_source_type_(event.menu_source_type) {
-  FloatPoint root_frame_coordinates = event.PositionInRootFrame();
-  InitCoordinatesFromRootFrame(root_frame_coordinates.X(),
-                               root_frame_coordinates.Y());
-}
-
-MouseEvent::MouseEvent(const AtomicString& event_type,
-                       Bubbles bubbles,
-                       Cancelable cancelable,
-                       AbstractView* abstract_view,
-                       int detail,
-                       double screen_x,
-                       double screen_y,
-                       double window_x,
-                       double window_y,
-                       double movement_x,
-                       double movement_y,
-                       WebInputEvent::Modifiers modifiers,
-                       short button,
-                       unsigned short buttons,
-                       EventTarget* related_target,
+                       const MouseEventInit& initializer,
                        TimeTicks platform_time_stamp,
                        SyntheticEventType synthetic_event_type,
-                       const String& region)
-    : UIEventWithKeyState(
-          event_type,
-          bubbles,
-          cancelable,
-          abstract_view,
-          detail,
-          modifiers,
-          platform_time_stamp,
-          abstract_view
-              ? abstract_view->GetInputDeviceCapabilities()->FiresTouchEvents(
-                    synthetic_event_type == kFromTouch)
-              : nullptr),
-      screen_location_(screen_x, screen_y),
-      movement_delta_(movement_x, movement_y),
-      position_type_(synthetic_event_type == kPositionless
-                         ? PositionType::kPositionless
-                         : PositionType::kPosition),
-      button_(button),
-      buttons_(buttons),
-      related_target_(related_target),
-      synthetic_event_type_(synthetic_event_type),
-      region_(region) {
-  InitCoordinatesFromRootFrame(window_x, window_y);
-}
-
-MouseEvent::MouseEvent(const AtomicString& event_type,
-                       const MouseEventInit& initializer,
-                       TimeTicks platform_time_stamp)
+                       WebMenuSourceType menu_source_type)
     : UIEventWithKeyState(event_type, initializer, platform_time_stamp),
       screen_location_(
           DoublePoint(initializer.screenX(), initializer.screenY())),
       movement_delta_(
           IntPoint(initializer.movementX(), initializer.movementY())),
-      position_type_(PositionType::kPosition),
+      position_type_(synthetic_event_type == kPositionless
+                         ? PositionType::kPositionless
+                         : PositionType::kPosition),
       button_(initializer.button()),
       buttons_(initializer.buttons()),
       related_target_(initializer.relatedTarget()),
-      synthetic_event_type_(kRealOrIndistinguishable),
-      region_(initializer.region()) {
+      synthetic_event_type_(synthetic_event_type),
+      region_(initializer.region()),
+      menu_source_type_(menu_source_type) {
   InitCoordinates(initializer.clientX(), initializer.clientY());
 }
 
@@ -263,35 +191,32 @@ void MouseEvent::InitCoordinates(const double client_x, const double client_y) {
   has_cached_relative_position_ = false;
 }
 
-void MouseEvent::InitCoordinatesFromRootFrame(double window_x,
-                                              double window_y) {
-  DoublePoint adjusted_page_location;
-  DoubleSize scroll_offset;
-
-  LocalFrame* frame = view() && view()->IsLocalDOMWindow()
-                          ? ToLocalDOMWindow(view())->GetFrame()
-                          : nullptr;
-  if (frame && HasPosition()) {
-    scroll_offset = ContentsScrollOffset(view());
-    if (LocalFrameView* frame_view = frame->View()) {
-      adjusted_page_location =
-          frame_view->RootFrameToDocument(FloatPoint(window_x, window_y));
-      float scale_factor = 1 / frame->PageZoomFactor();
-      if (scale_factor != 1.0f)
-        adjusted_page_location.Scale(scale_factor, scale_factor);
-    }
+void MouseEvent::SetCoordinatesFromWebPointerProperties(
+    const WebPointerProperties& web_pointer_properties,
+    const LocalDOMWindow* dom_window,
+    MouseEventInit& initializer) {
+  FloatPoint client_point;
+  float scale_factor = 1.0f;
+  if (dom_window && dom_window->GetFrame() && dom_window->GetFrame()->View()) {
+    LocalFrame* frame = dom_window->GetFrame();
+    FloatPoint page_point = frame->View()->RootFrameToContents(
+        web_pointer_properties.PositionInWidget());
+    scale_factor = 1.0f / frame->PageZoomFactor();
+    FloatPoint scroll_position(frame->View()->GetScrollOffset());
+    client_point = page_point.ScaledBy(scale_factor);
+    client_point.MoveBy(scroll_position.ScaledBy(-scale_factor));
   }
 
-  client_location_ = adjusted_page_location - scroll_offset;
-  page_location_ = adjusted_page_location;
+  initializer.setScreenX(web_pointer_properties.PositionInScreen().x);
+  initializer.setScreenY(web_pointer_properties.PositionInScreen().y);
+  initializer.setClientX(client_point.X());
+  initializer.setClientY(client_point.Y());
 
-  // Set up initial values for coordinates.
-  // Correct values are computed lazily, see computeRelativePosition.
-  layer_location_ = page_location_;
-  offset_location_ = page_location_;
-
-  ComputePageLocation();
-  has_cached_relative_position_ = false;
+  // TODO(nzolghadr): We need to scale movement attrinutes as well. But if we do
+  // that here and round it to the int again it causes inconsistencies between
+  // screenX/Y and cumulative movementX/Y.
+  initializer.setMovementX(web_pointer_properties.movement_x);
+  initializer.setMovementY(web_pointer_properties.movement_y);
 }
 
 MouseEvent::~MouseEvent() = default;

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

@@ -28,7 +28,6 @@
 #include "core/events/MouseEventInit.h"
 #include "core/events/UIEventWithKeyState.h"
 #include "public/platform/WebMenuSourceType.h"
-#include "public/platform/WebMouseEvent.h"
 
 namespace blink {
 class DataTransfer;
@@ -52,11 +51,10 @@ class CORE_EXPORT MouseEvent : public UIEventWithKeyState {
   static MouseEvent* Create() { return new MouseEvent; }
 
   static MouseEvent* Create(const AtomicString& event_type,
-                            AbstractView*,
-                            const WebMouseEvent&,
-                            int detail,
-                            const String& canvas_region_id,
-                            Node* related_target);
+                            const MouseEventInit&,
+                            TimeTicks platform_time_stamp,
+                            SyntheticEventType,
+                            WebMenuSourceType);
 
   static MouseEvent* Create(ScriptState*,
                             const AtomicString& event_type,
@@ -70,6 +68,10 @@ class CORE_EXPORT MouseEvent : public UIEventWithKeyState {
   ~MouseEvent() override;
 
   static unsigned short WebInputEventModifiersToButtons(unsigned modifiers);
+  static void SetCoordinatesFromWebPointerProperties(
+      const WebPointerProperties&,
+      const LocalDOMWindow*,
+      MouseEventInit&);
 
   void initMouseEvent(ScriptState*,
                       const AtomicString& type,
@@ -117,8 +119,6 @@ class CORE_EXPORT MouseEvent : public UIEventWithKeyState {
 
   int ClickCount() { return detail(); }
 
-  const WebMouseEvent* NativeEvent() const { return native_event_.get(); }
-
   enum class PositionType {
     kPosition,
     // Positionless mouse events are used, for example, for 'click' events from
@@ -192,36 +192,11 @@ class CORE_EXPORT MouseEvent : public UIEventWithKeyState {
 
  protected:
   MouseEvent(const AtomicString& type,
-             Bubbles,
-             Cancelable,
-             AbstractView*,
-             const WebMouseEvent&,
-             int detail,
-             const String& region,
-             EventTarget* related_target);
-
-  MouseEvent(const AtomicString& type,
-             Bubbles,
-             Cancelable,
-             AbstractView*,
-             int detail,
-             double screen_x,
-             double screen_y,
-             double window_x,
-             double window_y,
-             double movement_x,
-             double movement_y,
-             WebInputEvent::Modifiers,
-             short button,
-             unsigned short buttons,
-             EventTarget* related_target,
+             const MouseEventInit&,
              TimeTicks platform_time_stamp,
-             SyntheticEventType,
-             const String& region);
+             SyntheticEventType = kRealOrIndistinguishable,
+             WebMenuSourceType = kMenuSourceNone);
 
-  MouseEvent(const AtomicString& type,
-             const MouseEventInit&,
-             TimeTicks platform_time_stamp);
   MouseEvent(const AtomicString& type, const MouseEventInit& init)
       : MouseEvent(type, init, CurrentTimeTicks()) {}
 
@@ -254,7 +229,6 @@ class CORE_EXPORT MouseEvent : public UIEventWithKeyState {
                               unsigned short buttons = 0);
 
   void InitCoordinates(const double client_x, const double client_y);
-  void InitCoordinatesFromRootFrame(double window_x, double window_y);
 
   void ComputePageLocation();
   void ComputeRelativePosition();
@@ -274,8 +248,6 @@ class CORE_EXPORT MouseEvent : public UIEventWithKeyState {
 
   // Only used for contextmenu events.
   WebMenuSourceType menu_source_type_;
-
-  std::unique_ptr<WebMouseEvent> native_event_;
 };
 
 DEFINE_EVENT_TYPE_CASTS(MouseEvent);

third_party/WebKit/Source/core/events/PointerEventFactory.cpp

@@ -88,31 +88,16 @@ void UpdateCommonPointerEventInit(const WebPointerEvent& web_pointer_event,
   WebPointerEvent web_pointer_event_in_root_frame =
       web_pointer_event.WebPointerEventInRootFrame();
 
-  FloatPoint client_point;
-  float scale_factor = 1.0f;
-  if (dom_window && dom_window->GetFrame() && dom_window->GetFrame()->View()) {
-    LocalFrame* frame = dom_window->GetFrame();
-    FloatPoint page_point = frame->View()->RootFrameToContents(
-        web_pointer_event_in_root_frame.PositionInWidget());
-    scale_factor = 1.0f / frame->PageZoomFactor();
-    FloatPoint scroll_position(frame->View()->GetScrollOffset());
-    client_point = page_point.ScaledBy(scale_factor);
-    client_point.MoveBy(scroll_position.ScaledBy(-scale_factor));
-  }
-
-  pointer_event_init->setScreenX(web_pointer_event.PositionInScreen().x);
-  pointer_event_init->setScreenY(web_pointer_event.PositionInScreen().y);
-  pointer_event_init->setClientX(client_point.X());
-  pointer_event_init->setClientY(client_point.Y());
-  // TODO(nzolghadr): We need to scale movement attrinutes as well. But if we do
-  // that here and round it to the int again it causes inconsistencies between
-  // screenX/Y and cumulative movementX/Y.
-  pointer_event_init->setMovementX(web_pointer_event_in_root_frame.movement_x);
-  pointer_event_init->setMovementY(web_pointer_event_in_root_frame.movement_y);
+  MouseEvent::SetCoordinatesFromWebPointerProperties(
+      web_pointer_event_in_root_frame, dom_window, *pointer_event_init);
   // If width/height is unknown we let PointerEventInit set it to 1.
   // See https://w3c.github.io/pointerevents/#dom-pointerevent-width
   if (web_pointer_event_in_root_frame.HasWidth() &&
       web_pointer_event_in_root_frame.HasHeight()) {
+    float scale_factor = 1.0f;
+    if (dom_window && dom_window->GetFrame())
+      scale_factor = 1.0f / dom_window->GetFrame()->PageZoomFactor();
+
     FloatSize point_shape = FloatSize(web_pointer_event_in_root_frame.width,
                                       web_pointer_event_in_root_frame.height)
                                 .ScaledBy(scale_factor);

third_party/WebKit/Source/core/events/WebInputEventConversion.cpp

@@ -172,24 +172,6 @@ WebPointerEvent TransformWebPointerEvent(LocalFrameView* frame_view,
 WebMouseEventBuilder::WebMouseEventBuilder(const LocalFrameView* plugin_parent,
                                            const LayoutObject* layout_object,
                                            const MouseEvent& event) {
-  if (event.NativeEvent()) {
-    *static_cast<WebMouseEvent*>(this) =
-        event.NativeEvent()->FlattenTransform();
-    WebFloatPoint absolute_location = PositionInRootFrame();
-
-    // TODO(dtapuska): |plugin_parent| should never be null. Remove this
-    // conditional code.
-    // Translate the root frame position to content coordinates.
-    if (plugin_parent) {
-      absolute_location = plugin_parent->RootFrameToContents(absolute_location);
-    }
-
-    FloatPoint local_point =
-        layout_object->AbsoluteToLocal(absolute_location, kUseTransforms);
-    SetPositionInWidget(local_point.X(), local_point.Y());
-    return;
-  }
-
   // Code below here can be removed once OOPIF ships.
   // OOPIF will prevent synthetic events being dispatched into
   // other frames; but for now we allow the fallback to generate

third_party/WebKit/Source/core/events/WheelEvent.cpp

@@ -41,6 +41,30 @@ long NegateIfPossible(long value) {
   return -value;
 }
 
+MouseEventInit GetMouseEventInitForWheel(const WebMouseWheelEvent& event,
+                                         AbstractView* view) {
+  MouseEventInit initializer;
+  initializer.setBubbles(true);
+  initializer.setCancelable(event.IsCancelable());
+  MouseEvent::SetCoordinatesFromWebPointerProperties(
+      event.FlattenTransform(),
+      view->IsLocalDOMWindow() ? ToLocalDOMWindow(view) : nullptr, initializer);
+  initializer.setButton(static_cast<short>(event.button));
+  initializer.setButtons(
+      MouseEvent::WebInputEventModifiersToButtons(event.GetModifiers()));
+  initializer.setView(view);
+  initializer.setComposed(true);
+  initializer.setDetail(event.click_count);
+  UIEventWithKeyState::SetFromWebInputEventModifiers(
+      initializer, static_cast<WebInputEvent::Modifiers>(event.GetModifiers()));
+
+  // TODO(zino): Should support canvas hit region because the
+  // wheel event is a kind of mouse event. Please see
+  // http://crbug.com/594075
+
+  return initializer;
+}
+
 }  // namespace
 
 WheelEvent* WheelEvent::Create(const WebMouseWheelEvent& event,
@@ -69,16 +93,8 @@ WheelEvent::WheelEvent(const AtomicString& type,
 
 WheelEvent::WheelEvent(const WebMouseWheelEvent& event, AbstractView* view)
     : MouseEvent(EventTypeNames::wheel,
-                 Bubbles::kYes,
-                 event.IsCancelable() ? Cancelable::kYes : Cancelable::kNo,
-                 view,
-                 event,
-                 event.click_count,
-                 // TODO(zino): Should support canvas hit region because the
-                 // wheel event is a kind of mouse event. Please see
-                 // http://crbug.com/594075
-                 String(),
-                 nullptr),
+                 GetMouseEventInitForWheel(event, view),
+                 TimeTicksFromSeconds(event.TimeStampSeconds())),
       wheel_delta_(event.wheel_ticks_x * kTickMultiplier,
                    event.wheel_ticks_y * kTickMultiplier),
       delta_x_(-event.DeltaXInRootFrame()),

third_party/WebKit/Source/core/input/MouseEventManager.cpp

@@ -217,10 +217,41 @@ WebInputEventResult MouseEventManager::DispatchMouseEvent(
         mouse_event_type == EventTypeNames::dblclick) {
       click_count = click_count_;
     }
+    bool is_mouse_enter_or_leave =
+        mouse_event_type == EventTypeNames::mouseenter ||
+        mouse_event_type == EventTypeNames::mouseleave;
+    MouseEventInit initializer;
+    initializer.setBubbles(!is_mouse_enter_or_leave);
+    initializer.setCancelable(!is_mouse_enter_or_leave);
+    MouseEvent::SetCoordinatesFromWebPointerProperties(
+        mouse_event.FlattenTransform(), target_node->GetDocument().domWindow(),
+        initializer);
+    initializer.setButton(static_cast<short>(mouse_event.button));
+    initializer.setButtons(MouseEvent::WebInputEventModifiersToButtons(
+        mouse_event.GetModifiers()));
+    initializer.setView(target_node->GetDocument().domWindow());
+    initializer.setComposed(true);
+    initializer.setDetail(click_count);
+    initializer.setRegion(canvas_region_id);
+    initializer.setRelatedTarget(related_target);
+    UIEventWithKeyState::SetFromWebInputEventModifiers(
+        initializer,
+        static_cast<WebInputEvent::Modifiers>(mouse_event.GetModifiers()));
+    initializer.setSourceCapabilities(
+        target_node->GetDocument().domWindow()
+            ? target_node->GetDocument()
+                  .domWindow()
+                  ->GetInputDeviceCapabilities()
+                  ->FiresTouchEvents(mouse_event.FromTouch())
+            : nullptr);
+
     MouseEvent* event = MouseEvent::Create(
-        mouse_event_type, target_node->GetDocument().domWindow(), mouse_event,
-        click_count, canvas_region_id,
-        related_target ? related_target->ToNode() : nullptr);
+        mouse_event_type, initializer,
+        TimeTicksFromSeconds(mouse_event.TimeStampSeconds()),
+        mouse_event.FromTouch() ? MouseEvent::kFromTouch
+                                : MouseEvent::kRealOrIndistinguishable,
+        mouse_event.menu_source_type);
+
     DispatchEventResult dispatch_result = target->DispatchEvent(event);
     return EventHandlingUtil::ToWebInputEventResult(dispatch_result);
   }
@@ -1009,22 +1040,32 @@ WebInputEventResult MouseEventManager::DispatchDragEvent(
       related_target->GetDocument() != drag_target->GetDocument())
     related_target = nullptr;
 
-  const Event::Cancelable cancelable =
-      (event_type != EventTypeNames::dragleave &&
-       event_type != EventTypeNames::dragend)
-          ? Event::Cancelable::kYes
-          : Event::Cancelable::kNo;
+  DragEventInit initializer;
+  initializer.setBubbles(true);
+  initializer.setCancelable(event_type != EventTypeNames::dragleave &&
+                            event_type != EventTypeNames::dragend);
+  MouseEvent::SetCoordinatesFromWebPointerProperties(
+      event.FlattenTransform(), frame_->GetDocument()->domWindow(),
+      initializer);
+  initializer.setButton(0);
+  initializer.setButtons(
+      MouseEvent::WebInputEventModifiersToButtons(event.GetModifiers()));
+  initializer.setRelatedTarget(related_target);
+  initializer.setView(frame_->GetDocument()->domWindow());
+  initializer.setComposed(true);
+  initializer.setGetDataTransfer(data_transfer);
+  initializer.setSourceCapabilities(
+      frame_->GetDocument()->domWindow()
+          ? frame_->GetDocument()
+                ->domWindow()
+                ->GetInputDeviceCapabilities()
+                ->FiresTouchEvents(event.FromTouch())
+          : nullptr);
+  UIEventWithKeyState::SetFromWebInputEventModifiers(
+      initializer, static_cast<WebInputEvent::Modifiers>(event.GetModifiers()));
 
-  IntPoint movement = FlooredIntPoint(event.MovementInRootFrame());
   DragEvent* me = DragEvent::Create(
-      event_type, Event::Bubbles::kYes, cancelable,
-      frame_->GetDocument()->domWindow(), 0, event.PositionInScreen().x,
-      event.PositionInScreen().y, event.PositionInRootFrame().x,
-      event.PositionInRootFrame().y, movement.X(), movement.Y(),
-      static_cast<WebInputEvent::Modifiers>(event.GetModifiers()), 0,
-      MouseEvent::WebInputEventModifiersToButtons(event.GetModifiers()),
-      related_target, TimeTicksFromSeconds(event.TimeStampSeconds()),
-      data_transfer,
+      event_type, initializer, TimeTicksFromSeconds(event.TimeStampSeconds()),
       event.FromTouch() ? MouseEvent::kFromTouch
                         : MouseEvent::kRealOrIndistinguishable);