Remove PlatformMouseEvent and use WebMouseEvent instead

third_party/WebKit/Source/core/input/MouseEventManager.h

 // 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.
 
 #ifndef MouseEventManager_h
 #define MouseEventManager_h
 
 #include "core/CoreExport.h"
 #include "core/dom/SynchronousMutationObserver.h"
 #include "core/input/BoundaryEventDispatcher.h"
 #include "core/page/DragActions.h"
 #include "core/page/EventWithHitTestResults.h"
-#include "platform/PlatformMouseEvent.h"
 #include "platform/Timer.h"
 #include "public/platform/WebInputEventResult.h"
+#include "public/platform/WebMouseEvent.h"
 #include "wtf/Allocator.h"
 #include "wtf/Time.h"
 
 namespace blink {
 
 class ContainerNode;
 class DragState;
 class DataTransfer;
 class Element;
 class FloatQuad;
@@ skipping 12 matching lines @@
   WTF_MAKE_NONCOPYABLE(MouseEventManager);
   USING_GARBAGE_COLLECTED_MIXIN(MouseEventManager);
 
  public:
   MouseEventManager(LocalFrame&, ScrollManager&);
   virtual ~MouseEventManager();
   DECLARE_TRACE();
 
   WebInputEventResult dispatchMouseEvent(EventTarget*,
                                          const AtomicString&,
-                                         const PlatformMouseEvent&,
+                                         const WebMouseEvent&,
+                                         const String& canvasRegionId,
                                          EventTarget* relatedTarget,
                                          bool checkForListener = false);
 
   WebInputEventResult setMousePositionAndDispatchMouseEvent(
       Node* targetNode,
+      const String& canvasRegionId,
       const AtomicString& eventType,
-      const PlatformMouseEvent&);
+      const WebMouseEvent&);
 
   WebInputEventResult dispatchMouseClickIfNeeded(
       const MouseEventWithHitTestResults&);
 
   WebInputEventResult dispatchDragSrcEvent(const AtomicString& eventType,
-                                           const PlatformMouseEvent&);
+                                           const WebMouseEvent&);
   WebInputEventResult dispatchDragEvent(const AtomicString& eventType,
                                         Node* target,
-                                        const PlatformMouseEvent&,
+                                        const WebMouseEvent&,
                                         DataTransfer*);
 
   // Resets the internal state of this object.
   void clear();
 
   void sendBoundaryEvents(EventTarget* exitedTarget,
                           EventTarget* enteredTarget,
-                          const PlatformMouseEvent& mousePlatformEvent);
+                          const String& canvasRegionId,
+                          const WebMouseEvent&);
 
-  void setNodeUnderMouse(Node*, const PlatformMouseEvent&);
+  void setNodeUnderMouse(Node*,
+                         const String& canvasRegionId,
+                         const WebMouseEvent&);
 
   WebInputEventResult handleMouseFocus(
       const HitTestResult&,
       InputDeviceCapabilities* sourceCapabilities);
 
   void fakeMouseMoveEventTimerFired(TimerBase*);
 
   void cancelFakeMouseMoveEvent();
   void dispatchFakeMouseMoveEventSoon();
   void dispatchFakeMouseMoveEventSoonInQuad(const FloatQuad&);
 
-  void setLastKnownMousePosition(const PlatformMouseEvent&);
+  void setLastKnownMousePosition(const WebMouseEvent&);
 
   bool handleDragDropIfPossible(const GestureEventWithHitTestResults&);
 
   WebInputEventResult handleMouseDraggedEvent(
       const MouseEventWithHitTestResults&);
   WebInputEventResult handleMousePressEvent(
       const MouseEventWithHitTestResults&);
   WebInputEventResult handleMouseReleaseEvent(
       const MouseEventWithHitTestResults&);
 
   static DragState& dragState();
 
   void focusDocumentView();
 
   // Resets the state that indicates the next events could cause a drag. It is
   // called when we realize the next events should not cause drag based on the
   // drag heuristics.
   void clearDragHeuristicState();
 
-  void dragSourceEndedAt(const PlatformMouseEvent&, DragOperation);
+  void dragSourceEndedAt(const WebMouseEvent&, DragOperation);
 
   void updateSelectionForMouseDrag();
 
-  void handleMousePressEventUpdateStates(const PlatformMouseEvent&);
+  void handleMousePressEventUpdateStates(const WebMouseEvent&);
 
   // Returns whether pan is handled and resets the state on release.
   bool handleSvgPanIfNeeded(bool isReleaseEvent);
 
   void invalidateClick();
 
   // TODO: These functions ideally should be private but the code needs more
   // refactoring to be able to remove the dependency from EventHandler.
   Node* getNodeUnderMouse();
   bool isMousePositionUnknown();
@@ skipping 16 matching lines @@
   void setClickCount(int);
 
   bool mouseDownMayStartDrag();
 
  private:
   class MouseEventBoundaryEventDispatcher : public BoundaryEventDispatcher {
     WTF_MAKE_NONCOPYABLE(MouseEventBoundaryEventDispatcher);
 
    public:
     MouseEventBoundaryEventDispatcher(MouseEventManager*,
-                                      const PlatformMouseEvent*,
-                                      EventTarget* exitedTarget);
+                                      const WebMouseEvent*,
+                                      EventTarget* exitedTarget,
+                                      const String& canvasRegionId);
 
    protected:
     void dispatchOut(EventTarget*, EventTarget* relatedTarget) override;
     void dispatchOver(EventTarget*, EventTarget* relatedTarget) override;
     void dispatchLeave(EventTarget*,
                        EventTarget* relatedTarget,
                        bool checkForListener) override;
     void dispatchEnter(EventTarget*,
                        EventTarget* relatedTarget,
                        bool checkForListener) override;
     AtomicString getLeaveEvent() override;
     AtomicString getEnterEvent() override;
 
    private:
     void dispatch(EventTarget*,
                   EventTarget* relatedTarget,
                   const AtomicString&,
-                  const PlatformMouseEvent&,
+                  const String& canvasRegionId,
+                  const WebMouseEvent&,
                   bool checkForListener);
     Member<MouseEventManager> m_mouseEventManager;
-    const PlatformMouseEvent* m_platformMouseEvent;
+    const WebMouseEvent* m_webMouseEvent;
     Member<EventTarget> m_exitedTarget;
+    String m_canvasRegionId;
   };
 
   // If the given element is a shadow host and its root has delegatesFocus=false
   // flag, slide focus to its inner element. Returns true if the resulting focus
   // is different from the given element.
   bool slideFocusOnShadowHostIfNecessary(const Element&);
 
   bool dragThresholdExceeded(const IntPoint&) const;
   bool handleDrag(const MouseEventWithHitTestResults&, DragInitiator);
   bool tryStartDrag(const MouseEventWithHitTestResults&);
@@ skipping 30 matching lines @@
   unsigned m_capturesDragging : 1;
   unsigned m_mouseDownMayStartDrag : 1;
 
   Member<Node> m_mousePressNode;
 
   int m_clickCount;
   Member<Node> m_clickNode;
 
   IntPoint m_mouseDownPos;  // In our view's coords.
   TimeTicks m_mouseDownTimestamp;
-  PlatformMouseEvent m_mouseDown;
+  WebMouseEvent m_mouseDown;
 
   LayoutPoint m_dragStartPos;
 
   TaskRunnerTimer<MouseEventManager> m_fakeMouseMoveEventTimer;
 };
 
 }  // namespace blink
 
 #endif  // MouseEventManager_h