Remove PlatformMouseEvent and use WebMouseEvent instead

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 14 matching lines @@
 #include "bindings/core/v8/DOMWrapperWorld.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "core/dom/Element.h"
 #include "core/events/EventDispatcher.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalDOMWindow.h"
 #include "core/frame/LocalFrame.h"
 #include "core/layout/LayoutObject.h"
 #include "core/paint/PaintLayer.h"
 #include "core/svg/SVGElement.h"
-#include "platform/PlatformMouseEvent.h"
 #include "public/platform/WebPointerProperties.h"
 
 namespace blink {
 
 namespace {
 
 LayoutSize contentsScrollOffset(AbstractView* abstractView) {
   if (!abstractView || !abstractView->isLocalDOMWindow())
     return LayoutSize();
   LocalFrame* frame = toLocalDOMWindow(abstractView)->frame();
@@ skipping 38 matching lines @@
                                const MouseEventInit& initializer) {
   if (scriptState && scriptState->world().isIsolatedWorld())
     UIEventWithKeyState::didCreateEventInIsolatedWorld(
         initializer.ctrlKey(), initializer.altKey(), initializer.shiftKey(),
         initializer.metaKey());
   return new MouseEvent(type, initializer);
 }
 
 MouseEvent* MouseEvent::create(const AtomicString& eventType,
                                AbstractView* view,
-                               const PlatformMouseEvent& event,
+                               const WebMouseEvent& event,
                                int detail,
+                               const String& canvasRegionId,
                                Node* relatedTarget) {
   bool isMouseEnterOrLeave = eventType == EventTypeNames::mouseenter ||
                              eventType == EventTypeNames::mouseleave;
   bool isCancelable = !isMouseEnterOrLeave;
   bool isBubbling = !isMouseEnterOrLeave;
-
-  return MouseEvent::create(
-      eventType, isBubbling, isCancelable, view, detail,
-      event.globalPosition().x(), event.globalPosition().y(),
-      event.position().x(), event.position().y(), event.movementDelta().x(),
-      event.movementDelta().y(), event.getModifiers(),
-      static_cast<short>(event.pointerProperties().button),
-      platformModifiersToButtons(event.getModifiers()), relatedTarget,
-      event.timestamp(), event.getSyntheticEventType(), event.region(), &event);
-}
-
-MouseEvent* MouseEvent::create(
-    const AtomicString& type,
-    bool canBubble,
-    bool cancelable,
-    AbstractView* view,
-    int detail,
-    int screenX,
-    int screenY,
-    int windowX,
-    int windowY,
-    int movementX,
-    int movementY,
-    PlatformEvent::Modifiers modifiers,
-    short button,
-    unsigned short buttons,
-    EventTarget* relatedTarget,
-    TimeTicks platformTimeStamp,
-    PlatformMouseEvent::SyntheticEventType syntheticEventType,
-    const String& region,
-    const PlatformMouseEvent* mouseEvent) {
-  return new MouseEvent(
-      type, canBubble, cancelable, view, detail, screenX, screenY, windowX,
-      windowY, movementX, movementY, modifiers, button, buttons, relatedTarget,
-      platformTimeStamp, syntheticEventType, region, mouseEvent);
+  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;
   if (UIEventWithKeyState* keyStateEvent =
           findEventWithKeyState(underlyingEvent)) {
     modifiers = keyStateEvent->modifiers();
   }
 
-  PlatformMouseEvent::SyntheticEventType syntheticType =
-      PlatformMouseEvent::Positionless;
+  SyntheticEventType syntheticType = Positionless;
   int screenX = 0;
   int screenY = 0;
   if (underlyingEvent && underlyingEvent->isMouseEvent()) {
-    syntheticType = PlatformMouseEvent::RealOrIndistinguishable;
+    syntheticType = RealOrIndistinguishable;
     MouseEvent* mouseEvent = toMouseEvent(underlyingEvent);
     screenX = mouseEvent->screenX();
     screenY = mouseEvent->screenY();
   }
 
   TimeTicks timestamp =
       underlyingEvent ? underlyingEvent->platformTimeStamp() : TimeTicks::Now();
-  MouseEvent* createdEvent = MouseEvent::create(
+  MouseEvent* createdEvent = new MouseEvent(
       eventType, true, true, view, 0, screenX, screenY, 0, 0, 0, 0, modifiers,
-      0, 0, nullptr, timestamp, syntheticType, String(), nullptr);
+      0, 0, nullptr, timestamp, syntheticType, String());
 
   createdEvent->setTrusted(creationScope ==
                            SimulatedClickCreationScope::FromUserAgent);
   createdEvent->setUnderlyingEvent(underlyingEvent);
-  if (syntheticType == PlatformMouseEvent::RealOrIndistinguishable) {
+  if (syntheticType == RealOrIndistinguishable) {
     MouseEvent* mouseEvent = toMouseEvent(createdEvent->underlyingEvent());
     createdEvent->initCoordinates(mouseEvent->clientX(), mouseEvent->clientY());
   }
 
   return createdEvent;
 }
 
 MouseEvent::MouseEvent()
     : m_positionType(PositionType::Position),
       m_hasCachedRelativePosition(false),
       m_button(0),
       m_buttons(0),
       m_relatedTarget(nullptr),
-      m_syntheticEventType(PlatformMouseEvent::RealOrIndistinguishable) {}
+      m_syntheticEventType(RealOrIndistinguishable) {}
 
-MouseEvent::MouseEvent(
-    const AtomicString& eventType,
-    bool canBubble,
-    bool cancelable,
-    AbstractView* abstractView,
-    PlatformMouseEvent::SyntheticEventType syntheticEventType,
-    const String& region,
-    const WebMouseEvent& event)
+MouseEvent::MouseEvent(const AtomicString& eventType,
+                       bool canBubble,
+                       bool cancelable,
+                       AbstractView* abstractView,
+                       const WebMouseEvent& event,
+                       int detail,
+                       const String& region,
+                       EventTarget* relatedTarget)
     : UIEventWithKeyState(
           eventType,
           canBubble,
           cancelable,
           abstractView,
-          0,
+          detail,
           static_cast<PlatformEvent::Modifiers>(event.modifiers()),
           TimeTicks::FromSeconds(event.timeStampSeconds()),
-          syntheticEventType == PlatformMouseEvent::FromTouch
+          event.fromTouch()
               ? InputDeviceCapabilities::firesTouchEventsSourceCapabilities()
               : InputDeviceCapabilities::
                     doesntFireTouchEventsSourceCapabilities()),
       m_screenLocation(event.globalX, event.globalY),
       m_movementDelta(flooredIntPoint(event.movementInRootFrame())),
-      m_positionType(syntheticEventType == PlatformMouseEvent::Positionless
-                         ? PositionType::Positionless
-                         : PositionType::Position),
-      m_button(0),
+      m_positionType(PositionType::Position),
+      m_button(static_cast<short>(event.button)),
       m_buttons(platformModifiersToButtons(event.modifiers())),
-      m_syntheticEventType(syntheticEventType),
+      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,
-    short button,
-    unsigned short buttons,
-    EventTarget* relatedTarget,
-    TimeTicks platformTimeStamp,
-    PlatformMouseEvent::SyntheticEventType syntheticEventType,
-    const String& region,
-    const PlatformMouseEvent* mouseEvent)
+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,
+                       short button,
+                       unsigned short buttons,
+                       EventTarget* relatedTarget,
+                       TimeTicks platformTimeStamp,
+                       SyntheticEventType syntheticEventType,
+                       const String& region)
     : UIEventWithKeyState(
           eventType,
           canBubble,
           cancelable,
           abstractView,
           detail,
           modifiers,
           platformTimeStamp,
-          syntheticEventType == PlatformMouseEvent::FromTouch
+          syntheticEventType == FromTouch
               ? InputDeviceCapabilities::firesTouchEventsSourceCapabilities()
               : InputDeviceCapabilities::
                     doesntFireTouchEventsSourceCapabilities()),
       m_screenLocation(screenX, screenY),
       m_movementDelta(movementX, movementY),
-      m_positionType(syntheticEventType == PlatformMouseEvent::Positionless
+      m_positionType(syntheticEventType == Positionless
                          ? PositionType::Positionless
                          : PositionType::Position),
       m_button(button),
       m_buttons(buttons),
       m_relatedTarget(relatedTarget),
       m_syntheticEventType(syntheticEventType),
       m_region(region) {
-  if (mouseEvent)
-    m_mouseEvent.reset(new PlatformMouseEvent(*mouseEvent));
   initCoordinatesFromRootFrame(windowX, windowY);
 }
 
 MouseEvent::MouseEvent(const AtomicString& eventType,
                        const MouseEventInit& initializer)
     : UIEventWithKeyState(eventType, initializer),
       m_screenLocation(
           DoublePoint(initializer.screenX(), initializer.screenY())),
       m_movementDelta(
           IntPoint(initializer.movementX(), initializer.movementY())),
       m_positionType(PositionType::Position),
       m_button(initializer.button()),
       m_buttons(initializer.buttons()),
       m_relatedTarget(initializer.relatedTarget()),
-      m_syntheticEventType(PlatformMouseEvent::RealOrIndistinguishable),
+      m_syntheticEventType(RealOrIndistinguishable),
       m_region(initializer.region()) {
   initCoordinates(initializer.clientX(), initializer.clientY());
 }
 
 void MouseEvent::initCoordinates(const double clientX, const double clientY) {
   // Set up initial values for coordinates.
   // Correct values are computed lazily, see computeRelativePosition.
   m_clientLocation = DoublePoint(clientX, clientY);
   m_pageLocation = m_clientLocation + DoubleSize(contentsScrollOffset(view()));
 
@@ skipping 312 matching lines @@
 
 int MouseEvent::offsetY() {
   if (!hasPosition())
     return 0;
   if (!m_hasCachedRelativePosition)
     computeRelativePosition();
   return std::round(m_offsetLocation.y());
 }
 
 }  // namespace blink