Remove PlatformGestureEvent in favour of using WebGestureEvent

third_party/WebKit/Source/core/input/EventHandler.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights
  * reserved.
  * Copyright (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  * Copyright (C) 2012 Digia Plc. and/or its subsidiary(-ies)
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
@@ skipping 69 matching lines @@
 #include "core/page/DragState.h"
 #include "core/page/FocusController.h"
 #include "core/page/FrameTree.h"
 #include "core/page/Page.h"
 #include "core/page/TouchAdjustment.h"
 #include "core/page/scrolling/ScrollState.h"
 #include "core/paint/PaintLayer.h"
 #include "core/style/ComputedStyle.h"
 #include "core/style/CursorData.h"
 #include "core/svg/SVGDocumentExtensions.h"
-#include "platform/PlatformGestureEvent.h"
 #include "platform/PlatformTouchEvent.h"
 #include "platform/PlatformWheelEvent.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/WindowsKeyboardCodes.h"
 #include "platform/geometry/FloatPoint.h"
 #include "platform/graphics/Image.h"
 #include "platform/heap/Handle.h"
 #include "platform/scroll/ScrollAnimatorBase.h"
 #include "platform/scroll/Scrollbar.h"
 #include "platform/tracing/TraceEvent.h"
@@ skipping 1228 matching lines @@
         WheelEvent::create(event, node->document().domWindow());
     DispatchEventResult domEventResult = node->dispatchEvent(domEvent);
     if (domEventResult != DispatchEventResult::NotCanceled)
       return EventHandlingUtil::toWebInputEventResult(domEventResult);
   }
 
   return WebInputEventResult::NotHandled;
 }
 
 WebInputEventResult EventHandler::handleGestureEvent(
-    const PlatformGestureEvent& gestureEvent) {
+    const WebGestureEvent& gestureEvent) {
   // Propagation to inner frames is handled below this function.
   ASSERT(m_frame == m_frame->localFrameRoot());
 
   // Scrolling-related gesture events invoke EventHandler recursively for each
   // frame down the chain, doing a single-frame hit-test per frame. This matches
   // handleWheelEvent.
   // FIXME: Add a test that traverses this path, e.g. for devtools overlay.
   if (gestureEvent.isScrollEvent())
     return handleGestureScrollEvent(gestureEvent);
 
@@ skipping 14 matching lines @@
   // Propagation to inner frames is handled below this function.
   ASSERT(m_frame == m_frame->localFrameRoot());
 
   // Non-scrolling related gesture events do a single cross-frame hit-test and
   // jump directly to the inner most frame. This matches handleMousePressEvent
   // etc.
   ASSERT(!targetedEvent.event().isScrollEvent());
 
   // Update mouseout/leave/over/enter events before jumping directly to the
   // inner most frame.
-  if (targetedEvent.event().type() == PlatformEvent::GestureTap)
+  if (targetedEvent.event().type == WebInputEvent::GestureTap)
     updateGestureTargetNodeForMouseEvent(targetedEvent);
 
   // Route to the correct frame.
   if (LocalFrame* innerFrame = targetedEvent.hitTestResult().innerNodeFrame())
     return innerFrame->eventHandler().handleGestureEventInFrame(targetedEvent);
 
   // No hit test result, handle in root instance. Perhaps we should just return
   // false instead?
   return m_gestureManager->handleGestureEventInFrame(targetedEvent);
 }
 
 WebInputEventResult EventHandler::handleGestureEventInFrame(
     const GestureEventWithHitTestResults& targetedEvent) {
   return m_gestureManager->handleGestureEventInFrame(targetedEvent);
 }
 
 WebInputEventResult EventHandler::handleGestureScrollEvent(
-    const PlatformGestureEvent& gestureEvent) {
+    const WebGestureEvent& gestureEvent) {
   TRACE_EVENT0("input", "EventHandler::handleGestureScrollEvent");
   if (!m_frame->host())
     return WebInputEventResult::NotHandled;
 
   return m_scrollManager->handleGestureScrollEvent(gestureEvent);
 }
 
 WebInputEventResult EventHandler::handleGestureScrollEnd(
-    const PlatformGestureEvent& gestureEvent) {
+    const WebGestureEvent& gestureEvent) {
   if (!m_frame->host())
     return WebInputEventResult::NotHandled;
-
   return m_scrollManager->handleGestureScrollEnd(gestureEvent);
 }
 
 void EventHandler::setMouseDownMayStartAutoscroll() {
   m_mouseEventManager->setMouseDownMayStartAutoscroll();
 }
 
 bool EventHandler::isScrollbarHandlingGestures() const {
   return m_scrollManager->isScrollbarHandlingGestures();
 }
 
 bool EventHandler::shouldApplyTouchAdjustment(
-    const PlatformGestureEvent& event) const {
+    const WebGestureEvent& event) const {
   if (m_frame->settings() && !m_frame->settings()->touchAdjustmentEnabled())
     return false;
-  return !event.area().isEmpty();
+  return !event.tapAreaInRootFrame().isEmpty();
 }
 
 bool EventHandler::bestClickableNodeForHitTestResult(
     const HitTestResult& result,
     IntPoint& targetPoint,
     Node*& targetNode) {
   // FIXME: Unify this with the other best* functions which are very similar.
 
   TRACE_EVENT0("input", "EventHandler::bestClickableNodeForHitTestResult");
   ASSERT(result.isRectBasedTest());
@@ skipping 184 matching lines @@
           indexEnteredFrameChain ? enteredFrameChain[indexEnteredFrameChain - 1]
                                  : nullptr;
       if (exitedFrameInDocument != lastEnteredFrameInDocument)
         exitedFrameChain.append(exitedFrameInDocument);
       else if (nextExitedFrameInDocument && indexEnteredFrameChain)
         --indexEnteredFrameChain;
     }
     exitedFrameInDocument = nextExitedFrameInDocument;
   }
 
