Remove PlatformMouseEvent and use WebMouseEvent instead

third_party/WebKit/Source/core/input/GestureManager.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/input/GestureManager.h"
 
 #include "core/dom/Document.h"
 #include "core/dom/DocumentUserGestureToken.h"
 #include "core/editing/SelectionController.h"
 #include "core/events/GestureEvent.h"
@@ skipping 132 matching lines @@
   HitTestResult currentHitTest = targetedEvent.hitTestResult();
 
   // We use the adjusted position so the application isn't surprised to see a
   // event with co-ordinates outside the target's bounds.
   IntPoint adjustedPoint = frameView->rootFrameToContents(
       flooredIntPoint(gestureEvent.positionInRootFrame()));
 
   const unsigned modifiers = gestureEvent.modifiers();
 
   if (!m_suppressMouseEventsFromGestures) {
-    PlatformMouseEvent fakeMouseMove(
-        gestureEvent, WebPointerProperties::Button::NoButton,
-        PlatformEvent::MouseMoved,
-        /* clickCount */ 0, static_cast<PlatformEvent::Modifiers>(modifiers),
-        PlatformMouseEvent::FromTouch,
-        TimeTicks::FromSeconds(gestureEvent.timeStampSeconds()),
-        WebPointerProperties::PointerType::Mouse);
+    WebMouseEvent fakeMouseMove(
+        WebInputEvent::MouseMove, gestureEvent,
+        WebPointerProperties::Button::NoButton,
+        /* clickCount */ 0,
+        static_cast<PlatformEvent::Modifiers>(
+            modifiers | WebInputEvent::Modifiers::IsCompatibilityEventForTouch),
+        gestureEvent.timeStampSeconds());
     m_mouseEventManager->setMousePositionAndDispatchMouseEvent(
-        currentHitTest.innerNode(), EventTypeNames::mousemove, fakeMouseMove);
+        currentHitTest.innerNode(), currentHitTest.canvasRegionId(),
+        EventTypeNames::mousemove, fakeMouseMove);
   }
 
   // Do a new hit-test in case the mousemove event changed the DOM.
   // Note that if the original hit test wasn't over an element (eg. was over a
   // scrollbar) we don't want to re-hit-test because it may be in the wrong
   // frame (and there's no way the page could have seen the event anyway).  Also
   // note that the position of the frame may have changed, so we need to
   // recompute the content co-ordinates (updating layout/style as
   // hitTestResultAtPoint normally would).
   // FIXME: Use a hit-test cache to avoid unnecessary hit tests.
@@ skipping 13 matching lines @@
   IntPoint tappedPosition = flooredIntPoint(gestureEvent.positionInRootFrame());
   Node* tappedNonTextNode = tappedNode;
   UserGestureIndicator gestureIndicator(DocumentUserGestureToken::create(
       tappedNode ? &tappedNode->document() : nullptr));
 
   if (tappedNonTextNode && tappedNonTextNode->isTextNode())
     tappedNonTextNode = FlatTreeTraversal::parent(*tappedNonTextNode);
 
   m_mouseEventManager->setClickNode(tappedNonTextNode);
 
