Remove PlatformGestureEvent in favour of using WebGestureEvent

third_party/WebKit/Source/core/input/ScrollManager.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/ScrollManager.h"
 
 #include "core/dom/DOMNodeIds.h"
 #include "core/events/GestureEvent.h"
 #include "core/frame/BrowserControls.h"
 #include "core/frame/FrameHost.h"
 #include "core/frame/FrameView.h"
 #include "core/html/HTMLFrameOwnerElement.h"
 #include "core/input/EventHandler.h"
 #include "core/input/EventHandlingUtil.h"
 #include "core/layout/LayoutBlock.h"
 #include "core/layout/LayoutPart.h"
 #include "core/layout/api/LayoutViewItem.h"
 #include "core/loader/DocumentLoader.h"
 #include "core/page/AutoscrollController.h"
 #include "core/page/Page.h"
 #include "core/page/scrolling/OverscrollController.h"
 #include "core/page/scrolling/RootScrollerController.h"
 #include "core/page/scrolling/ScrollState.h"
 #include "core/paint/PaintLayer.h"
-#include "platform/PlatformGestureEvent.h"
 #include "wtf/PtrUtil.h"
 #include <memory>
 
 namespace blink {
 
 ScrollManager::ScrollManager(LocalFrame& frame) : m_frame(frame) {
   clear();
 }
 
 void ScrollManager::clear() {
@@ skipping 155 matching lines @@
     m_frame->document()->updateStyleAndLayoutIgnorePendingStylesheets();
 
   if (m_currentScrollChain.empty())
     recomputeScrollChain(startNode, m_currentScrollChain);
   scrollState.setScrollChain(m_currentScrollChain);
 
   scrollState.distributeToScrollChainDescendant();
 }
 
 WebInputEventResult ScrollManager::handleGestureScrollBegin(
-    const PlatformGestureEvent& gestureEvent) {
+    const WebGestureEvent& gestureEvent) {
   Document* document = m_frame->document();
 
   if (document->layoutViewItem().isNull())
     return WebInputEventResult::NotHandled;
 
   // If there's no layoutObject on the node, send the event to the nearest
   // ancestor with a layoutObject.  Needed for <option> and <optgroup> elements
   // so we can touch scroll <select>s
   while (m_scrollGestureHandlingNode &&
          !m_scrollGestureHandlingNode->layoutObject())
     m_scrollGestureHandlingNode =
         m_scrollGestureHandlingNode->parentOrShadowHostNode();
 
   if (!m_scrollGestureHandlingNode)
     m_scrollGestureHandlingNode = m_frame->document()->documentElement();
 
   if (!m_scrollGestureHandlingNode ||
       !m_scrollGestureHandlingNode->layoutObject())
     return WebInputEventResult::NotHandled;
 
   passScrollGestureEventToWidget(gestureEvent,
                                  m_scrollGestureHandlingNode->layoutObject());
 
   m_currentScrollChain.clear();
   std::unique_ptr<ScrollStateData> scrollStateData =
       WTF::makeUnique<ScrollStateData>();
-  scrollStateData->position_x = gestureEvent.position().x();
-  scrollStateData->position_y = gestureEvent.position().y();
+  IntPoint position = flooredIntPoint(gestureEvent.positionInRootFrame());
+  scrollStateData->position_x = position.x();
+  scrollStateData->position_y = position.y();
   scrollStateData->is_beginning = true;
   scrollStateData->from_user_input = true;
   scrollStateData->is_direct_manipulation =
-      gestureEvent.source() == PlatformGestureSourceTouchscreen;
+      gestureEvent.sourceDevice == WebGestureDeviceTouchscreen;
   scrollStateData->delta_consumed_for_scroll_sequence =
       m_deltaConsumedForScrollSequence;
   ScrollState* scrollState = ScrollState::create(std::move(scrollStateData));
   customizedScroll(*m_scrollGestureHandlingNode.get(), *scrollState);
   return WebInputEventResult::HandledSystem;
 }
 
 WebInputEventResult ScrollManager::handleGestureScrollUpdate(
-    const PlatformGestureEvent& gestureEvent) {
-  DCHECK_EQ(gestureEvent.type(), PlatformEvent::GestureScrollUpdate);
+    const WebGestureEvent& gestureEvent) {
+  DCHECK_EQ(gestureEvent.type, WebInputEvent::GestureScrollUpdate);
 
   Node* node = m_scrollGestureHandlingNode.get();
   if (!node || !node->layoutObject())
     return WebInputEventResult::NotHandled;
 
   // Negate the deltas since the gesture event stores finger movement and
   // scrolling occurs in the direction opposite the finger's movement
   // direction. e.g. Finger moving up has negative event delta but causes the
   // page to scroll down causing positive scroll delta.
-  FloatSize delta(-gestureEvent.deltaX(), -gestureEvent.deltaY());
+  FloatSize delta(-gestureEvent.deltaXInRootFrame(),
+                  -gestureEvent.deltaYInRootFrame());
   FloatSize velocity(-gestureEvent.velocityX(), -gestureEvent.velocityY());
-  FloatPoint position(gestureEvent.position());
+  FloatPoint position(gestureEvent.positionInRootFrame());
 
   if (delta.isZero())
     return WebInputEventResult::NotHandled;
 
   LayoutObject* layoutObject = node->layoutObject();
 
   // Try to send the event to the correct view.
   WebInputEventResult result =
       passScrollGestureEventToWidget(gestureEvent, layoutObject);
   if (result != WebInputEventResult::NotHandled) {
     // FIXME: we should allow simultaneous scrolling of nested
     // iframes along perpendicular axes. See crbug.com/466991.
     m_deltaConsumedForScrollSequence = true;
     return result;
   }
 
   std::unique_ptr<ScrollStateData> scrollStateData =
       WTF::makeUnique<ScrollStateData>();
   scrollStateData->delta_x = delta.width();
   scrollStateData->delta_y = delta.height();
-  scrollStateData->delta_granularity =
-      static_cast<double>(gestureEvent.deltaUnits());
+  scrollStateData->delta_granularity = static_cast<double>(
+      toPlatformScrollGranularity(gestureEvent.deltaUnits()));
   scrollStateData->velocity_x = velocity.width();
   scrollStateData->velocity_y = velocity.height();
   scrollStateData->position_x = position.x();
   scrollStateData->position_y = position.y();
   scrollStateData->should_propagate = !gestureEvent.preventPropagation();
   scrollStateData->is_in_inertial_phase =
-      gestureEvent.inertialPhase() == ScrollInertialPhaseMomentum;
+      gestureEvent.inertialPhase() == WebGestureEvent::MomentumPhase;
   scrollStateData->is_direct_manipulation =
-      gestureEvent.source() == PlatformGestureSourceTouchscreen;
+      gestureEvent.sourceDevice == WebGestureDeviceTouchscreen;
   scrollStateData->from_user_input = true;
   scrollStateData->delta_consumed_for_scroll_sequence =
       m_deltaConsumedForScrollSequence;
   ScrollState* scrollState = ScrollState::create(std::move(scrollStateData));
   if (m_previousGestureScrolledElement) {
     // The ScrollState needs to know what the current
     // native scrolling element is, so that for an
     // inertial scroll that shouldn't propagate, only the
     // currently scrolling element responds.
     scrollState->setCurrentNativeScrollingElement(
@@ skipping 16 matching lines @@
 
   if (didScrollX || didScrollY) {
     setFrameWasScrolledByUser();
     return WebInputEventResult::HandledSystem;
   }
 
   return WebInputEventResult::NotHandled;
 }
 
 WebInputEventResult ScrollManager::handleGestureScrollEnd(
-    const PlatformGestureEvent& gestureEvent) {
+    const WebGestureEvent& gestureEvent) {
   Node* node = m_scrollGestureHandlingNode;
 
   if (node && node->layoutObject()) {
     passScrollGestureEventToWidget(gestureEvent, node->layoutObject());
     std::unique_ptr<ScrollStateData> scrollStateData =
         WTF::makeUnique<ScrollStateData>();
     scrollStateData->is_ending = true;
     scrollStateData->is_in_inertial_phase =
-        gestureEvent.inertialPhase() == ScrollInertialPhaseMomentum;
+        gestureEvent.inertialPhase() == WebGestureEvent::MomentumPhase;
     scrollStateData->from_user_input = true;
     scrollStateData->is_direct_manipulation =
-        gestureEvent.source() == PlatformGestureSourceTouchscreen;
+        gestureEvent.sourceDevice == WebGestureDeviceTouchscreen;
     scrollStateData->delta_consumed_for_scroll_sequence =
         m_deltaConsumedForScrollSequence;
     ScrollState* scrollState = ScrollState::create(std::move(scrollStateData));
     customizedScroll(*node, *scrollState);
   }
 
   clearGestureScrollState();
   return WebInputEventResult::NotHandled;
 }
 
 FrameHost* ScrollManager::frameHost() const {
   if (!m_frame->page())
     return nullptr;
 
   return &m_frame->page()->frameHost();
 }
 
 WebInputEventResult ScrollManager::passScrollGestureEventToWidget(
-    const PlatformGestureEvent& gestureEvent,
+    const WebGestureEvent& gestureEvent,
     LayoutObject* layoutObject) {
   DCHECK(gestureEvent.isScrollEvent());
 
   if (!m_lastGestureScrollOverWidget || !layoutObject ||
       !layoutObject->isLayoutPart())
     return WebInputEventResult::NotHandled;
 
   Widget* widget = toLayoutPart(layoutObject)->widget();
 
   if (!widget || !widget->isFrameView())
     return WebInputEventResult::NotHandled;
 
   return toFrameView(widget)->frame().eventHandler().handleGestureScrollEvent(
       gestureEvent);
 }
 
 bool ScrollManager::isViewportScrollingElement(const Element& element) const {
   // The root scroller is the one Element on the page designated to perform
   // "viewport actions" like browser controls movement and overscroll glow.
   if (!m_frame->document())
     return false;
 
   return m_frame->document()->rootScrollerController().scrollsViewport(element);
 }
 
 WebInputEventResult ScrollManager::handleGestureScrollEvent(
-    const PlatformGestureEvent& gestureEvent) {
+    const WebGestureEvent& gestureEvent) {
   if (!m_frame->view())
     return WebInputEventResult::NotHandled;
 
   Node* eventTarget = nullptr;
   Scrollbar* scrollbar = nullptr;
-  if (gestureEvent.type() != PlatformEvent::GestureScrollBegin) {
+  if (gestureEvent.type != WebInputEvent::GestureScrollBegin) {
     scrollbar = m_scrollbarHandlingScrollGesture.get();
     eventTarget = m_scrollGestureHandlingNode.get();
   }
 
   if (!eventTarget) {
     Document* document = m_frame->document();
     if (document->layoutViewItem().isNull())
       return WebInputEventResult::NotHandled;
 
     FrameView* view = m_frame->view();
-    LayoutPoint viewPoint = view->rootFrameToContents(gestureEvent.position());
+    LayoutPoint viewPoint = view->rootFrameToContents(
+        flooredIntPoint(gestureEvent.positionInRootFrame()));
     HitTestRequest request(HitTestRequest::ReadOnly);
     HitTestResult result(request, viewPoint);
     document->layoutViewItem().hitTest(result);
 
     eventTarget = result.innerNode();
 
     m_lastGestureScrollOverWidget = result.isOverWidget();
     m_scrollGestureHandlingNode = eventTarget;
     m_previousGestureScrolledElement = nullptr;
     m_deltaConsumedForScrollSequence = false;
@@ skipping 22 matching lines @@
       DispatchEventResult gestureDomEventResult =
           eventTarget->dispatchEvent(gestureDomEvent);
       if (gestureDomEventResult != DispatchEventResult::NotCanceled) {
         DCHECK(gestureDomEventResult !=
                DispatchEventResult::CanceledByEventHandler);
         return EventHandlingUtil::toWebInputEventResult(gestureDomEventResult);
       }
     }
   }
 
-  switch (gestureEvent.type()) {
-    case PlatformEvent::GestureScrollBegin:
+  switch (gestureEvent.type) {
+    case WebInputEvent::GestureScrollBegin:
       return handleGestureScrollBegin(gestureEvent);
-    case PlatformEvent::GestureScrollUpdate:
+    case WebInputEvent::GestureScrollUpdate:
       return handleGestureScrollUpdate(gestureEvent);
-    case PlatformEvent::GestureScrollEnd:
+    case WebInputEvent::GestureScrollEnd:
       return handleGestureScrollEnd(gestureEvent);
-    case PlatformEvent::GestureFlingStart:
-    case PlatformEvent::GesturePinchBegin:
-    case PlatformEvent::GesturePinchEnd:
-    case PlatformEvent::GesturePinchUpdate:
+    case WebInputEvent::GestureFlingStart:
+    case WebInputEvent::GesturePinchBegin:
+    case WebInputEvent::GesturePinchEnd:
+    case WebInputEvent::GesturePinchUpdate:
       return WebInputEventResult::NotHandled;
     default:
       NOTREACHED();
       return WebInputEventResult::NotHandled;
   }
 }
 
 bool ScrollManager::isScrollbarHandlingGestures() const {
   return m_scrollbarHandlingScrollGesture.get();
 }
 
 bool ScrollManager::handleScrollGestureOnResizer(
     Node* eventTarget,
-    const PlatformGestureEvent& gestureEvent) {
-  if (gestureEvent.source() != PlatformGestureSourceTouchscreen)
+    const WebGestureEvent& gestureEvent) {
+  if (gestureEvent.sourceDevice != WebGestureDeviceTouchscreen)
     return false;
 
-  if (gestureEvent.type() == PlatformEvent::GestureScrollBegin) {
+  if (gestureEvent.type == WebInputEvent::GestureScrollBegin) {
     PaintLayer* layer = eventTarget->layoutObject()
                             ? eventTarget->layoutObject()->enclosingLayer()
                             : nullptr;
-    IntPoint p = m_frame->view()->rootFrameToContents(gestureEvent.position());
+    IntPoint p = m_frame->view()->rootFrameToContents(
+        flooredIntPoint(gestureEvent.positionInRootFrame()));
     if (layer && layer->getScrollableArea() &&
         layer->getScrollableArea()->isPointInResizeControl(p,
                                                            ResizerForTouch)) {
       m_resizeScrollableArea = layer->getScrollableArea();
       m_resizeScrollableArea->setInResizeMode(true);
       m_offsetFromResizeCorner =
           LayoutSize(m_resizeScrollableArea->offsetFromResizeCorner(p));
       return true;
     }
-  } else if (gestureEvent.type() == PlatformEvent::GestureScrollUpdate) {
+  } else if (gestureEvent.type == WebInputEvent::GestureScrollUpdate) {
     if (m_resizeScrollableArea && m_resizeScrollableArea->inResizeMode()) {
-      m_resizeScrollableArea->resize(gestureEvent, m_offsetFromResizeCorner);
+      IntPoint pos = roundedIntPoint(gestureEvent.positionInRootFrame());
+      pos.move(gestureEvent.deltaXInRootFrame(),
+               gestureEvent.deltaYInRootFrame());
+      m_resizeScrollableArea->resize(pos, m_offsetFromResizeCorner);
       return true;
     }
-  } else if (gestureEvent.type() == PlatformEvent::GestureScrollEnd) {
+  } else if (gestureEvent.type == WebInputEvent::GestureScrollEnd) {
     if (m_resizeScrollableArea && m_resizeScrollableArea->inResizeMode()) {
       m_resizeScrollableArea->setInResizeMode(false);
       m_resizeScrollableArea = nullptr;
       return false;
     }
   }
 
   return false;
 }
 
 bool ScrollManager::inResizeMode() const {
   return m_resizeScrollableArea && m_resizeScrollableArea->inResizeMode();
 }
 
-void ScrollManager::resize(const PlatformEvent& evt) {
-  m_resizeScrollableArea->resize(evt, m_offsetFromResizeCorner);
+void ScrollManager::resize(const PlatformMouseEvent& evt) {
+  if (evt.type() == PlatformEvent::MouseMoved) {
+    if ((evt.getModifiers() &
+         (PlatformEvent::LeftButtonDown | PlatformEvent::MiddleButtonDown |
+          PlatformEvent::RightButtonDown)) == 0)

[majidvp, 2016/12/15 17:40:45]

This line is replacing 
"if (!document.frame()->eventHandler().mousePressed())"

but I don't think it does the same thing. Even if it does I suggest 
doing this as a follow-up patch.

[dtapuska, 2016/12/15 21:29:38]

Done.

+      return;
+    m_resizeScrollableArea->resize(evt.position(), m_offsetFromResizeCorner);
+  }
 }
 
 void ScrollManager::clearResizeScrollableArea(bool shouldNotBeNull) {
   if (shouldNotBeNull)
     DCHECK(m_resizeScrollableArea);
 
   if (m_resizeScrollableArea)
     m_resizeScrollableArea->setInResizeMode(false);
   m_resizeScrollableArea = nullptr;
 }
@@ skipping 14 matching lines @@
     if (scrollbar->gestureEvent(targetedEvent.event(), &shouldUpdateCapture)) {
       if (shouldUpdateCapture)
         m_scrollbarHandlingScrollGesture = scrollbar;
       return true;
     }
   }
   return false;
 }
 
 }  // namespace blink