-  const PlatformGestureEvent& gestureEvent = targetedEvent.event();
-  unsigned modifiers = gestureEvent.getModifiers();
+  const WebGestureEvent& gestureEvent = targetedEvent.event();
+  unsigned modifiers = gestureEvent.modifiers;
   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, gestureEvent.timeStampSeconds,
       WebPointerProperties::PointerType::Mouse);
 
   // Update the mouseout/mouseleave event
   size_t indexExitedFrameChain = exitedFrameChain.size();
   while (indexExitedFrameChain) {
     LocalFrame* leaveFrame = exitedFrameChain[--indexExitedFrameChain];
     leaveFrame->eventHandler().m_mouseEventManager->setNodeUnderMouse(
         updateMouseEventTargetNode(nullptr), fakeMouseMove);
   }
 
   // update the mouseover/mouseenter event
   while (indexEnteredFrameChain) {
     Frame* parentFrame =
         enteredFrameChain[--indexEnteredFrameChain]->tree().parent();
     if (parentFrame && parentFrame->isLocalFrame())
       toLocalFrame(parentFrame)
           ->eventHandler()
           .m_mouseEventManager->setNodeUnderMouse(
               updateMouseEventTargetNode(toHTMLFrameOwnerElement(
                   enteredFrameChain[indexEnteredFrameChain]->owner())),
               fakeMouseMove);
   }
 }
 
 GestureEventWithHitTestResults EventHandler::targetGestureEvent(
-    const PlatformGestureEvent& gestureEvent,
+    const WebGestureEvent& gestureEvent,
     bool readOnly) {
   TRACE_EVENT0("input", "EventHandler::targetGestureEvent");
 
   ASSERT(m_frame == m_frame->localFrameRoot());
   // Scrolling events get hit tested per frame (like wheel events do).
   ASSERT(!gestureEvent.isScrollEvent());
 
   HitTestRequest::HitTestRequestType hitType =
-      m_gestureManager->getHitTypeForGestureType(gestureEvent.type());
+      m_gestureManager->getHitTypeForGestureType(gestureEvent.type);
   double activeInterval = 0;
   bool shouldKeepActiveForMinInterval = false;
   if (readOnly) {
     hitType |= HitTestRequest::ReadOnly;
-  } else if (gestureEvent.type() == PlatformEvent::GestureTap) {
+  } else if (gestureEvent.type == WebInputEvent::GestureTap) {
     // If the Tap is received very shortly after ShowPress, we want to
     // delay clearing of the active state so that it's visible to the user
     // for at least a couple of frames.
     activeInterval = WTF::monotonicallyIncreasingTime() -
                      m_gestureManager->getLastShowPressTimestamp();
     shouldKeepActiveForMinInterval =
         m_gestureManager->getLastShowPressTimestamp() &&
         activeInterval < minimumActiveInterval;
     if (shouldKeepActiveForMinInterval)
       hitType |= HitTestRequest::ReadOnly;
@@ skipping 12 matching lines @@
         eventWithHitTestResults.hitTestResult().innerElement();
     // TODO(https://crbug.com/668758): Use a normal BeginFrame update for this.
     m_activeIntervalTimer.startOneShot(minimumActiveInterval - activeInterval,
                                        BLINK_FROM_HERE);
   }
 
   return eventWithHitTestResults;
 }
 
 GestureEventWithHitTestResults EventHandler::hitTestResultForGestureEvent(
-    const PlatformGestureEvent& gestureEvent,
+    const WebGestureEvent& gestureEvent,
     HitTestRequest::HitTestRequestType hitType) {
   // Perform the rect-based hit-test (or point-based if adjustment is disabled).
   // Note that we don't yet apply hover/active state here because we need to
   // resolve touch adjustment first so that we apply hover/active it to the
   // final adjusted node.
-  IntPoint hitTestPoint =
-      m_frame->view()->rootFrameToContents(gestureEvent.position());
+  IntPoint hitTestPoint = m_frame->view()->rootFrameToContents(
+      flooredIntPoint(gestureEvent.positionInRootFrame()));
   LayoutSize padding;
   if (shouldApplyTouchAdjustment(gestureEvent)) {
-    padding = LayoutSize(gestureEvent.area());
+    padding = LayoutSize(gestureEvent.tapAreaInRootFrame());
     if (!padding.isEmpty()) {
       padding.scale(1.f / 2);
       hitType |= HitTestRequest::ListBased;
     }
   }
   HitTestResult hitTestResult = hitTestResultAtPoint(
       hitTestPoint, hitType | HitTestRequest::ReadOnly, padding);
 
   // Adjust the location of the gesture to the most likely nearby node, as
   // appropriate for the type of event.
-  PlatformGestureEvent adjustedEvent = gestureEvent;
+  WebGestureEvent adjustedEvent = gestureEvent;
   applyTouchAdjustment(&adjustedEvent, &hitTestResult);
 
   // Do a new hit-test at the (adjusted) gesture co-ordinates. This is necessary
   // because rect-based hit testing and touch adjustment sometimes return a
   // different node than what a point-based hit test would return for the same
   // point.
   // FIXME: Fix touch adjustment to avoid the need for a redundant hit test.
   // http://crbug.com/398914
   if (shouldApplyTouchAdjustment(gestureEvent)) {
     LocalFrame* hitFrame = hitTestResult.innerNodeFrame();
     if (!hitFrame)
       hitFrame = m_frame;
     hitTestResult = EventHandlingUtil::hitTestResultInFrame(
-        hitFrame,
-        hitFrame->view()->rootFrameToContents(adjustedEvent.position()),
+        hitFrame, hitFrame->view()->rootFrameToContents(
+                      flooredIntPoint(adjustedEvent.positionInRootFrame())),
         (hitType | HitTestRequest::ReadOnly) & ~HitTestRequest::ListBased);
   }
 
   // If we did a rect-based hit test it must be resolved to the best single node
   // by now to ensure consumers don't accidentally use one of the other
   // candidates.
   ASSERT(!hitTestResult.isRectBasedTest());
 
   return GestureEventWithHitTestResults(adjustedEvent, hitTestResult);
 }
 