-  PlatformMouseEvent fakeMouseDown(
-      gestureEvent, WebPointerProperties::Button::Left,
-      PlatformEvent::MousePressed, gestureEvent.tapCount(),
-      static_cast<PlatformEvent::Modifiers>(modifiers |
-                                            PlatformEvent::LeftButtonDown),
-      PlatformMouseEvent::FromTouch,
-      TimeTicks::FromSeconds(gestureEvent.timeStampSeconds()),
-      WebPointerProperties::PointerType::Mouse);
+  WebMouseEvent fakeMouseDown(
+      WebInputEvent::MouseDown, gestureEvent,
+      WebPointerProperties::Button::Left, gestureEvent.tapCount(),
+      static_cast<PlatformEvent::Modifiers>(
+          modifiers | WebInputEvent::Modifiers::LeftButtonDown |
+          WebInputEvent::Modifiers::IsCompatibilityEventForTouch),
+      gestureEvent.timeStampSeconds());
 
   // TODO(mustaq): We suppress MEs plus all it's side effects. What would that
   // mean for for TEs?  What's the right balance here? crbug.com/617255
   WebInputEventResult mouseDownEventResult =
       WebInputEventResult::HandledSuppressed;
   if (!m_suppressMouseEventsFromGestures) {
     m_mouseEventManager->setClickCount(gestureEvent.tapCount());
 
     mouseDownEventResult =
         m_mouseEventManager->setMousePositionAndDispatchMouseEvent(
-            currentHitTest.innerNode(), EventTypeNames::mousedown,
-            fakeMouseDown);
+            currentHitTest.innerNode(), currentHitTest.canvasRegionId(),
+            EventTypeNames::mousedown, fakeMouseDown);
     m_selectionController->initializeSelectionState();
     if (mouseDownEventResult == WebInputEventResult::NotHandled)
       mouseDownEventResult = m_mouseEventManager->handleMouseFocus(
           currentHitTest,
           InputDeviceCapabilities::firesTouchEventsSourceCapabilities());
     if (mouseDownEventResult == WebInputEventResult::NotHandled)
       mouseDownEventResult = m_mouseEventManager->handleMousePressEvent(
           MouseEventWithHitTestResults(fakeMouseDown, currentHitTest));
   }
 
   if (currentHitTest.innerNode()) {
     DCHECK(gestureEvent.type() == WebInputEvent::GestureTap);
     HitTestResult result = currentHitTest;
     result.setToShadowHostIfInUserAgentShadowRoot();
     m_frame->chromeClient().onMouseDown(result.innerNode());
   }
 
   // FIXME: Use a hit-test cache to avoid unnecessary hit tests.
   // http://crbug.com/398920
   if (currentHitTest.innerNode()) {
     LocalFrame* mainFrame = m_frame->localFrameRoot();
     if (mainFrame && mainFrame->view())
       mainFrame->view()->updateAllLifecyclePhases();
     adjustedPoint = frameView->rootFrameToContents(tappedPosition);
     currentHitTest = EventHandlingUtil::hitTestResultInFrame(
         m_frame, adjustedPoint, hitType);
   }
 
