Remove PlatformMouseEvent and use WebMouseEvent instead

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

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/input/MouseEventManager.h"
 
 #include "core/clipboard/DataObject.h"
 #include "core/clipboard/DataTransfer.h"
 #include "core/dom/Element.h"
 #include "core/dom/ElementTraversal.h"
@@ skipping 17 matching lines @@
 #include "core/page/DragState.h"
 #include "core/page/FocusController.h"
 #include "core/paint/PaintLayer.h"
 #include "core/svg/SVGDocumentExtensions.h"
 #include "platform/geometry/FloatQuad.h"
 
 namespace blink {
 
 namespace {
 
-PlatformMouseEvent mouseEventWithRegion(Node* node,
-                                        const PlatformMouseEvent& mouseEvent) {
+String canvasRegionId(Node* node, const WebMouseEvent& mouseEvent) {
   if (!node->isElementNode())
-    return mouseEvent;
+    return String();
 
   Element* element = toElement(node);
   if (!element->isInCanvasSubtree())
-    return mouseEvent;
+    return String();
 
   HTMLCanvasElement* canvas =
       Traversal<HTMLCanvasElement>::firstAncestorOrSelf(*element);
   // In this case, the event target is canvas and mouse rerouting doesn't
   // happen.
   if (canvas == element)
-    return mouseEvent;
-  String region = canvas->getIdFromControl(element);
-  PlatformMouseEvent newMouseEvent = mouseEvent;
-  newMouseEvent.setRegion(region);
-  return newMouseEvent;
+    return String();
+  return canvas->getIdFromControl(element);
 }
 
 // The amount of time to wait before sending a fake mouse event triggered
 // during a scroll.
 const double kFakeMouseMoveInterval = 0.1;
 
 // TODO(crbug.com/653490): Read these values from the OS.
 #if OS(MACOSX)
 const int kDragThresholdX = 3;
 const int kDragThresholdY = 3;
@@ skipping 26 matching lines @@
   m_mouseDownMayStartDrag = false;
   m_capturesDragging = false;
   m_isMousePositionUnknown = true;
   m_lastKnownMousePosition = IntPoint();
   m_lastKnownMouseGlobalPosition = IntPoint();
   m_mousePressed = false;
   m_clickCount = 0;
   m_clickNode = nullptr;
   m_mouseDownPos = IntPoint();
   m_mouseDownTimestamp = TimeTicks();
-  m_mouseDown = PlatformMouseEvent();
+  m_mouseDown = WebMouseEvent();
   m_svgPan = false;
   m_dragStartPos = LayoutPoint();
   m_fakeMouseMoveEventTimer.stop();
 }
 
 MouseEventManager::~MouseEventManager() = default;
 
 DEFINE_TRACE(MouseEventManager) {
   visitor->trace(m_frame);
   visitor->trace(m_scrollManager);
   visitor->trace(m_nodeUnderMouse);
   visitor->trace(m_mousePressNode);
   visitor->trace(m_clickNode);
   SynchronousMutationObserver::trace(visitor);
 }
 
 MouseEventManager::MouseEventBoundaryEventDispatcher::
-    MouseEventBoundaryEventDispatcher(
-        MouseEventManager* mouseEventManager,
-        const PlatformMouseEvent* platformMouseEvent,
-        EventTarget* exitedTarget)
+    MouseEventBoundaryEventDispatcher(MouseEventManager* mouseEventManager,
+                                      const WebMouseEvent* webMouseEvent,
+                                      EventTarget* exitedTarget,
+                                      const String& canvasRegionId)
     : m_mouseEventManager(mouseEventManager),
-      m_platformMouseEvent(platformMouseEvent),
-      m_exitedTarget(exitedTarget) {}
+      m_webMouseEvent(webMouseEvent),
+      m_exitedTarget(exitedTarget),
+      m_canvasRegionId(canvasRegionId) {}
 
 void MouseEventManager::MouseEventBoundaryEventDispatcher::dispatchOut(
     EventTarget* target,
     EventTarget* relatedTarget) {
-  dispatch(
-      target, relatedTarget, EventTypeNames::mouseout,
-      mouseEventWithRegion(m_exitedTarget->toNode(), *m_platformMouseEvent),
-      false);
+  dispatch(target, relatedTarget, EventTypeNames::mouseout,
+           canvasRegionId(m_exitedTarget->toNode(), *m_webMouseEvent),
+           *m_webMouseEvent, false);
 }
 
 void MouseEventManager::MouseEventBoundaryEventDispatcher::dispatchOver(
     EventTarget* target,
     EventTarget* relatedTarget) {
-  dispatch(target, relatedTarget, EventTypeNames::mouseover,
-           *m_platformMouseEvent, false);
+  dispatch(target, relatedTarget, EventTypeNames::mouseover, m_canvasRegionId,
+           *m_webMouseEvent, false);
 }
 
 void MouseEventManager::MouseEventBoundaryEventDispatcher::dispatchLeave(
     EventTarget* target,
     EventTarget* relatedTarget,
     bool checkForListener) {
-  dispatch(
-      target, relatedTarget, EventTypeNames::mouseleave,
-      mouseEventWithRegion(m_exitedTarget->toNode(), *m_platformMouseEvent),
-      checkForListener);
+  dispatch(target, relatedTarget, EventTypeNames::mouseleave,
+           canvasRegionId(m_exitedTarget->toNode(), *m_webMouseEvent),
+           *m_webMouseEvent, checkForListener);
 }
 
 void MouseEventManager::MouseEventBoundaryEventDispatcher::dispatchEnter(
     EventTarget* target,
     EventTarget* relatedTarget,
     bool checkForListener) {
-  dispatch(target, relatedTarget, EventTypeNames::mouseenter,
-           *m_platformMouseEvent, checkForListener);
+  dispatch(target, relatedTarget, EventTypeNames::mouseenter, m_canvasRegionId,
+           *m_webMouseEvent, checkForListener);
 }
 
 AtomicString
 MouseEventManager::MouseEventBoundaryEventDispatcher::getLeaveEvent() {
   return EventTypeNames::mouseleave;
 }
 
 AtomicString
 MouseEventManager::MouseEventBoundaryEventDispatcher::getEnterEvent() {
   return EventTypeNames::mouseenter;
 }
 
 void MouseEventManager::MouseEventBoundaryEventDispatcher::dispatch(
     EventTarget* target,
     EventTarget* relatedTarget,
     const AtomicString& type,
-    const PlatformMouseEvent& platformMouseEvent,
+    const String& canvasRegionId,
+    const WebMouseEvent& webMouseEvent,
     bool checkForListener) {
-  m_mouseEventManager->dispatchMouseEvent(target, type, platformMouseEvent,
-                                          relatedTarget, checkForListener);
+  m_mouseEventManager->dispatchMouseEvent(target, type, webMouseEvent,
+                                          canvasRegionId, relatedTarget,
+                                          checkForListener);
 }
 
-void MouseEventManager::sendBoundaryEvents(
-    EventTarget* exitedTarget,
-    EventTarget* enteredTarget,
-    const PlatformMouseEvent& mousePlatformEvent) {
+void MouseEventManager::sendBoundaryEvents(EventTarget* exitedTarget,
+                                           EventTarget* enteredTarget,
+                                           const String& canvasRegionId,
+                                           const WebMouseEvent& mouseEvent) {
   MouseEventBoundaryEventDispatcher boundaryEventDispatcher(
-      this, &mousePlatformEvent, exitedTarget);
+      this, &mouseEvent, exitedTarget, canvasRegionId);
   boundaryEventDispatcher.sendBoundaryEvents(exitedTarget, enteredTarget);
 }
 
 WebInputEventResult MouseEventManager::dispatchMouseEvent(
     EventTarget* target,
     const AtomicString& mouseEventType,
-    const PlatformMouseEvent& mouseEvent,
+    const WebMouseEvent& mouseEvent,
+    const String& canvasRegionId,
     EventTarget* relatedTarget,
     bool checkForListener) {
   if (target && target->toNode() &&
       (!checkForListener || target->hasEventListeners(mouseEventType))) {
     Node* targetNode = target->toNode();
     int clickCount = 0;
     if (mouseEventType == EventTypeNames::mouseup ||
         mouseEventType == EventTypeNames::mousedown ||
         mouseEventType == EventTypeNames::click ||
         mouseEventType == EventTypeNames::auxclick ||
         mouseEventType == EventTypeNames::dblclick) {
       clickCount = m_clickCount;
     }
-    MouseEvent* event = MouseEvent::create(
-        mouseEventType, targetNode->document().domWindow(), mouseEvent,
-        clickCount, relatedTarget ? relatedTarget->toNode() : nullptr);
+    MouseEvent* event =
+        MouseEvent::create(mouseEventType, targetNode->document().domWindow(),
+                           mouseEvent, clickCount, canvasRegionId,
+                           relatedTarget ? relatedTarget->toNode() : nullptr);
     DispatchEventResult dispatchResult = target->dispatchEvent(event);
     return EventHandlingUtil::toWebInputEventResult(dispatchResult);
   }
   return WebInputEventResult::NotHandled;
 }
 
 WebInputEventResult MouseEventManager::setMousePositionAndDispatchMouseEvent(
     Node* targetNode,
+    const String& canvasRegionId,
     const AtomicString& eventType,
-    const PlatformMouseEvent& platformMouseEvent) {
+    const WebMouseEvent& webMouseEvent) {
   // If the target node is a text node, dispatch on the parent node.
   if (targetNode && targetNode->isTextNode())
     targetNode = FlatTreeTraversal::parent(*targetNode);
 
-  setNodeUnderMouse(targetNode, platformMouseEvent);
+  setNodeUnderMouse(targetNode, canvasRegionId, webMouseEvent);
 
-  return dispatchMouseEvent(m_nodeUnderMouse, eventType, platformMouseEvent,
-                            nullptr);
+  return dispatchMouseEvent(m_nodeUnderMouse, eventType, webMouseEvent,
+                            canvasRegionId, nullptr);
 }
 
 WebInputEventResult MouseEventManager::dispatchMouseClickIfNeeded(
     const MouseEventWithHitTestResults& mev) {
   // We only prevent click event when the click may cause contextmenu to popup.
   // However, we always send auxclick.
-  bool contextMenuEvent = !RuntimeEnabledFeatures::auxclickEnabled() &&
-                          mev.event().pointerProperties().button ==
-                              WebPointerProperties::Button::Right;
+  bool contextMenuEvent =
+      !RuntimeEnabledFeatures::auxclickEnabled() &&
+      mev.event().button == WebPointerProperties::Button::Right;
 #if OS(MACOSX)
   // FIXME: The Mac port achieves the same behavior by checking whether the
   // context menu is currently open in WebPage::mouseEvent(). Consider merging
   // the implementations.
-  if (mev.event().pointerProperties().button ==
-          WebPointerProperties::Button::Left &&
-      mev.event().getModifiers() & PlatformEvent::CtrlKey)
+  if (mev.event().button == WebPointerProperties::Button::Left &&
+      mev.event().modifiers() & WebInputEvent::Modifiers::ControlKey)
     contextMenuEvent = true;
 #endif
 
   WebInputEventResult clickEventResult = WebInputEventResult::NotHandled;
   const bool shouldDispatchClickEvent =
       m_clickCount > 0 && !contextMenuEvent && mev.innerNode() && m_clickNode &&
       mev.innerNode()->canParticipateInFlatTree() &&
       m_clickNode->canParticipateInFlatTree() &&
       !(m_frame->eventHandler().selectionController().hasExtendedSelection() &&
         isLinkSelection(mev));
   if (shouldDispatchClickEvent) {
     Node* clickTargetNode = nullptr;
     // Updates distribution because a 'mouseup' event listener can make the
     // tree dirty at dispatchMouseEvent() invocation above.
     // Unless distribution is updated, commonAncestor would hit ASSERT.
     if (m_clickNode == mev.innerNode()) {
       clickTargetNode = m_clickNode;
       clickTargetNode->updateDistribution();
     } else if (m_clickNode->document() == mev.innerNode()->document()) {
       m_clickNode->updateDistribution();
       mev.innerNode()->updateDistribution();
       clickTargetNode = mev.innerNode()->commonAncestor(
           *m_clickNode, EventHandlingUtil::parentForClickEvent);
     }
     if (clickTargetNode) {
       clickEventResult = dispatchMouseEvent(
-          clickTargetNode, !RuntimeEnabledFeatures::auxclickEnabled() ||
-                                   (mev.event().pointerProperties().button ==
-                                    WebPointerProperties::Button::Left)
-                               ? EventTypeNames::click
-                               : EventTypeNames::auxclick,
-          mev.event(), nullptr);
+          clickTargetNode,
+          !RuntimeEnabledFeatures::auxclickEnabled() ||
+                  (mev.event().button == WebPointerProperties::Button::Left)
+              ? EventTypeNames::click
+              : EventTypeNames::auxclick,
+          mev.event(), mev.canvasRegionId(), nullptr);
     }
   }
   return clickEventResult;
 }
 
 void MouseEventManager::fakeMouseMoveEventTimerFired(TimerBase* timer) {
   TRACE_EVENT0("input", "MouseEventManager::fakeMouseMoveEventTimerFired");
   DCHECK(timer == &m_fakeMouseMoveEventTimer);
   DCHECK(!m_mousePressed);
 
   if (m_isMousePositionUnknown)
     return;
 
   FrameView* view = m_frame->view();
   if (!view)
     return;
 
   if (!m_frame->page() || !m_frame->page()->focusController().isActive())
     return;
 
   // Don't dispatch a synthetic mouse move event if the mouse cursor is not
   // visible to the user.
   if (!m_frame->page()->isCursorVisible())
     return;
 
-  PlatformMouseEvent fakeMouseMoveEvent(
-      m_lastKnownMousePosition, m_lastKnownMouseGlobalPosition,
-      WebPointerProperties::Button::NoButton, PlatformEvent::MouseMoved, 0,
-      static_cast<PlatformEvent::Modifiers>(
-          KeyboardEventManager::getCurrentModifierState()),
-      PlatformMouseEvent::RealOrIndistinguishable, TimeTicks::Now(),
-      WebPointerProperties::PointerType::Mouse);
-  Vector<PlatformMouseEvent> coalescedEvents;
+  WebMouseEvent fakeMouseMoveEvent(
+      WebInputEvent::MouseMove,
+      WebFloatPoint(m_lastKnownMousePosition.x(), m_lastKnownMousePosition.y()),
+      WebFloatPoint(m_lastKnownMouseGlobalPosition.x(),
+                    m_lastKnownMouseGlobalPosition.y()),
+      WebPointerProperties::Button::NoButton, 0,
+      KeyboardEventManager::getCurrentModifierState(),
+      TimeTicks::Now().InSeconds());
+  // TODO(dtapuska): Update m_lastKnowMousePosition to be viewport coordinates.
+  fakeMouseMoveEvent.setFrameScale(1);
+  Vector<WebMouseEvent> coalescedEvents;
   m_frame->eventHandler().handleMouseMoveEvent(fakeMouseMoveEvent,
                                                coalescedEvents);
 }
 
 void MouseEventManager::cancelFakeMouseMoveEvent() {
   m_fakeMouseMoveEventTimer.stop();
 }
 
-void MouseEventManager::setNodeUnderMouse(
-    Node* target,
-    const PlatformMouseEvent& platformMouseEvent) {
+void MouseEventManager::setNodeUnderMouse(Node* target,
+                                          const String& canvasRegionId,
+                                          const WebMouseEvent& webMouseEvent) {
   Node* lastNodeUnderMouse = m_nodeUnderMouse;
   m_nodeUnderMouse = target;
 
   PaintLayer* layerForLastNode =
       EventHandlingUtil::layerForNode(lastNodeUnderMouse);
   PaintLayer* layerForNodeUnderMouse =
       EventHandlingUtil::layerForNode(m_nodeUnderMouse.get());
   Page* page = m_frame->page();
 
   if (lastNodeUnderMouse &&
@@ skipping 28 matching lines @@
     if (ScrollableArea* scrollableAreaForNodeUnderMouse =
             EventHandlingUtil::associatedScrollableArea(layerForNodeUnderMouse))
       scrollableAreaForNodeUnderMouse->mouseEnteredContentArea();
   }
 
   if (lastNodeUnderMouse &&
       lastNodeUnderMouse->document() != m_frame->document()) {
     lastNodeUnderMouse = nullptr;
   }
 
-  sendBoundaryEvents(lastNodeUnderMouse, m_nodeUnderMouse, platformMouseEvent);
+  sendBoundaryEvents(lastNodeUnderMouse, m_nodeUnderMouse, canvasRegionId,
+                     webMouseEvent);
 }
 
 void MouseEventManager::nodeChildrenWillBeRemoved(ContainerNode& container) {
   if (container == m_clickNode)
     return;
   if (!container.isShadowIncludingInclusiveAncestorOf(m_clickNode.get()))
     return;
   m_clickNode = nullptr;
 }
 
@@ skipping 105 matching lines @@
       // focus has slided.
       found->focus(FocusParams(SelectionBehaviorOnFocus::Reset,
                                WebFocusTypeForward, nullptr));
       return true;
     }
   }
   return false;
 }
 
 void MouseEventManager::handleMousePressEventUpdateStates(
-    const PlatformMouseEvent& mouseEvent) {
+    const WebMouseEvent& mouseEvent) {
   cancelFakeMouseMoveEvent();
   m_mousePressed = true;
   m_capturesDragging = true;
   setLastKnownMousePosition(mouseEvent);
   m_mouseDownMayStartDrag = false;
   m_mouseDownMayStartAutoscroll = false;
-  m_mouseDownTimestamp = mouseEvent.timestamp();
+  m_mouseDownTimestamp = TimeTicks::FromSeconds(mouseEvent.timeStampSeconds());
 
   if (FrameView* view = m_frame->view()) {
-    m_mouseDownPos = view->rootFrameToContents(mouseEvent.position());
+    m_mouseDownPos = view->rootFrameToContents(
+        flooredIntPoint(mouseEvent.positionInRootFrame()));
   } else {
     invalidateClick();
   }
 }
 
 bool MouseEventManager::isMousePositionUnknown() {
   return m_isMousePositionUnknown;
 }
 
 IntPoint MouseEventManager::lastKnownMousePosition() {
   return m_lastKnownMousePosition;
 }
 
