Remove PlatformMouseEvent and use WebMouseEvent instead

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

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All
  * rights reserved.
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved.
  * (http://www.torchmobile.com/)
  *
@@ skipping 2101 matching lines @@
   event->setUnderlyingEvent(&underlyingEvent);
   event->setComposed(underlyingEvent.composed());
   dispatchScopedEvent(event);
 
   // TODO(dtapuska): Dispatching scoped events shouldn't check the return
   // type because the scoped event could get put off in the delayed queue.
   return EventTarget::dispatchEventResult(*event);
 }
 
 void Node::createAndDispatchPointerEvent(const AtomicString& mouseEventName,
-                                         const PlatformMouseEvent& mouseEvent,
+                                         const WebMouseEvent& mouseEvent,
                                          LocalDOMWindow* view) {
   AtomicString pointerEventName;
   if (mouseEventName == EventTypeNames::mousemove)
     pointerEventName = EventTypeNames::pointermove;
   else if (mouseEventName == EventTypeNames::mousedown)
     pointerEventName = EventTypeNames::pointerdown;
   else if (mouseEventName == EventTypeNames::mouseup)
     pointerEventName = EventTypeNames::pointerup;
   else
     return;
 
   PointerEventInit pointerEventInit;
 
   pointerEventInit.setPointerId(PointerEventFactory::s_mouseId);
   pointerEventInit.setPointerType("mouse");
   pointerEventInit.setIsPrimary(true);
   pointerEventInit.setButtons(
-      MouseEvent::platformModifiersToButtons(mouseEvent.getModifiers()));
+      MouseEvent::platformModifiersToButtons(mouseEvent.modifiers()));
 
   pointerEventInit.setBubbles(true);
   pointerEventInit.setCancelable(true);
   pointerEventInit.setComposed(true);
   pointerEventInit.setDetail(0);
 
-  pointerEventInit.setScreenX(mouseEvent.globalPosition().x());
-  pointerEventInit.setScreenY(mouseEvent.globalPosition().y());
+  pointerEventInit.setScreenX(mouseEvent.globalX);
+  pointerEventInit.setScreenY(mouseEvent.globalY);
 
   IntPoint locationInFrameZoomed;
   if (view && view->frame() && view->frame()->view()) {
     LocalFrame* frame = view->frame();
     FrameView* frameView = frame->view();
-    IntPoint locationInContents =
-        frameView->rootFrameToContents(mouseEvent.position());
+    IntPoint locationInContents = flooredIntPoint(

[mustaq, 2017/01/27 16:53:44]

Let's floor the coord first before transforming, to preserve old behavior for
corner cases where flooring before/after gives different results.

Moreover, mouseEvent positions are truncated to ints in many other places here.

[dtapuska, 2017/01/27 20:59:59]

Done.

+        frameView->rootFrameToContents(mouseEvent.positionInRootFrame()));
     locationInFrameZoomed = frameView->contentsToFrame(locationInContents);
     float scaleFactor = 1 / frame->pageZoomFactor();
     locationInFrameZoomed.scale(scaleFactor, scaleFactor);
   }
 
   // Set up initial values for coordinates.
   pointerEventInit.setClientX(locationInFrameZoomed.x());
   pointerEventInit.setClientY(locationInFrameZoomed.y());
 
   if (pointerEventName == EventTypeNames::pointerdown ||
       pointerEventName == EventTypeNames::pointerup) {
-    pointerEventInit.setButton(
-        static_cast<int>(mouseEvent.pointerProperties().button));
+    pointerEventInit.setButton(static_cast<int>(mouseEvent.button));
   } else {
     pointerEventInit.setButton(
         static_cast<int>(WebPointerProperties::Button::NoButton));
   }
 
-  UIEventWithKeyState::setFromPlatformModifiers(pointerEventInit,
-                                                mouseEvent.getModifiers());
+  UIEventWithKeyState::setFromWebInputEventModifiers(
+      pointerEventInit,
+      static_cast<WebInputEvent::Modifiers>(mouseEvent.modifiers()));
   pointerEventInit.setView(view);
 
   dispatchEvent(PointerEvent::create(pointerEventName, pointerEventInit));
 }
 
-void Node::dispatchMouseEvent(const PlatformMouseEvent& nativeEvent,
+void Node::dispatchMouseEvent(const WebMouseEvent& nativeEvent,
                               const AtomicString& mouseEventType,
                               int detail,
+                              const String& canvasRegionId,
                               Node* relatedTarget) {
   createAndDispatchPointerEvent(mouseEventType, nativeEvent,
                                 document().domWindow());
   dispatchEvent(MouseEvent::create(mouseEventType, document().domWindow(),
-                                   nativeEvent, detail, relatedTarget));
+                                   nativeEvent, detail, canvasRegionId,
+                                   relatedTarget));
 }
 
 void Node::dispatchSimulatedClick(Event* underlyingEvent,
                                   SimulatedClickMouseEventOptions eventOptions,
                                   SimulatedClickCreationScope scope) {
   EventDispatcher::dispatchSimulatedClick(*this, underlyingEvent, eventOptions,
                                           scope);
 }
 
 void Node::dispatchInputEvent() {
@@ skipping 365 matching lines @@
   if (node) {
     std::stringstream stream;
     node->printNodePathTo(stream);
     LOG(INFO) << stream.str();
   } else {
     LOG(INFO) << "Cannot showNodePath for <null>";
   }
 }
 
 #endif