Add getCoalescedEvents API to PointerEvent

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 630 matching lines @@
   m_mouseEventManager->setClickCount(mouseEvent.clickCount());
   m_mouseEventManager->setClickNode(
       mev.innerNode()->isTextNode()
           ? FlatTreeTraversal::parent(*mev.innerNode())
           : mev.innerNode());
 
   if (!mouseEvent.fromTouch())
     m_frame->selection().setCaretBlinkingSuspended(true);
 
   WebInputEventResult eventResult = updatePointerTargetAndDispatchEvents(
-      EventTypeNames::mousedown, mev.innerNode(), mev.event());
+      EventTypeNames::mousedown, mev.innerNode(), mev.event(),
+      Vector<PlatformMouseEvent>());
 
   if (eventResult == WebInputEventResult::NotHandled && m_frame->view()) {
     FrameView* view = m_frame->view();
     PaintLayer* layer = mev.innerNode()->layoutObject()
                             ? mev.innerNode()->layoutObject()->enclosingLayer()
                             : nullptr;
     IntPoint p = view->rootFrameToContents(mouseEvent.position());
     if (layer && layer->getScrollableArea() &&
         layer->getScrollableArea()->isPointInResizeControl(p,
                                                            ResizerForPointer)) {
@@ skipping 57 matching lines @@
     ASSERT(mouseEvent.type() == PlatformEvent::MousePressed);
     HitTestResult result = mev.hitTestResult();
     result.setToShadowHostIfInUserAgentShadowRoot();
     m_frame->chromeClient().onMouseDown(result.innerNode());
   }
 
   return eventResult;
 }
 
 WebInputEventResult EventHandler::handleMouseMoveEvent(
-    const PlatformMouseEvent& event) {
+    const PlatformMouseEvent& event,
+    const Vector<PlatformMouseEvent>& coalescedEvents) {
   TRACE_EVENT0("blink", "EventHandler::handleMouseMoveEvent");
 
   HitTestResult hoveredNode = HitTestResult();
-  WebInputEventResult result = handleMouseMoveOrLeaveEvent(event, &hoveredNode);
+  WebInputEventResult result =
+      handleMouseMoveOrLeaveEvent(event, coalescedEvents, &hoveredNode);
 
   Page* page = m_frame->page();
   if (!page)
     return result;
 
   if (PaintLayer* layer =
           EventHandlingUtil::layerForNode(hoveredNode.innerNode())) {
     if (ScrollableArea* layerScrollableArea =
             EventHandlingUtil::associatedScrollableArea(layer))
       layerScrollableArea->mouseMovedInContentArea();
   }
 
   if (FrameView* frameView = m_frame->view())
     frameView->mouseMovedInContentArea();
 
   hoveredNode.setToShadowHostIfInUserAgentShadowRoot();
   page->chromeClient().mouseDidMoveOverElement(*m_frame, hoveredNode);
 
   return result;
 }
 
 void EventHandler::handleMouseLeaveEvent(const PlatformMouseEvent& event) {
   TRACE_EVENT0("blink", "EventHandler::handleMouseLeaveEvent");
 
-  handleMouseMoveOrLeaveEvent(event, 0, false, true);
+  handleMouseMoveOrLeaveEvent(event, Vector<PlatformMouseEvent>(), 0, false,
+                              true);
 }
 
 WebInputEventResult EventHandler::handleMouseMoveOrLeaveEvent(
     const PlatformMouseEvent& mouseEvent,
+    const Vector<PlatformMouseEvent>& coalescedEvents,
     HitTestResult* hoveredNode,
     bool onlyUpdateScrollbars,
     bool forceLeave) {
   ASSERT(m_frame);
   ASSERT(m_frame->view());
 
   m_mouseEventManager->setLastKnownMousePosition(mouseEvent);
 
   m_hoverTimer.stop();
   m_cursorUpdateTimer.stop();
 
   m_mouseEventManager->cancelFakeMouseMoveEvent();
   m_mouseEventManager->handleSvgPanIfNeeded(false);
 
   if (m_frameSetBeingResized) {
-    return updatePointerTargetAndDispatchEvents(
-        EventTypeNames::mousemove, m_frameSetBeingResized.get(), mouseEvent);
+    return updatePointerTargetAndDispatchEvents(EventTypeNames::mousemove,
+                                                m_frameSetBeingResized.get(),
+                                                mouseEvent, coalescedEvents);
   }
 
   // Send events right to a scrollbar if the mouse is pressed.
   if (m_lastScrollbarUnderMouse && m_mouseEventManager->mousePressed()) {
     m_lastScrollbarUnderMouse->mouseMoved(mouseEvent);
     return WebInputEventResult::HandledSystem;
   }
 
   // Mouse events simulated from touch should not hit-test again.
   ASSERT(!mouseEvent.fromTouch());
@@ skipping 60 matching lines @@
         mev.event());
 
   if (newSubframe) {
     // Update over/out state before passing the event to the subframe.
     m_pointerEventManager->sendMouseAndPointerBoundaryEvents(
         updateMouseEventTargetNode(mev.innerNode()), mev.event());
 
     // Event dispatch in sendMouseAndPointerBoundaryEvents may have caused the
     // subframe of the target node to be detached from its FrameView, in which
     // case the event should not be passed.
-    if (newSubframe->view())
-      eventResult = passMouseMoveEventToSubframe(mev, newSubframe, hoveredNode);
+    if (newSubframe->view()) {
+      eventResult = passMouseMoveEventToSubframe(mev, coalescedEvents,
+                                                 newSubframe, hoveredNode);
+    }
   } else {
     if (scrollbar && !m_mouseEventManager->mousePressed()) {
       // Handle hover effects on platforms that support visual feedback on
       // scrollbar hovering.
       scrollbar->mouseMoved(mev.event());
     }
     if (FrameView* view = m_frame->view()) {
       OptionalCursor optionalCursor = selectCursor(mev.hitTestResult());
       if (optionalCursor.isCursorChange()) {
         view->setCursor(optionalCursor.cursor());
       }
     }
   }
 
   m_lastMouseMoveEventSubframe = newSubframe;
 
   if (eventResult != WebInputEventResult::NotHandled)
     return eventResult;
 
   eventResult = updatePointerTargetAndDispatchEvents(
-      EventTypeNames::mousemove, mev.innerNode(), mev.event());
+      EventTypeNames::mousemove, mev.innerNode(), mev.event(), coalescedEvents);
   if (eventResult != WebInputEventResult::NotHandled)
     return eventResult;
 
   return m_mouseEventManager->handleMouseDraggedEvent(mev);
 }
 
 WebInputEventResult EventHandler::handleMouseReleaseEvent(
     const PlatformMouseEvent& mouseEvent) {
   TRACE_EVENT0("blink", "EventHandler::handleMouseReleaseEvent");
 
@@ skipping 21 matching lines @@
     return m_mouseEventManager->setMousePositionAndDispatchMouseEvent(
         updateMouseEventTargetNode(m_frameSetBeingResized.get()),
         EventTypeNames::mouseup, mouseEvent);
   }
 
   if (m_lastScrollbarUnderMouse) {
     m_mouseEventManager->invalidateClick();
     m_lastScrollbarUnderMouse->mouseUp(mouseEvent);
     return updatePointerTargetAndDispatchEvents(
         EventTypeNames::mouseup, m_mouseEventManager->getNodeUnderMouse(),
-        mouseEvent);
+        mouseEvent, Vector<PlatformMouseEvent>());
   }
 
   // Mouse events simulated from touch should not hit-test again.
   ASSERT(!mouseEvent.fromTouch());
 
   HitTestRequest::HitTestRequestType hitType = HitTestRequest::Release;
   HitTestRequest request(hitType);
   MouseEventWithHitTestResults mev =
       EventHandlingUtil::performMouseEventHitTest(m_frame, request, mouseEvent);
   LocalFrame* subframe =
