Remove PlatformEvent it is no longer used.

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

 /*
  * Copyright (C) 2001 Peter Kelly (pmk@post.com)
  * Copyright (C) 2001 Tobias Anton (anton@stud.fbi.fh-darmstadt.de)
  * Copyright (C) 2006 Samuel Weinig (sam.weinig@gmail.com)
  * Copyright (C) 2003, 2005, 2006, 2008 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
@@ skipping 88 matching lines @@
   bool isCancelable = !isMouseEnterOrLeave;
   bool isBubbling = !isMouseEnterOrLeave;
   return new MouseEvent(eventType, isBubbling, isCancelable, view, event,
                         detail, canvasRegionId, relatedTarget);
 }
 
 MouseEvent* MouseEvent::create(const AtomicString& eventType,
                                AbstractView* view,
                                Event* underlyingEvent,
                                SimulatedClickCreationScope creationScope) {
-  PlatformEvent::Modifiers modifiers = PlatformEvent::NoModifiers;
+  WebInputEvent::Modifiers modifiers = WebInputEvent::NoModifiers;
   if (UIEventWithKeyState* keyStateEvent =
           findEventWithKeyState(underlyingEvent)) {
     modifiers = keyStateEvent->modifiers();
   }
 
   SyntheticEventType syntheticType = Positionless;
   int screenX = 0;
   int screenY = 0;
   if (underlyingEvent && underlyingEvent->isMouseEvent()) {
     syntheticType = RealOrIndistinguishable;
@@ skipping 34 matching lines @@
                        const WebMouseEvent& event,
                        int detail,
                        const String& region,
                        EventTarget* relatedTarget)
     : UIEventWithKeyState(
           eventType,
           canBubble,
           cancelable,
           abstractView,
           detail,
-          static_cast<PlatformEvent::Modifiers>(event.modifiers()),
+          static_cast<WebInputEvent::Modifiers>(event.modifiers()),
           TimeTicks::FromSeconds(event.timeStampSeconds()),
           event.fromTouch()
               ? InputDeviceCapabilities::firesTouchEventsSourceCapabilities()
               : InputDeviceCapabilities::
                     doesntFireTouchEventsSourceCapabilities()),
       m_screenLocation(event.globalX, event.globalY),
       m_movementDelta(flooredIntPoint(event.movementInRootFrame())),
       m_positionType(PositionType::Position),
       m_button(static_cast<short>(event.button)),
-      m_buttons(platformModifiersToButtons(event.modifiers())),
+      m_buttons(webInputEventModifiersToButtons(event.modifiers())),
       m_relatedTarget(relatedTarget),
       m_syntheticEventType(event.fromTouch() ? FromTouch
                                              : RealOrIndistinguishable),
       m_region(region) {
   IntPoint rootFrameCoordinates = flooredIntPoint(event.positionInRootFrame());
   initCoordinatesFromRootFrame(rootFrameCoordinates.x(),
                                rootFrameCoordinates.y());
 }
 
 MouseEvent::MouseEvent(const AtomicString& eventType,
                        bool canBubble,
                        bool cancelable,
                        AbstractView* abstractView,
                        int detail,
                        int screenX,
                        int screenY,
                        int windowX,
                        int windowY,
                        int movementX,
                        int movementY,
-                       PlatformEvent::Modifiers modifiers,
+                       WebInputEvent::Modifiers modifiers,
                        short button,
                        unsigned short buttons,
                        EventTarget* relatedTarget,
                        TimeTicks platformTimeStamp,
                        SyntheticEventType syntheticEventType,
                        const String& region)
     : UIEventWithKeyState(
           eventType,
           canBubble,
           cancelable,
@@ skipping 74 matching lines @@
   // Correct values are computed lazily, see computeRelativePosition.
   m_layerLocation = m_pageLocation;
   m_offsetLocation = m_pageLocation;
 
   computePageLocation();
   m_hasCachedRelativePosition = false;
 }
 
 MouseEvent::~MouseEvent() {}
 
-unsigned short MouseEvent::platformModifiersToButtons(unsigned modifiers) {
+unsigned short MouseEvent::webInputEventModifiersToButtons(unsigned modifiers) {
   unsigned short buttons = 0;
 
-  if (modifiers & PlatformEvent::LeftButtonDown)
+  if (modifiers & WebInputEvent::LeftButtonDown)
     buttons |= static_cast<unsigned short>(WebPointerProperties::Buttons::Left);
-  if (modifiers & PlatformEvent::RightButtonDown)
+  if (modifiers & WebInputEvent::RightButtonDown)
     buttons |=
         static_cast<unsigned short>(WebPointerProperties::Buttons::Right);
-  if (modifiers & PlatformEvent::MiddleButtonDown)
+  if (modifiers & WebInputEvent::MiddleButtonDown)
     buttons |=
         static_cast<unsigned short>(WebPointerProperties::Buttons::Middle);
 
   return buttons;
 }
 
 void MouseEvent::initMouseEvent(ScriptState* scriptState,
                                 const AtomicString& type,
                                 bool canBubble,
                                 bool cancelable,
@@ skipping 26 matching lines @@
 void MouseEvent::initMouseEventInternal(
     const AtomicString& type,
     bool canBubble,
     bool cancelable,
     AbstractView* view,
     int detail,
     int screenX,
     int screenY,
     int clientX,
     int clientY,
-    PlatformEvent::Modifiers modifiers,
+    WebInputEvent::Modifiers modifiers,
     short button,
     EventTarget* relatedTarget,
     InputDeviceCapabilities* sourceCapabilities,
     unsigned short buttons) {
   initUIEventInternal(type, canBubble, cancelable, relatedTarget, view, detail,
                       sourceCapabilities);
 
   m_screenLocation = IntPoint(screenX, screenY);
   m_button = button;
   m_buttons = buttons;
@@ skipping 205 matching lines @@
 
 int MouseEvent::offsetY() {
   if (!hasPosition())
     return 0;
   if (!m_hasCachedRelativePosition)
     computeRelativePosition();
   return std::round(m_offsetLocation.y());
 }
 
 }  // namespace blink