WIP Add getCoalescedEvents API using vector of WebInputEvents

third_party/WebKit/Source/core/input/PointerEventManager.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/PointerEventManager.h"
 
 #include "core/dom/DocumentUserGestureToken.h"
 #include "core/dom/ElementTraversal.h"
 #include "core/dom/shadow/FlatTreeTraversal.h"
 #include "core/events/MouseEvent.h"
@@ skipping 10 matching lines @@
 #include "platform/PlatformTouchEvent.h"
 
 namespace blink {
 
 namespace {
 
 size_t toPointerTypeIndex(WebPointerProperties::PointerType t) {
   return static_cast<size_t>(t);
 }
 
-const AtomicString& pointerEventNameForTouchPointState(
-    PlatformTouchPoint::TouchState state) {
-  switch (state) {
-    case PlatformTouchPoint::TouchReleased:
-      return EventTypeNames::pointerup;
-    case PlatformTouchPoint::TouchCancelled:
-      return EventTypeNames::pointercancel;
-    case PlatformTouchPoint::TouchPressed:
-      return EventTypeNames::pointerdown;
-    case PlatformTouchPoint::TouchMoved:
-      return EventTypeNames::pointermove;
-    case PlatformTouchPoint::TouchStationary:
-    // Fall through to default
-    default:
-      NOTREACHED();
-      return emptyAtom;
-  }
-}
-
 bool isInDocument(EventTarget* n) {
   return n && n->toNode() && n->toNode()->isConnected();
 }
 
+Vector<PlatformTouchPoint> getCoalescedPoints(
+    const Vector<PlatformTouchEvent>& coalescedEvents,
+    int id) {
+  Vector<PlatformTouchPoint> relatedPoints;
+  for (const auto& touchEvent : coalescedEvents) {
+    for (auto& point : touchEvent.touchPoints()) {
+      // TODO(nzolghadr): Need to filter out stationary points
+      if (point.id() == id)
+        relatedPoints.append(point);
+    }
+  }
+  return relatedPoints;
+}
+
 }  // namespace
 
 PointerEventManager::PointerEventManager(LocalFrame* frame,
                                          MouseEventManager* mouseEventManager)
     : m_frame(frame),
       m_touchEventManager(new TouchEventManager(frame)),
       m_mouseEventManager(mouseEventManager) {
   clear();
 }
 
@@ skipping 127 matching lines @@
   return target;
 }
 
 void PointerEventManager::sendMouseAndPointerBoundaryEvents(
     Node* enteredNode,
     const PlatformMouseEvent& mouseEvent) {
   // Mouse event type does not matter as this pointerevent will only be used
   // to create boundary pointer events and its type will be overridden in
   // |sendBoundaryEvents| function.
   PointerEvent* dummyPointerEvent = m_pointerEventFactory.create(
-      EventTypeNames::mousedown, mouseEvent, m_frame->document()->domWindow());
+      EventTypeNames::mousedown, mouseEvent, Vector<PlatformMouseEvent>(),
+      m_frame->document()->domWindow());
 
   // TODO(crbug/545647): This state should reset with pointercancel too.
   // This function also gets called for compat mouse events of touch at this
   // stage. So if the event is not frame boundary transition it is only a
   // compatibility mouse event and we do not need to change pointer event
   // behavior regarding preventMouseEvent state in that case.
   if (dummyPointerEvent->buttons() == 0 && dummyPointerEvent->isPrimary()) {
     m_preventMouseEventForPointerType[toPointerTypeIndex(
         mouseEvent.pointerProperties().pointerType)] = false;
   }