@@ skipping 17 matching lines @@
     gestureIndicator = wrapUnique(new UserGestureIndicator(
         m_frame->localFrameRoot()
             ->eventHandler()
             .m_lastMouseDownUserGestureToken.release()));
   } else {
     gestureIndicator = wrapUnique(new UserGestureIndicator(
         DocumentUserGestureToken::create(m_frame->document())));
   }
 
   WebInputEventResult eventResult = updatePointerTargetAndDispatchEvents(
-      EventTypeNames::mouseup, mev.innerNode(), mev.event());
+      EventTypeNames::mouseup, mev.innerNode(), mev.event(),
+      Vector<PlatformMouseEvent>());
 
   WebInputEventResult clickEventResult =
       m_mouseEventManager->dispatchMouseClickIfNeeded(mev);
 
   m_scrollManager->clearResizeScrollableArea(false);
 
   if (eventResult == WebInputEventResult::NotHandled)
     eventResult = m_mouseEventManager->handleMouseReleaseEvent(mev);
   m_mouseEventManager->clearDragHeuristicState();
 
@@ skipping 270 matching lines @@
   return m_pointerEventManager->hasProcessedPointerCapture(pointerId, target);
 }
 
 void EventHandler::elementRemoved(EventTarget* target) {
   m_pointerEventManager->elementRemoved(target);
 }
 
 WebInputEventResult EventHandler::updatePointerTargetAndDispatchEvents(
     const AtomicString& mouseEventType,
     Node* targetNode,
-    const PlatformMouseEvent& mouseEvent) {
+    const PlatformMouseEvent& mouseEvent,
+    const Vector<PlatformMouseEvent>& coalescedEvents) {
   ASSERT(mouseEventType == EventTypeNames::mousedown ||
          mouseEventType == EventTypeNames::mousemove ||
          mouseEventType == EventTypeNames::mouseup);
 
   const auto& eventResult = m_pointerEventManager->sendMousePointerEvent(
-      updateMouseEventTargetNode(targetNode), mouseEventType, mouseEvent);
+      updateMouseEventTargetNode(targetNode), mouseEventType, mouseEvent,
+      coalescedEvents);
   return eventResult;
 }
 
 WebInputEventResult EventHandler::handleWheelEvent(
     const PlatformWheelEvent& event) {
 #if OS(MACOSX)
   // Filter Mac OS specific phases, usually with a zero-delta.
   // https://crbug.com/553732
   // TODO(chongz): EventSender sends events with |PlatformWheelEventPhaseNone|,
   // but it shouldn't.
@@ skipping 784 matching lines @@
 
     // Send mouse entered if we're setting a new scrollbar.
     if (scrollbar && setLast)
       scrollbar->mouseEntered();
 
     m_lastScrollbarUnderMouse = setLast ? scrollbar : nullptr;
   }
 }
 
 WebInputEventResult EventHandler::handleTouchEvent(
-    const PlatformTouchEvent& event) {
+    const PlatformTouchEvent& event,
+    const Vector<PlatformTouchEvent>& coalescedEvents) {
   TRACE_EVENT0("blink", "EventHandler::handleTouchEvent");
-  return m_pointerEventManager->handleTouchEvents(event);
+  return m_pointerEventManager->handleTouchEvents(event, coalescedEvents);
 }
 
 WebInputEventResult EventHandler::passMousePressEventToSubframe(
     MouseEventWithHitTestResults& mev,
     LocalFrame* subframe) {
   selectionController().passMousePressEventToSubframe(mev);
   WebInputEventResult result =
       subframe->eventHandler().handleMousePressEvent(mev.event());
   if (result != WebInputEventResult::NotHandled)
     return result;
   return WebInputEventResult::HandledSystem;
 }
 
 WebInputEventResult EventHandler::passMouseMoveEventToSubframe(
     MouseEventWithHitTestResults& mev,
+    const Vector<PlatformMouseEvent>& coalescedEvents,
     LocalFrame* subframe,
     HitTestResult* hoveredNode) {
   if (m_mouseEventManager->mouseDownMayStartDrag())
     return WebInputEventResult::NotHandled;
   WebInputEventResult result =
-      subframe->eventHandler().handleMouseMoveOrLeaveEvent(mev.event(),
-                                                           hoveredNode);
+      subframe->eventHandler().handleMouseMoveOrLeaveEvent(
+          mev.event(), coalescedEvents, hoveredNode);
   if (result != WebInputEventResult::NotHandled)
     return result;
   return WebInputEventResult::HandledSystem;
 }
 
 WebInputEventResult EventHandler::passMouseReleaseEventToSubframe(
     MouseEventWithHitTestResults& mev,
     LocalFrame* subframe) {
   WebInputEventResult result =
       subframe->eventHandler().handleMouseReleaseEvent(mev.event());
   if (result != WebInputEventResult::NotHandled)
     return result;
   return WebInputEventResult::HandledSystem;
 }
 
 FrameHost* EventHandler::frameHost() const {
   if (!m_frame->page())
     return nullptr;
 
   return &m_frame->page()->frameHost();
 }
 
 }  // namespace blink