Remove PlatformGestureEvent in favour of using WebGestureEvent

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 29 matching lines @@
 
 DEFINE_TRACE(GestureManager) {
   visitor->trace(m_frame);
   visitor->trace(m_scrollManager);
   visitor->trace(m_mouseEventManager);
   visitor->trace(m_pointerEventManager);
   visitor->trace(m_selectionController);
 }
 
 HitTestRequest::HitTestRequestType GestureManager::getHitTypeForGestureType(
-    PlatformEvent::EventType type) {
+    WebInputEvent::Type type) {
   HitTestRequest::HitTestRequestType hitType = HitTestRequest::TouchEvent;
   switch (type) {
-    case PlatformEvent::GestureShowPress:
-    case PlatformEvent::GestureTapUnconfirmed:
+    case WebInputEvent::GestureShowPress:
+    case WebInputEvent::GestureTapUnconfirmed:
       return hitType | HitTestRequest::Active;
-    case PlatformEvent::GestureTapDownCancel:
+    case WebInputEvent::GestureTapCancel:
       // A TapDownCancel received when no element is active shouldn't really be
       // changing hover state.
       if (!m_frame->document()->activeHoverElement())
         hitType |= HitTestRequest::ReadOnly;
       return hitType | HitTestRequest::Release;
-    case PlatformEvent::GestureTap:
+    case WebInputEvent::GestureTap:
       return hitType | HitTestRequest::Release;
-    case PlatformEvent::GestureTapDown:
-    case PlatformEvent::GestureLongPress:
-    case PlatformEvent::GestureLongTap:
-    case PlatformEvent::GestureTwoFingerTap:
+    case WebInputEvent::GestureTapDown:
+    case WebInputEvent::GestureLongPress:
+    case WebInputEvent::GestureLongTap:
+    case WebInputEvent::GestureTwoFingerTap:
       // FIXME: Shouldn't LongTap and TwoFingerTap clear the Active state?
       return hitType | HitTestRequest::Active | HitTestRequest::ReadOnly;
     default:
       NOTREACHED();
       return hitType | HitTestRequest::Active | HitTestRequest::ReadOnly;
   }
 }
 
 WebInputEventResult GestureManager::handleGestureEventInFrame(
     const GestureEventWithHitTestResults& targetedEvent) {
   DCHECK(!targetedEvent.event().isScrollEvent());
 
   Node* eventTarget = targetedEvent.hitTestResult().innerNode();
-  const PlatformGestureEvent& gestureEvent = targetedEvent.event();
+  const WebGestureEvent& gestureEvent = targetedEvent.event();
 
   if (m_scrollManager->canHandleGestureEvent(targetedEvent))
     return WebInputEventResult::HandledSuppressed;
 
   if (eventTarget) {
     GestureEvent* gestureDomEvent =
         GestureEvent::create(eventTarget->document().domWindow(), gestureEvent);
     if (gestureDomEvent) {
       DispatchEventResult gestureDomEventResult =
           eventTarget->dispatchEvent(gestureDomEvent);
       if (gestureDomEventResult != DispatchEventResult::NotCanceled) {
         DCHECK(gestureDomEventResult !=
                DispatchEventResult::CanceledByEventHandler);
         return EventHandlingUtil::toWebInputEventResult(gestureDomEventResult);
       }
     }
   }
 
-  switch (gestureEvent.type()) {
-    case PlatformEvent::GestureTapDown:
+  switch (gestureEvent.type) {
+    case WebInputEvent::GestureTapDown:
       return handleGestureTapDown(targetedEvent);
-    case PlatformEvent::GestureTap:
+    case WebInputEvent::GestureTap:
       return handleGestureTap(targetedEvent);
-    case PlatformEvent::GestureShowPress:
+    case WebInputEvent::GestureShowPress:
       return handleGestureShowPress();
-    case PlatformEvent::GestureLongPress:
+    case WebInputEvent::GestureLongPress:
       return handleGestureLongPress(targetedEvent);
-    case PlatformEvent::GestureLongTap:
+    case WebInputEvent::GestureLongTap:
       return handleGestureLongTap(targetedEvent);
-    case PlatformEvent::GestureTwoFingerTap:
+    case WebInputEvent::GestureTwoFingerTap:
       return handleGestureTwoFingerTap(targetedEvent);
-    case PlatformEvent::GesturePinchBegin:
-    case PlatformEvent::GesturePinchEnd:
-    case PlatformEvent::GesturePinchUpdate:
-    case PlatformEvent::GestureTapDownCancel:
-    case PlatformEvent::GestureTapUnconfirmed:
+    case WebInputEvent::GesturePinchBegin:
+    case WebInputEvent::GesturePinchEnd:
+    case WebInputEvent::GesturePinchUpdate:
+    case WebInputEvent::GestureTapCancel:
+    case WebInputEvent::GestureTapUnconfirmed:
       break;
     default:
       NOTREACHED();
   }
 
   return WebInputEventResult::NotHandled;
 }
 
 WebInputEventResult GestureManager::handleGestureTapDown(
     const GestureEventWithHitTestResults& targetedEvent) {
   m_suppressMouseEventsFromGestures =
       m_pointerEventManager->primaryPointerdownCanceled(
-          targetedEvent.event().uniqueTouchEventId());
+          targetedEvent.event().uniqueTouchEventId);
   return WebInputEventResult::NotHandled;
 }
 
 WebInputEventResult GestureManager::handleGestureTap(
     const GestureEventWithHitTestResults& targetedEvent) {
   FrameView* frameView(m_frame->view());
-  const PlatformGestureEvent& gestureEvent = targetedEvent.event();
+  const WebGestureEvent& gestureEvent = targetedEvent.event();
   HitTestRequest::HitTestRequestType hitType =
-      getHitTypeForGestureType(gestureEvent.type());
+      getHitTypeForGestureType(gestureEvent.type);
   uint64_t preDispatchDomTreeVersion = m_frame->document()->domTreeVersion();
   uint64_t preDispatchStyleVersion = m_frame->document()->styleVersion();
 
   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(gestureEvent.position());
+  IntPoint adjustedPoint = frameView->rootFrameToContents(
+      flooredIntPoint(gestureEvent.positionInRootFrame()));
 
-  const unsigned modifiers = gestureEvent.getModifiers();
+  const unsigned modifiers = gestureEvent.modifiers;
 
   if (!m_suppressMouseEventsFromGestures) {
     PlatformMouseEvent fakeMouseMove(
-        gestureEvent.position(), gestureEvent.globalPosition(),
-        WebPointerProperties::Button::NoButton, PlatformEvent::MouseMoved,
+        gestureEvent, WebPointerProperties::Button::NoButton,
+        PlatformEvent::MouseMoved,
         /* clickCount */ 0, static_cast<PlatformEvent::Modifiers>(modifiers),
-        PlatformMouseEvent::FromTouch, gestureEvent.timestamp(),
+        PlatformMouseEvent::FromTouch,
+        TimeTicks::FromSeconds(gestureEvent.timeStampSeconds),
         WebPointerProperties::PointerType::Mouse);
     m_mouseEventManager->setMousePositionAndDispatchMouseEvent(
         currentHitTest.innerNode(), 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.
   // http://crbug.com/398920
   if (currentHitTest.innerNode()) {
     LocalFrame* mainFrame = m_frame->localFrameRoot();
     if (mainFrame && mainFrame->view())
       mainFrame->view()->updateLifecycleToCompositingCleanPlusScrolling();
-    adjustedPoint = frameView->rootFrameToContents(gestureEvent.position());
+    adjustedPoint = frameView->rootFrameToContents(
+        flooredIntPoint(gestureEvent.positionInRootFrame()));
     currentHitTest = EventHandlingUtil::hitTestResultInFrame(
         m_frame, adjustedPoint, hitType);
   }
 
   // Capture data for showUnhandledTapUIIfNeeded.
   Node* tappedNode = currentHitTest.innerNode();
-  IntPoint tappedPosition = gestureEvent.position();
+  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.position(), gestureEvent.globalPosition(),
-      WebPointerProperties::Button::Left, PlatformEvent::MousePressed,
-      gestureEvent.tapCount(), static_cast<PlatformEvent::Modifiers>(
-                                   modifiers | PlatformEvent::LeftButtonDown),
-      PlatformMouseEvent::FromTouch, gestureEvent.timestamp(),
+      gestureEvent, WebPointerProperties::Button::Left,
+      PlatformEvent::MousePressed, gestureEvent.tapCount(),
+      static_cast<PlatformEvent::Modifiers>(modifiers |
+                                            PlatformEvent::LeftButtonDown),
+      PlatformMouseEvent::FromTouch,
+      TimeTicks::FromSeconds(gestureEvent.timeStampSeconds),
       WebPointerProperties::PointerType::Mouse);
 
   // 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);
     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() == PlatformEvent::GestureTap);
+    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(gestureEvent.position());
+    adjustedPoint = frameView->rootFrameToContents(tappedPosition);
     currentHitTest = EventHandlingUtil::hitTestResultInFrame(
         m_frame, adjustedPoint, hitType);
   }
 
   PlatformMouseEvent fakeMouseUp(
-      gestureEvent.position(), gestureEvent.globalPosition(),
-      WebPointerProperties::Button::Left, PlatformEvent::MouseReleased,
-      gestureEvent.tapCount(), static_cast<PlatformEvent::Modifiers>(modifiers),
-      PlatformMouseEvent::FromTouch, gestureEvent.timestamp(),
+      gestureEvent, WebPointerProperties::Button::Left,
+      PlatformEvent::MouseReleased, gestureEvent.tapCount(),
+      static_cast<PlatformEvent::Modifiers>(modifiers),
+      PlatformMouseEvent::FromTouch,
+      TimeTicks::FromSeconds(gestureEvent.timeStampSeconds),
       WebPointerProperties::PointerType::Mouse);
   WebInputEventResult mouseUpEventResult =
       m_suppressMouseEventsFromGestures
           ? WebInputEventResult::HandledSuppressed
           : m_mouseEventManager->setMousePositionAndDispatchMouseEvent(
                 currentHitTest.innerNode(), EventTypeNames::mouseup,
                 fakeMouseUp);
 
   WebInputEventResult clickEventResult = WebInputEventResult::NotHandled;
   if (tappedNonTextNode) {
@@ skipping 33 matching lines @@
     IntPoint tappedPositionInViewport =
         frameHost()->visualViewport().rootFrameToViewport(tappedPosition);
     m_frame->chromeClient().showUnhandledTapUIIfNeeded(
         tappedPositionInViewport, tappedNode, domTreeChanged || styleChanged);
   }
   return eventResult;
 }
 
 WebInputEventResult GestureManager::handleGestureLongPress(
     const GestureEventWithHitTestResults& targetedEvent) {
-  const PlatformGestureEvent& gestureEvent = targetedEvent.event();
+  const WebGestureEvent& gestureEvent = targetedEvent.event();
 
   // FIXME: Ideally we should try to remove the extra mouse-specific hit-tests
   // here (re-using the supplied HitTestResult), but that will require some
   // overhaul of the touch drag-and-drop code and LongPress is such a special
   // scenario that it's unlikely to matter much in practice.
 
-  IntPoint hitTestPoint =
-      m_frame->view()->rootFrameToContents(gestureEvent.position());
+  IntPoint hitTestPoint = m_frame->view()->rootFrameToContents(
+      flooredIntPoint(gestureEvent.positionInRootFrame()));
   HitTestResult hitTestResult =
       m_frame->eventHandler().hitTestResultAtPoint(hitTestPoint);
 
   m_longTapShouldInvokeContextMenu = false;
   bool hitTestContainsLinks = hitTestResult.URLElement() ||
                               !hitTestResult.absoluteImageURL().isNull() ||
                               !hitTestResult.absoluteMediaURL().isNull();
 
   if (!hitTestContainsLinks &&
       m_mouseEventManager->handleDragDropIfPossible(targetedEvent)) {
@@ skipping 23 matching lines @@
 }
 
 WebInputEventResult GestureManager::handleGestureTwoFingerTap(
     const GestureEventWithHitTestResults& targetedEvent) {
   m_selectionController->handleGestureTwoFingerTap(targetedEvent);
   return sendContextMenuEventForGesture(targetedEvent);
 }
 
 WebInputEventResult GestureManager::sendContextMenuEventForGesture(
     const GestureEventWithHitTestResults& targetedEvent) {
-  const PlatformGestureEvent& gestureEvent = targetedEvent.event();
-  unsigned modifiers = gestureEvent.getModifiers();
+  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.position(), gestureEvent.globalPosition(),
-        WebPointerProperties::Button::NoButton, PlatformEvent::MouseMoved,
+        gestureEvent, WebPointerProperties::Button::NoButton,
+        PlatformEvent::MouseMoved,
         /* clickCount */ 0, static_cast<PlatformEvent::Modifiers>(modifiers),
-        PlatformMouseEvent::FromTouch, gestureEvent.timestamp(),
+        PlatformMouseEvent::FromTouch,
+        TimeTicks::FromSeconds(gestureEvent.timeStampSeconds),
         WebPointerProperties::PointerType::Mouse);
     m_mouseEventManager->setMousePositionAndDispatchMouseEvent(
         targetedEvent.hitTestResult().innerNode(), EventTypeNames::mousemove,
         fakeMouseMove);
   }
 
   PlatformEvent::EventType eventType = PlatformEvent::MousePressed;
   if (m_frame->settings() && m_frame->settings()->showContextMenuOnMouseUp())
     eventType = PlatformEvent::MouseReleased;
 
   PlatformMouseEvent mouseEvent(
-      targetedEvent.event().position(), targetedEvent.event().globalPosition(),
-      WebPointerProperties::Button::Right, eventType, /* clickCount */ 1,
+      gestureEvent, WebPointerProperties::Button::Right, eventType,
+      /* clickCount */ 1,
       static_cast<PlatformEvent::Modifiers>(
           modifiers | PlatformEvent::Modifiers::RightButtonDown),
       PlatformMouseEvent::FromTouch, TimeTicks::Now(),
       WebPointerProperties::PointerType::Mouse);
 
   if (!m_suppressMouseEventsFromGestures && m_frame->view()) {
     HitTestRequest request(HitTestRequest::Active);
-    LayoutPoint documentPoint =
-        m_frame->view()->rootFrameToContents(targetedEvent.event().position());
+    LayoutPoint documentPoint = m_frame->view()->rootFrameToContents(
+        flooredIntPoint(targetedEvent.event().positionInRootFrame()));
     MouseEventWithHitTestResults mev =
         m_frame->document()->performMouseEventHitTest(request, documentPoint,
                                                       mouseEvent);
     m_mouseEventManager->handleMouseFocus(
         mev.hitTestResult(),
         InputDeviceCapabilities::firesTouchEventsSourceCapabilities());
   }
   return m_frame->eventHandler().sendContextMenuEvent(mouseEvent);
 }
 
@@ skipping 21 matching lines @@
     return nullptr;
 
   return &m_frame->page()->frameHost();
 }
 
 TimeTicks GestureManager::getLastShowPressTimestamp() const {
   return m_lastShowPressTimestamp;
 }
 
 }  // namespace blink