-void MouseEventManager::setLastKnownMousePosition(
-    const PlatformMouseEvent& event) {
+void MouseEventManager::setLastKnownMousePosition(const WebMouseEvent& event) {
   m_isMousePositionUnknown = false;
-  m_lastKnownMousePosition = event.position();
-  m_lastKnownMouseGlobalPosition = event.globalPosition();
+  m_lastKnownMousePosition = flooredIntPoint(event.positionInRootFrame());
+  m_lastKnownMouseGlobalPosition = IntPoint(event.globalX, event.globalY);
 }
 
 void MouseEventManager::dispatchFakeMouseMoveEventSoon() {
   if (m_mousePressed)
     return;
 
   if (m_isMousePositionUnknown)
     return;
 
   // Reschedule the timer, to prevent dispatching mouse move events
@@ skipping 19 matching lines @@
   TRACE_EVENT0("blink", "MouseEventManager::handleMousePressEvent");
 
   // Reset drag state.
   dragState().m_dragSrc = nullptr;
 
   cancelFakeMouseMoveEvent();
 
   m_frame->document()->updateStyleAndLayoutIgnorePendingStylesheets();
 
   if (FrameView* frameView = m_frame->view()) {
-    if (frameView->isPointInScrollbarCorner(event.event().position()))
+    if (frameView->isPointInScrollbarCorner(
+            flooredIntPoint(event.event().positionInRootFrame())))
       return WebInputEventResult::NotHandled;
   }
 
-  bool singleClick = event.event().clickCount() <= 1;
+  bool singleClick = event.event().clickCount <= 1;
 
   m_mouseDownMayStartDrag =
       singleClick && !isLinkSelection(event) && !isExtendingSelection(event);
 
   m_frame->eventHandler().selectionController().handleMousePressEvent(event);
 
   m_mouseDown = event.event();
 
   if (m_frame->document()->isSVGDocument() &&
       m_frame->document()->accessSVGExtensions().zoomAndPanEnabled()) {
-    if (event.event().shiftKey() && singleClick) {
+    if ((event.event().modifiers() & WebInputEvent::Modifiers::ShiftKey) &&
+        singleClick) {
       m_svgPan = true;
       m_frame->document()->accessSVGExtensions().startPan(
-          m_frame->view()->rootFrameToContents(event.event().position()));
+          m_frame->view()->rootFrameToContents(
+              flooredIntPoint(event.event().positionInRootFrame())));
       return WebInputEventResult::HandledSystem;
     }
   }
 
   // We don't do this at the start of mouse down handling,
   // because we don't want to do it until we know we didn't hit a widget.
   if (singleClick)
     focusDocumentView();
 
   Node* innerNode = event.innerNode();
 
   m_mousePressNode = innerNode;
   m_frame->document()->setSequentialFocusNavigationStartingPoint(innerNode);
-  m_dragStartPos = event.event().position();
+  m_dragStartPos = flooredIntPoint(event.event().positionInRootFrame());
 
   bool swallowEvent = false;
   m_mousePressed = true;
 
-  if (event.event().clickCount() == 2) {
+  if (event.event().clickCount == 2) {
     swallowEvent = m_frame->eventHandler()
                        .selectionController()
                        .handleMousePressEventDoubleClick(event);
-  } else if (event.event().clickCount() >= 3) {
+  } else if (event.event().clickCount >= 3) {
     swallowEvent = m_frame->eventHandler()
                        .selectionController()
                        .handleMousePressEventTripleClick(event);
   } else {
     swallowEvent = m_frame->eventHandler()
                        .selectionController()
                        .handleMousePressEventSingleClick(event);
   }
 
   m_mouseDownMayStartAutoscroll =
@@ skipping 24 matching lines @@
 
 bool MouseEventManager::handleDragDropIfPossible(
     const GestureEventWithHitTestResults& targetedEvent) {
   if (m_frame->settings() && m_frame->settings()->getTouchDragDropEnabled() &&
       m_frame->view()) {
     const WebGestureEvent& gestureEvent = targetedEvent.event();
     unsigned modifiers = gestureEvent.modifiers();
 
     // TODO(mustaq): Suppressing long-tap MouseEvents could break
     // drag-drop. Will do separately because of the risk. crbug.com/606938.
-    PlatformMouseEvent mouseDownEvent(
-        gestureEvent, WebPointerProperties::Button::Left,
-        PlatformEvent::MousePressed, 1,
-        static_cast<PlatformEvent::Modifiers>(modifiers |
-                                              PlatformEvent::LeftButtonDown),
-        PlatformMouseEvent::FromTouch, TimeTicks::Now(),
-        WebPointerProperties::PointerType::Mouse);
+    WebMouseEvent mouseDownEvent(
+        WebInputEvent::MouseDown, gestureEvent,
+        WebPointerProperties::Button::Left, 1,
+        modifiers | WebInputEvent::Modifiers::LeftButtonDown |
+            WebInputEvent::Modifiers::IsCompatibilityEventForTouch,
+        TimeTicks::Now().InSeconds());
     m_mouseDown = mouseDownEvent;
 
-    PlatformMouseEvent mouseDragEvent(
-        gestureEvent, WebPointerProperties::Button::Left,
-        PlatformEvent::MouseMoved, 1,
-        static_cast<PlatformEvent::Modifiers>(modifiers |
-                                              PlatformEvent::LeftButtonDown),
-        PlatformMouseEvent::FromTouch, TimeTicks::Now(),
-        WebPointerProperties::PointerType::Mouse);
+    WebMouseEvent mouseDragEvent(
+        WebInputEvent::MouseMove, gestureEvent,
+        WebPointerProperties::Button::Left, 1,
+        modifiers | WebInputEvent::Modifiers::LeftButtonDown |
+            WebInputEvent::Modifiers::IsCompatibilityEventForTouch,
+        TimeTicks::Now().InSeconds());
     HitTestRequest request(HitTestRequest::ReadOnly);
     MouseEventWithHitTestResults mev =
         EventHandlingUtil::performMouseEventHitTest(m_frame, request,
                                                     mouseDragEvent);
     m_mouseDownMayStartDrag = true;
     dragState().m_dragSrc = nullptr;
-    m_mouseDownPos =
-        m_frame->view()->rootFrameToContents(mouseDragEvent.position());
+    m_mouseDownPos = m_frame->view()->rootFrameToContents(
+        flooredIntPoint(mouseDragEvent.positionInRootFrame()));
     return handleDrag(mev, DragInitiator::Touch);
   }
   return false;
 }
 
 void MouseEventManager::focusDocumentView() {
   Page* page = m_frame->page();
   if (!page)
     return;
   page->focusController().focusDocumentView(m_frame);
@@ skipping 10 matching lines @@
   //    is on a mouse press. The problem is the <embed> node only starts
   //    capturing mouse events *after* m_mousePressed for the containing frame
   //    has already been set to true. As a result, the frame's EventHandler
   //    never sees the mouse release event, which is supposed to reset
   //    m_mousePressed... so m_mousePressed ends up remaining true until the
   //    event handler finally gets another mouse released event. Oops.
   // 2. Dragging doesn't start until after a mouse press event, but a drag
   //    that ends as a result of a mouse release does not send a mouse release
   //    event. As a result, m_mousePressed also ends up remaining true until
   //    the next mouse release event seen by the EventHandler.
-  if (event.event().pointerProperties().button !=
-      WebPointerProperties::Button::Left)
+  if (event.event().button != WebPointerProperties::Button::Left)
     m_mousePressed = false;
 
   if (!m_mousePressed)
     return WebInputEventResult::NotHandled;
 
   if (handleDrag(event, DragInitiator::Mouse))
     return WebInputEventResult::HandledSystem;
 
   Node* targetNode = event.innerNode();
   if (!targetNode)
@@ skipping 28 matching lines @@
       controller->startAutoscrollForSelection(layoutObject);
       m_mouseDownMayStartAutoscroll = false;
     }
   }
 
   return WebInputEventResult::HandledSystem;
 }
 
 bool MouseEventManager::handleDrag(const MouseEventWithHitTestResults& event,
                                    DragInitiator initiator) {
-  DCHECK(event.event().type() == PlatformEvent::MouseMoved);
+  DCHECK(event.event().type() == WebInputEvent::MouseMove);
   // Callers must protect the reference to FrameView, since this function may
   // dispatch DOM events, causing page/FrameView to go away.
   DCHECK(m_frame);
   DCHECK(m_frame->view());
   if (!m_frame->page())
     return false;
 
   if (m_mouseDownMayStartDrag) {
     HitTestRequest request(HitTestRequest::ReadOnly);
     HitTestResult result(request, m_mouseDownPos);
     m_frame->contentLayoutItem().hitTest(result);
     Node* node = result.innerNode();
     if (node) {
       DragController::SelectionDragPolicy selectionDragPolicy =
-          event.event().timestamp() - m_mouseDownTimestamp < kTextDragDelay
+          TimeTicks::FromSeconds(event.event().timeStampSeconds()) -
+                      m_mouseDownTimestamp <
+                  kTextDragDelay
               ? DragController::DelayedSelectionDragResolution
               : DragController::ImmediateSelectionDragResolution;
       dragState().m_dragSrc = m_frame->page()->dragController().draggableNode(
           m_frame, node, m_mouseDownPos, selectionDragPolicy,
           dragState().m_dragType);
     } else {
       dragState().m_dragSrc = nullptr;
     }
 
     if (!dragState().m_dragSrc)
       m_mouseDownMayStartDrag = false;  // no element is draggable
   }
 
   if (!m_mouseDownMayStartDrag) {
     return initiator == DragInitiator::Mouse &&
            !m_frame->eventHandler()
                 .selectionController()
                 .mouseDownMayStartSelect() &&
            !m_mouseDownMayStartAutoscroll;
   }
 
   // We are starting a text/image/url drag, so the cursor should be an arrow
   // FIXME <rdar://7577595>: Custom cursors aren't supported during drag and
   // drop (default to pointer).
   m_frame->view()->setCursor(pointerCursor());
 
   if (initiator == DragInitiator::Mouse &&
-      !dragThresholdExceeded(event.event().position())) {
+      !dragThresholdExceeded(
+          flooredIntPoint(event.event().positionInRootFrame()))) {
     dragState().m_dragSrc = nullptr;
     return true;
   }
 
   // Once we're past the drag threshold, we don't want to treat this gesture as
   // a click.
   invalidateClick();
 
   if (!tryStartDrag(event)) {
     // Something failed to start the drag, clean up.
@@ skipping 52 matching lines @@
     dispatchDragSrcEvent(EventTypeNames::dragend, event.event());
   }
 
   return false;
 }
 
 // Returns if we should continue "default processing", i.e., whether
 // eventhandler canceled.
 WebInputEventResult MouseEventManager::dispatchDragSrcEvent(
     const AtomicString& eventType,
-    const PlatformMouseEvent& event) {
+    const WebMouseEvent& event) {
   return dispatchDragEvent(eventType, dragState().m_dragSrc.get(), event,
                            dragState().m_dragDataTransfer.get());
 }
 
 WebInputEventResult MouseEventManager::dispatchDragEvent(
     const AtomicString& eventType,
     Node* dragTarget,
-    const PlatformMouseEvent& event,
+    const WebMouseEvent& event,
     DataTransfer* dataTransfer) {
   FrameView* view = m_frame->view();
 
   // FIXME: We might want to dispatch a dragleave even if the view is gone.
   if (!view)
     return WebInputEventResult::NotHandled;
 
   const bool cancelable = eventType != EventTypeNames::dragleave &&
                           eventType != EventTypeNames::dragend;
 
+  IntPoint position = flooredIntPoint(event.positionInRootFrame());
+  IntPoint movement = flooredIntPoint(event.movementInRootFrame());
   DragEvent* me = DragEvent::create(
       eventType, true, cancelable, m_frame->document()->domWindow(), 0,
-      event.globalPosition().x(), event.globalPosition().y(),
-      event.position().x(), event.position().y(), event.movementDelta().x(),
-      event.movementDelta().y(), event.getModifiers(), 0,
-      MouseEvent::platformModifiersToButtons(event.getModifiers()), nullptr,
-      event.timestamp(), dataTransfer, event.getSyntheticEventType());
+      event.globalX, event.globalY, position.x(), position.y(), movement.x(),
+      movement.y(), static_cast<PlatformEvent::Modifiers>(event.modifiers()), 0,
+      MouseEvent::platformModifiersToButtons(event.modifiers()), nullptr,
+      TimeTicks::FromSeconds(event.timeStampSeconds()), dataTransfer,
+      event.fromTouch() ? MouseEvent::FromTouch
+                        : MouseEvent::RealOrIndistinguishable);
 
   return EventHandlingUtil::toWebInputEventResult(
       dragTarget->dispatchEvent(me));
 }
 
 void MouseEventManager::clearDragDataTransfer() {
   if (dragState().m_dragDataTransfer) {
     dragState().m_dragDataTransfer->clearDragImage();
     dragState().m_dragDataTransfer->setAccessPolicy(DataTransferNumb);
   }
 }
 
-void MouseEventManager::dragSourceEndedAt(const PlatformMouseEvent& event,
+void MouseEventManager::dragSourceEndedAt(const WebMouseEvent& event,
                                           DragOperation operation) {
   if (dragState().m_dragSrc) {
     dragState().m_dragDataTransfer->setDestinationOperation(operation);
     // The return value is ignored because dragend is not cancelable.
     dispatchDragSrcEvent(EventTypeNames::dragend, event);
   }
   clearDragDataTransfer();
   dragState().m_dragSrc = nullptr;
   // In case the drag was ended due to an escape key press we need to ensure
   // that consecutive mousemove events don't reinitiate the drag and drop.
@@ skipping 75 matching lines @@
 
 void MouseEventManager::setClickCount(int clickCount) {
   m_clickCount = clickCount;
 }
 
 bool MouseEventManager::mouseDownMayStartDrag() {
   return m_mouseDownMayStartDrag;
 }
 
 }  // namespace blink