-  PlatformMouseEvent fakeMouseUp(
-      gestureEvent, WebPointerProperties::Button::Left,
-      PlatformEvent::MouseReleased, gestureEvent.tapCount(),
-      static_cast<PlatformEvent::Modifiers>(modifiers),
-      PlatformMouseEvent::FromTouch,
-      TimeTicks::FromSeconds(gestureEvent.timeStampSeconds()),
-      WebPointerProperties::PointerType::Mouse);
+  WebMouseEvent fakeMouseUp(
+      WebInputEvent::MouseUp, gestureEvent, WebPointerProperties::Button::Left,
+      gestureEvent.tapCount(),
+      static_cast<PlatformEvent::Modifiers>(
+          modifiers | WebInputEvent::Modifiers::IsCompatibilityEventForTouch),
+      gestureEvent.timeStampSeconds());
   WebInputEventResult mouseUpEventResult =
       m_suppressMouseEventsFromGestures
           ? WebInputEventResult::HandledSuppressed
           : m_mouseEventManager->setMousePositionAndDispatchMouseEvent(
-                currentHitTest.innerNode(), EventTypeNames::mouseup,
-                fakeMouseUp);
+                currentHitTest.innerNode(), currentHitTest.canvasRegionId(),
+                EventTypeNames::mouseup, fakeMouseUp);
 
   WebInputEventResult clickEventResult = WebInputEventResult::NotHandled;
   if (tappedNonTextNode) {
     if (currentHitTest.innerNode()) {
       // Updates distribution because a mouseup (or mousedown) event listener
       // can make the tree dirty at dispatchMouseEvent() invocation above.
       // Unless distribution is updated, commonAncestor would hit DCHECK.  Both
       // tappedNonTextNode and currentHitTest.innerNode()) don't need to be
       // updated because commonAncestor() will exit early if their documents are
       // different.
       tappedNonTextNode->updateDistribution();
       Node* clickTargetNode = currentHitTest.innerNode()->commonAncestor(
           *tappedNonTextNode, EventHandlingUtil::parentForClickEvent);
       clickEventResult =
           m_mouseEventManager->setMousePositionAndDispatchMouseEvent(
-              clickTargetNode, EventTypeNames::click, fakeMouseUp);
+              clickTargetNode, String(), EventTypeNames::click, fakeMouseUp);
     }
     m_mouseEventManager->setClickNode(nullptr);
   }
 
   if (mouseUpEventResult == WebInputEventResult::NotHandled)
     mouseUpEventResult = m_mouseEventManager->handleMouseReleaseEvent(
         MouseEventWithHitTestResults(fakeMouseUp, currentHitTest));
   m_mouseEventManager->clearDragHeuristicState();
 
   WebInputEventResult eventResult = EventHandlingUtil::mergeEventResult(
@@ skipping 72 matching lines @@
     m_selectionController->handleGestureTwoFingerTap(targetedEvent);
   return sendContextMenuEventForGesture(targetedEvent);
 }
 
 WebInputEventResult GestureManager::sendContextMenuEventForGesture(
     const GestureEventWithHitTestResults& targetedEvent) {
   const WebGestureEvent& gestureEvent = targetedEvent.event();
   unsigned modifiers = gestureEvent.modifiers();
 
   if (!m_suppressMouseEventsFromGestures) {
-    // Send MouseMoved event prior to handling (https://crbug.com/485290).
-    PlatformMouseEvent fakeMouseMove(
-        gestureEvent, WebPointerProperties::Button::NoButton,
-        PlatformEvent::MouseMoved,
-        /* clickCount */ 0, static_cast<PlatformEvent::Modifiers>(modifiers),
-        PlatformMouseEvent::FromTouch,
-        TimeTicks::FromSeconds(gestureEvent.timeStampSeconds()),
-        WebPointerProperties::PointerType::Mouse);
+    // Send MouseMove event prior to handling (https://crbug.com/485290).
+    WebMouseEvent fakeMouseMove(
+        WebInputEvent::MouseMove, gestureEvent,
+        WebPointerProperties::Button::NoButton,
+        /* clickCount */ 0,
+        static_cast<PlatformEvent::Modifiers>(
+            modifiers | WebInputEvent::IsCompatibilityEventForTouch),
+        gestureEvent.timeStampSeconds());
     m_mouseEventManager->setMousePositionAndDispatchMouseEvent(
-        targetedEvent.hitTestResult().innerNode(), EventTypeNames::mousemove,
+        targetedEvent.hitTestResult().innerNode(),
+        targetedEvent.canvasRegionId(), EventTypeNames::mousemove,
         fakeMouseMove);
   }
 
-  PlatformEvent::EventType eventType = PlatformEvent::MousePressed;
+  WebInputEvent::Type eventType = WebInputEvent::MouseDown;
   if (m_frame->settings() && m_frame->settings()->getShowContextMenuOnMouseUp())
-    eventType = PlatformEvent::MouseReleased;
+    eventType = WebInputEvent::MouseUp;
 
-  PlatformMouseEvent mouseEvent(
-      gestureEvent, WebPointerProperties::Button::Right, eventType,
+  WebMouseEvent mouseEvent(
+      eventType, gestureEvent, WebPointerProperties::Button::Right,
       /* clickCount */ 1,
       static_cast<PlatformEvent::Modifiers>(
-          modifiers | PlatformEvent::Modifiers::RightButtonDown),
-      PlatformMouseEvent::FromTouch, TimeTicks::Now(),
-      WebPointerProperties::PointerType::Mouse);
+          modifiers | PlatformEvent::Modifiers::RightButtonDown |
+          WebInputEvent::IsCompatibilityEventForTouch),
+      gestureEvent.timeStampSeconds());
 
   if (!m_suppressMouseEventsFromGestures && m_frame->view()) {
     HitTestRequest request(HitTestRequest::Active);
     LayoutPoint documentPoint = m_frame->view()->rootFrameToContents(
         flooredIntPoint(targetedEvent.event().positionInRootFrame()));
     MouseEventWithHitTestResults mev =
         m_frame->document()->performMouseEventHitTest(request, documentPoint,
                                                       mouseEvent);
     m_mouseEventManager->handleMouseFocus(
         mev.hitTestResult(),
@@ skipping 26 matching lines @@
     return nullptr;
 
   return &m_frame->page()->frameHost();
 }
 
 TimeTicks GestureManager::getLastShowPressTimestamp() const {
   return m_lastShowPressTimestamp;
 }
 
 }  // namespace blink