-void EventHandler::applyTouchAdjustment(PlatformGestureEvent* gestureEvent,
+void EventHandler::applyTouchAdjustment(WebGestureEvent* gestureEvent,
                                         HitTestResult* hitTestResult) {
   if (!shouldApplyTouchAdjustment(*gestureEvent))
     return;
 
   Node* adjustedNode = nullptr;
-  IntPoint adjustedPoint = gestureEvent->position();
+  IntPoint adjustedPoint = flooredIntPoint(gestureEvent->positionInRootFrame());
   bool adjusted = false;
-  switch (gestureEvent->type()) {
-    case PlatformEvent::GestureTap:
-    case PlatformEvent::GestureTapUnconfirmed:
-    case PlatformEvent::GestureTapDown:
-    case PlatformEvent::GestureShowPress:
+  switch (gestureEvent->type) {
+    case WebInputEvent::GestureTap:
+    case WebInputEvent::GestureTapUnconfirmed:
+    case WebInputEvent::GestureTapDown:
+    case WebInputEvent::GestureShowPress:
       adjusted = bestClickableNodeForHitTestResult(*hitTestResult,
                                                    adjustedPoint, adjustedNode);
       break;
-    case PlatformEvent::GestureLongPress:
-    case PlatformEvent::GestureLongTap:
-    case PlatformEvent::GestureTwoFingerTap:
+    case WebInputEvent::GestureLongPress:
+    case WebInputEvent::GestureLongTap:
+    case WebInputEvent::GestureTwoFingerTap:
       adjusted = bestContextMenuNodeForHitTestResult(
           *hitTestResult, adjustedPoint, adjustedNode);
       break;
     default:
       ASSERT_NOT_REACHED();
   }
 
   // Update the hit-test result to be a point-based result instead of a
   // rect-based result.
   // FIXME: We should do this even when no candidate matches the node filter.
   // crbug.com/398914
   if (adjusted) {
     hitTestResult->resolveRectBasedTest(
         adjustedNode, m_frame->view()->rootFrameToContents(adjustedPoint));
-    gestureEvent->applyTouchAdjustment(adjustedPoint);
+    gestureEvent->applyTouchAdjustment(
+        WebFloatPoint(adjustedPoint.x(), adjustedPoint.y()));
   }
 }
 
 WebInputEventResult EventHandler::sendContextMenuEvent(
     const PlatformMouseEvent& event,
     Node* overrideTargetNode) {
   FrameView* v = m_frame->view();
   if (!v)
     return WebInputEventResult::NotHandled;
 
@@ skipping 333 matching lines @@
 }
 
 FrameHost* EventHandler::frameHost() const {
   if (!m_frame->page())
     return nullptr;
 
   return &m_frame->page()->frameHost();
 }
 
 }  // namespace blink