Remove PlatformMouseEvent and use WebMouseEvent instead

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

 /*
  * 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, 2004, 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 10 matching lines @@
  *
  */
 
 #ifndef MouseEvent_h
 #define MouseEvent_h
 
 #include "core/CoreExport.h"
 #include "core/events/EventDispatchMediator.h"
 #include "core/events/MouseEventInit.h"
 #include "core/events/UIEventWithKeyState.h"
-#include "platform/PlatformMouseEvent.h"
 #include "public/platform/WebMouseEvent.h"
 
 namespace blink {
 class DataTransfer;
 class EventDispatcher;
 
 class CORE_EXPORT MouseEvent : public UIEventWithKeyState {
   DEFINE_WRAPPERTYPEINFO();
 
  public:
+  enum SyntheticEventType {
+    // Real mouse input events or synthetic events that behave just like real
+    // events
+    RealOrIndistinguishable,
+    // Synthetic mouse events derived from touch input
+    FromTouch,
+    // Synthetic mouse events generated without a position, for example those
+    // generated from keyboard input.
+    Positionless,
+  };
+
   static MouseEvent* create() { return new MouseEvent; }
 
-  // TODO(mustaq): Should replace most/all of these params with a
-  // MouseEventInit.
-  static MouseEvent* create(const AtomicString& type,
-                            bool canBubble,
-                            bool cancelable,
-                            AbstractView*,
-                            int detail,
-                            int screenX,
-                            int screenY,
-                            int windowX,
-                            int windowY,
-                            int movementX,
-                            int movementY,
-                            PlatformEvent::Modifiers,
-                            short button,
-                            unsigned short buttons,
-                            EventTarget* relatedTarget,
-                            TimeTicks platformTimeStamp,
-                            PlatformMouseEvent::SyntheticEventType,
-                            const String& region,
-                            const PlatformMouseEvent*);
-
   static MouseEvent* create(const AtomicString& eventType,
                             AbstractView*,
-                            const PlatformMouseEvent&,
+                            const WebMouseEvent&,
                             int detail,
+                            const String& canvasRegionId,
                             Node* relatedTarget);
 
   static MouseEvent* create(ScriptState*,
                             const AtomicString& eventType,
                             const MouseEventInit&);
 
   static MouseEvent* create(const AtomicString& eventType,
                             AbstractView*,
                             Event* underlyingEvent,
                             SimulatedClickCreationScope);
@@ skipping 22 matching lines @@
 
   // WinIE uses 1,4,2 for left/middle/right but not for click (just for
   // mousedown/up, maybe others), but we will match the standard DOM.
   virtual short button() const { return m_button == -1 ? 0 : m_button; }
   unsigned short buttons() const { return m_buttons; }
   bool buttonDown() const { return m_button != -1; }
   EventTarget* relatedTarget() const { return m_relatedTarget.get(); }
   void setRelatedTarget(EventTarget* relatedTarget) {
     m_relatedTarget = relatedTarget;
   }
-  PlatformMouseEvent::SyntheticEventType getSyntheticEventType() const {
+  SyntheticEventType getSyntheticEventType() const {
     return m_syntheticEventType;
   }
   const String& region() const { return m_region; }
-  void setRegion(const String& region) { m_region = region; }
 
   Node* toElement() const;
   Node* fromElement() const;
 
   virtual DataTransfer* getDataTransfer() const { return nullptr; }
 
-  bool fromTouch() const {
-    return m_syntheticEventType == PlatformMouseEvent::FromTouch;
-  }
+  bool fromTouch() const { return m_syntheticEventType == FromTouch; }
 
   const AtomicString& interfaceName() const override;
 
   bool isMouseEvent() const override;
   int which() const final;
 
   EventDispatchMediator* createMediator() override;
 
   int clickCount() { return detail(); }
 
-  const PlatformMouseEvent* mouseEvent() const { return m_mouseEvent.get(); }
+  const WebMouseEvent* nativeEvent() const { return m_nativeEvent.get(); }
 
   enum class PositionType {
     Position,
     // Positionless mouse events are used, for example, for 'click' events from
     // keyboard input.  It's kind of surprising for a mouse event not to have a
     // position.
     Positionless
   };
 
   // Note that these values are adjusted to counter the effects of zoom, so that
@@ skipping 46 matching lines @@
   // the local frame.
   const DoublePoint& absoluteLocation() const { return m_absoluteLocation; }
 
   DECLARE_VIRTUAL_TRACE();
 
  protected:
   MouseEvent(const AtomicString& type,
              bool canBubble,
              bool cancelable,
              AbstractView*,
-             PlatformMouseEvent::SyntheticEventType,
+             const WebMouseEvent&,
+             int detail,
              const String& region,
-             const WebMouseEvent&);
+             EventTarget* relatedTarget);
 
   MouseEvent(const AtomicString& type,
              bool canBubble,
              bool cancelable,
              AbstractView*,
              int detail,
              int screenX,
              int screenY,
              int windowX,
              int windowY,
              int movementX,
              int movementY,
              PlatformEvent::Modifiers,
              short button,
              unsigned short buttons,
              EventTarget* relatedTarget,
              TimeTicks platformTimeStamp,
-             PlatformMouseEvent::SyntheticEventType,
-             const String& region,
-             const PlatformMouseEvent*);
+             SyntheticEventType,
+             const String& region);
 
   MouseEvent(const AtomicString& type, const MouseEventInit&);
 
   MouseEvent();
 
   short rawButton() const { return m_button; }
 
  private:
   friend class MouseEventDispatchMediator;
   void initMouseEventInternal(const AtomicString& type,
@@ skipping 24 matching lines @@
 
   DoublePoint m_pageLocation;
   DoublePoint m_layerLocation;
   DoublePoint m_offsetLocation;
   DoublePoint m_absoluteLocation;
   PositionType m_positionType;
   bool m_hasCachedRelativePosition;
   short m_button;
   unsigned short m_buttons;
   Member<EventTarget> m_relatedTarget;
-  PlatformMouseEvent::SyntheticEventType m_syntheticEventType;
+  SyntheticEventType m_syntheticEventType;
   String m_region;
-  std::unique_ptr<PlatformMouseEvent> m_mouseEvent;
+  std::unique_ptr<WebMouseEvent> m_nativeEvent;
 };
 
 class MouseEventDispatchMediator final : public EventDispatchMediator {
  public:
   static MouseEventDispatchMediator* create(MouseEvent*);
 
  private:
   explicit MouseEventDispatchMediator(MouseEvent*);
   MouseEvent& event() const;
 
   DispatchEventResult dispatchEvent(EventDispatcher&) const override;
 };
 
 DEFINE_EVENT_TYPE_CASTS(MouseEvent);
 
 }  // namespace blink
 
 #endif  // MouseEvent_h