Remove PlatformMouseEvent and use WebMouseEvent instead

third_party/WebKit/Source/core/events/PointerEventFactory.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/events/PointerEventFactory.h"
 
 #include "core/frame/FrameView.h"
 #include "platform/geometry/FloatSize.h"
 
 namespace blink {
@@ skipping 116 matching lines @@
   pointerEventInit->setScreenX(touchPoint.screenPosition.x);
   pointerEventInit->setScreenY(touchPoint.screenPosition.y);
   pointerEventInit->setPressure(
       getPointerEventPressure(touchPoint.force, pointerEventInit->buttons()));
   pointerEventInit->setTiltX(touchPoint.tiltX);
   pointerEventInit->setTiltY(touchPoint.tiltY);
   pointerEventInit->setTangentialPressure(touchPoint.tangentialPressure);
   pointerEventInit->setTwist(touchPoint.twist);
 }
 
-void updateMousePointerEventInit(const PlatformMouseEvent& mouseEvent,
+void updateMousePointerEventInit(const WebMouseEvent& mouseEvent,
                                  LocalDOMWindow* view,
                                  PointerEventInit* pointerEventInit) {
   // This function should not update attributes like pointerId, isPrimary,
   // and pointerType which is the same among the coalesced events and the
   // dispatched event.
 
-  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 = frameView->rootFrameToContents(
+        flooredIntPoint(mouseEvent.positionInRootFrame()));
     locationInFrameZoomed = frameView->contentsToFrame(locationInContents);
     float scaleFactor = 1 / frame->pageZoomFactor();
     locationInFrameZoomed.scale(scaleFactor, scaleFactor);
   }
 
   pointerEventInit->setClientX(locationInFrameZoomed.x());
   pointerEventInit->setClientY(locationInFrameZoomed.y());
 
-  pointerEventInit->setPressure(getPointerEventPressure(
-      mouseEvent.pointerProperties().force, pointerEventInit->buttons()));
-  pointerEventInit->setTiltX(mouseEvent.pointerProperties().tiltX);
-  pointerEventInit->setTiltY(mouseEvent.pointerProperties().tiltY);
-  pointerEventInit->setTangentialPressure(
-      mouseEvent.pointerProperties().tangentialPressure);
-  pointerEventInit->setTwist(mouseEvent.pointerProperties().twist);
+  pointerEventInit->setPressure(
+      getPointerEventPressure(mouseEvent.force, pointerEventInit->buttons()));
+  pointerEventInit->setTiltX(mouseEvent.tiltX);
+  pointerEventInit->setTiltY(mouseEvent.tiltY);
+  pointerEventInit->setTangentialPressure(mouseEvent.tangentialPressure);
+  pointerEventInit->setTwist(mouseEvent.twist);
 }
 
 }  // namespace
 
 const int PointerEventFactory::s_invalidId = 0;
 
 // Mouse id is 1 to behave the same as MS Edge for compatibility reasons.
 const int PointerEventFactory::s_mouseId = 1;
 
 void PointerEventFactory::setIdTypeButtons(
@@ skipping 31 matching lines @@
                                  type != EventTypeNames::pointercancel &&
                                  type != EventTypeNames::gotpointercapture &&
                                  type != EventTypeNames::lostpointercapture);
 
   pointerEventInit.setComposed(true);
   pointerEventInit.setDetail(0);
 }
 
 PointerEvent* PointerEventFactory::create(
     const AtomicString& mouseEventName,
-    const PlatformMouseEvent& mouseEvent,
-    const Vector<PlatformMouseEvent>& coalescedMouseEvents,
+    const WebMouseEvent& mouseEvent,
+    const Vector<WebMouseEvent>& coalescedMouseEvents,
     LocalDOMWindow* view) {
   DCHECK(mouseEventName == EventTypeNames::mousemove ||
          mouseEventName == EventTypeNames::mousedown ||
          mouseEventName == EventTypeNames::mouseup);
 
   AtomicString pointerEventName =
       pointerEventNameForMouseEventName(mouseEventName);
 
-  unsigned buttons =
-      MouseEvent::platformModifiersToButtons(mouseEvent.getModifiers());
+  unsigned buttons = MouseEvent::platformModifiersToButtons(
+      static_cast<PlatformEvent::Modifiers>(mouseEvent.modifiers()));
   PointerEventInit pointerEventInit;
 
-  setIdTypeButtons(pointerEventInit, mouseEvent.pointerProperties(), buttons);
+  setIdTypeButtons(pointerEventInit, mouseEvent, buttons);
   setEventSpecificFields(pointerEventInit, pointerEventName);
 
   if (pointerEventName == EventTypeNames::pointerdown ||
       pointerEventName == EventTypeNames::pointerup) {
-    WebPointerProperties::Button button = mouseEvent.pointerProperties().button;
+    WebPointerProperties::Button button = mouseEvent.button;
     // TODO(mustaq): Fix when the spec starts supporting hovering erasers.
-    if (mouseEvent.pointerProperties().pointerType ==
-            WebPointerProperties::PointerType::Eraser &&
+    if (mouseEvent.pointerType == WebPointerProperties::PointerType::Eraser &&
         button == WebPointerProperties::Button::Left)
       button = WebPointerProperties::Button::Eraser;
     pointerEventInit.setButton(static_cast<int>(button));
   } else {
     DCHECK(pointerEventName == EventTypeNames::pointermove);
     pointerEventInit.setButton(
         static_cast<int>(WebPointerProperties::Button::NoButton));
   }
 
-  UIEventWithKeyState::setFromPlatformModifiers(pointerEventInit,
-                                                mouseEvent.getModifiers());
+  UIEventWithKeyState::setFromWebInputEventModifiers(
+      pointerEventInit,
+      static_cast<WebInputEvent::Modifiers>(mouseEvent.modifiers()));
 
   // Make sure chorded buttons fire pointermove instead of pointerup/down.
   if ((pointerEventName == EventTypeNames::pointerdown &&
-       (buttons &
-        ~buttonToButtonsBitfield(mouseEvent.pointerProperties().button)) !=
-           0) ||
+       (buttons & ~buttonToButtonsBitfield(mouseEvent.button)) != 0) ||
       (pointerEventName == EventTypeNames::pointerup && buttons != 0))
     pointerEventName = EventTypeNames::pointermove;
 
   pointerEventInit.setView(view);
 
   updateMousePointerEventInit(mouseEvent, view, &pointerEventInit);
 
   // Create coalesced events init structure only for pointermove.
   if (pointerEventName == EventTypeNames::pointermove) {
     HeapVector<Member<PointerEvent>> coalescedPointerEvents;
     for (const auto& coalescedMouseEvent : coalescedMouseEvents) {
-      DCHECK_EQ(mouseEvent.pointerProperties().id,
-                coalescedMouseEvent.pointerProperties().id);
+      DCHECK_EQ(mouseEvent.id, coalescedMouseEvent.id);
       // TODO(crbug.com/684292): We need further investigation of why the
       // following DCHECK fails.
-      // DCHECK_EQ(mouseEvent.pointerProperties().pointerType,
-      //          coalescedMouseEvent.pointerProperties().pointerType);
+      // DCHECK_EQ(mouseEvent.pointerType, coalescedMouseEvent.pointerType);
       PointerEventInit coalescedEventInit = pointerEventInit;
       updateMousePointerEventInit(coalescedMouseEvent, view,
                                   &coalescedEventInit);
       coalescedPointerEvents.push_back(
           PointerEvent::create(pointerEventName, coalescedEventInit));
     }
     pointerEventInit.setCoalescedEvents(coalescedPointerEvents);
   }
 
   return PointerEvent::create(pointerEventName, pointerEventInit);
@@ skipping 236 matching lines @@
     const WebPointerProperties& properties) const {
   if (properties.pointerType == WebPointerProperties::PointerType::Mouse)
     return PointerEventFactory::s_mouseId;
   IncomingId id(properties.pointerType, properties.id);
   if (m_pointerIncomingIdMapping.contains(id))
     return m_pointerIncomingIdMapping.get(id);
   return PointerEventFactory::s_invalidId;
 }
 
 }  // namespace blink