@@ skipping 76 matching lines @@
 
     removePointer(pointerEvent);
   }
 }
 
 void PointerEventManager::unblockTouchPointers() {
   m_inCanceledStateForPointerTypeTouch = false;
 }
 
 WebInputEventResult PointerEventManager::handleTouchEvents(
-    const PlatformTouchEvent& event) {
+    const PlatformTouchEvent& event,
+    const Vector<PlatformTouchEvent>& coalescedEvents) {
   if (event.type() == PlatformEvent::TouchScrollStarted) {
     blockTouchPointers();
     m_touchEventManager->setTouchScrollStarted();
     return WebInputEventResult::HandledSystem;
   }
 
   bool newTouchSequence = true;
   for (const auto& touchPoint : event.touchPoints()) {
     if (touchPoint.state() != PlatformTouchPoint::TouchPressed) {
       newTouchSequence = false;
       break;
     }
   }
   if (newTouchSequence)
     unblockTouchPointers();
   HeapVector<TouchEventManager::TouchInfo> touchInfos;
 
-  dispatchTouchPointerEvents(event, touchInfos);
+  dispatchTouchPointerEvents(event, coalescedEvents, touchInfos);
 
   return m_touchEventManager->handleTouchEvent(event, touchInfos);
 }
 
 void PointerEventManager::dispatchTouchPointerEvents(
     const PlatformTouchEvent& event,
+    const Vector<PlatformTouchEvent>& coalescedEvents,
     HeapVector<TouchEventManager::TouchInfo>& touchInfos) {
   // Iterate through the touch points, sending PointerEvents to the targets as
   // required.
   for (const auto& touchPoint : event.touchPoints()) {
     TouchEventManager::TouchInfo touchInfo;
     touchInfo.point = touchPoint;
 
     int pointerId =
         m_pointerEventFactory.getPointerEventId(touchPoint.pointerProperties());
     // Do the hit test either when the touch first starts or when the touch
@@ skipping 37 matching lines @@
       // and perform a hit-test.
       touchInfo.touchNode =
           m_pendingPointerCaptureTarget.get(pointerId)->toNode();
       touchInfo.targetFrame = touchInfo.touchNode->document().frame();
     }
 
     // Do not send pointer events for stationary touches or null targetFrame
     if (touchInfo.touchNode && touchInfo.targetFrame &&
         touchPoint.state() != PlatformTouchPoint::TouchStationary &&
         !m_inCanceledStateForPointerTypeTouch) {
-      FloatPoint pagePoint = touchInfo.targetFrame->view()->rootFrameToContents(
-          touchInfo.point.pos());
-      float scaleFactor = 1.0f / touchInfo.targetFrame->pageZoomFactor();
-      FloatPoint scrollPosition(touchInfo.targetFrame->view()->scrollOffset());
-      FloatPoint framePoint = pagePoint.scaledBy(scaleFactor);
-      framePoint.moveBy(scrollPosition.scaledBy(-scaleFactor));
       PointerEvent* pointerEvent = m_pointerEventFactory.create(
-          pointerEventNameForTouchPointState(touchPoint.state()), touchPoint,
-          event.getModifiers(), touchPoint.radius().scaledBy(scaleFactor),
-          framePoint,
+          touchPoint, getCoalescedPoints(coalescedEvents, touchPoint.id()),
+          event.getModifiers(), touchInfo.targetFrame,
           touchInfo.touchNode ? touchInfo.touchNode->document().domWindow()
                               : nullptr);
 
       WebInputEventResult result =
           sendTouchPointerEvent(touchInfo.touchNode, pointerEvent);
 
       // If a pointerdown has been canceled, queue the unique id to allow
       // suppressing mouse events from gesture events. For mouse events
       // fired from GestureTap & GestureLongPress (which are triggered by
       // single touches only), it is enough to queue the ids only for
@@ skipping 37 matching lines @@
 
     removePointer(pointerEvent);
   }
 
   return result;
 }
 
 WebInputEventResult PointerEventManager::sendMousePointerEvent(
     Node* target,
     const AtomicString& mouseEventType,
-    const PlatformMouseEvent& mouseEvent) {
-  PointerEvent* pointerEvent = m_pointerEventFactory.create(
-      mouseEventType, mouseEvent, m_frame->document()->domWindow());
+    const PlatformMouseEvent& mouseEvent,
+    const Vector<PlatformMouseEvent>& coalescedEvents) {
+  PointerEvent* pointerEvent =
+      m_pointerEventFactory.create(mouseEventType, mouseEvent, coalescedEvents,
+                                   m_frame->document()->domWindow());
 
   // This is for when the mouse is released outside of the page.
   if (pointerEvent->type() == EventTypeNames::pointermove &&
       !pointerEvent->buttons()) {
     releasePointerCapture(pointerEvent->pointerId());
     // Send got/lostpointercapture rightaway if necessary.
     processPendingPointerCapture(pointerEvent);
 
     if (pointerEvent->isPrimary()) {
       m_preventMouseEventForPointerType[toPointerTypeIndex(
@@ skipping 240 matching lines @@
       return true;
   }
   return false;
 }
 
 EventTarget* PointerEventManager::getMouseCapturingNode() {
   return getCapturingNode(PointerEventFactory::s_mouseId);
 }
 
 }  // namespace blink