WIP Add getCoalescedEvents API using vector of WebInputEvents

third_party/WebKit/Source/core/events/PointerEventFactory.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/events/PointerEventFactory.h"
 
 #include "core/frame/FrameView.h"
 #include "platform/geometry/FloatSize.h"
 
 namespace blink {
@@ skipping 57 matching lines @@
     CASE_BUTTON_TO_BUTTONS(X2);
     CASE_BUTTON_TO_BUTTONS(Eraser);
   }
 
 #undef CASE_BUTTON_TO_BUTTONS
 
   NOTREACHED();
   return 0;
 }
 
-}  // namespace
-
-const int PointerEventFactory::s_invalidId = 0;
-
-// Mouse id is 1 to behave the same as MS Edge for compatibility reasons.
-const int PointerEventFactory::s_mouseId = 1;
+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;
+  }
+}
 
 float getPointerEventPressure(float force, int buttons) {
   if (std::isnan(force))
     return buttons ? 0.5 : 0;
   return force;
 }
 
+void updateTouchPointPointerEventInit(const PlatformTouchPoint& touchPoint,
+                                      LocalFrame* targetFrame,
+                                      PointerEventInit* pointerEventInit) {
+  if (targetFrame) {
+    FloatPoint pagePoint =
+        targetFrame->view()->rootFrameToContents(touchPoint.pos());
+    float scaleFactor = 1.0f / targetFrame->pageZoomFactor();
+    FloatPoint scrollPosition(targetFrame->view()->scrollOffset());
+    FloatPoint clientPoint = pagePoint.scaledBy(scaleFactor);
+    clientPoint.moveBy(scrollPosition.scaledBy(-scaleFactor));
+
+    pointerEventInit->setClientX(clientPoint.x());
+    pointerEventInit->setClientY(clientPoint.y());
+
+    FloatSize pointRadius = touchPoint.radius().scaledBy(scaleFactor);
+    pointerEventInit->setWidth(pointRadius.width());
+    pointerEventInit->setHeight(pointRadius.height());
+  }
+
+  pointerEventInit->setScreenX(touchPoint.screenPos().x());
+  pointerEventInit->setScreenY(touchPoint.screenPos().y());
+  pointerEventInit->setPressure(
+      getPointerEventPressure(touchPoint.force(), pointerEventInit->buttons()));
+  pointerEventInit->setTiltX(touchPoint.pointerProperties().tiltX);
+  pointerEventInit->setTiltY(touchPoint.pointerProperties().tiltY);
+}
+
+void updateMousePointerEventInit(const PlatformMouseEvent& mouseEvent,
+                                 LocalDOMWindow* view,
+                                 PointerEventInit* pointerEventInit) {
+  pointerEventInit->setScreenX(mouseEvent.globalPosition().x());
+  pointerEventInit->setScreenY(mouseEvent.globalPosition().y());
+
+  IntPoint locationInFrameZoomed;
+  if (view && view->frame() && view->frame()->view()) {
+    LocalFrame* frame = view->frame();
+    FrameView* frameView = frame->view();
+    IntPoint locationInContents =
+        frameView->rootFrameToContents(mouseEvent.position());
+    locationInFrameZoomed = frameView->contentsToFrame(locationInContents);
+    float scaleFactor = 1 / frame->pageZoomFactor();
+    locationInFrameZoomed.scale(scaleFactor, scaleFactor);
+  }
+
+  // Set up initial values for coordinates.
+  pointerEventInit->setClientX(locationInFrameZoomed.x());
+  pointerEventInit->setClientY(locationInFrameZoomed.y());
+
+  pointerEventInit->setPressure(getPointerEventPressure(
+      mouseEvent.pointerProperties().force, pointerEventInit->buttons()));
+  pointerEventInit->setTiltX(mouseEvent.pointerProperties().tiltX);
+  pointerEventInit->setTiltY(mouseEvent.pointerProperties().tiltY);
+}
+
+}  // namespace
+
+const int PointerEventFactory::s_invalidId = 0;
+
+// Mouse id is 1 to behave the same as MS Edge for compatibility reasons.
+const int PointerEventFactory::s_mouseId = 1;
+
 void PointerEventFactory::setIdTypeButtons(
     PointerEventInit& pointerEventInit,
     const WebPointerProperties& pointerProperties,
     unsigned buttons) {
   const WebPointerProperties::PointerType pointerType =
       pointerProperties.pointerType;
   const IncomingId incomingId(pointerType, pointerProperties.id);
   int pointerId = addIdAndActiveButtons(incomingId, buttons != 0);
 
   // Tweak the |buttons| to reflect pen eraser mode only if the pen is in
@@ skipping 17 matching lines @@
     const AtomicString& type) {
   pointerEventInit.setBubbles(type != EventTypeNames::pointerenter &&
                               type != EventTypeNames::pointerleave);
   pointerEventInit.setCancelable(type != EventTypeNames::pointerenter &&
                                  type != EventTypeNames::pointerleave &&
                                  type != EventTypeNames::pointercancel &&
                                  type != EventTypeNames::gotpointercapture &&
                                  type != EventTypeNames::lostpointercapture);
 }
 
-PointerEvent* PointerEventFactory::create(const AtomicString& mouseEventName,
-                                          const PlatformMouseEvent& mouseEvent,
-                                          LocalDOMWindow* view) {
+PointerEvent* PointerEventFactory::create(
+    const AtomicString& mouseEventName,
+    const PlatformMouseEvent& mouseEvent,
+    const Vector<PlatformMouseEvent>& coalescedEvents,
+    LocalDOMWindow* view) {
   DCHECK(mouseEventName == EventTypeNames::mousemove ||
          mouseEventName == EventTypeNames::mousedown ||
          mouseEventName == EventTypeNames::mouseup);
 
   AtomicString pointerEventName =
       pointerEventNameForMouseEventName(mouseEventName);
   unsigned buttons =
       MouseEvent::platformModifiersToButtons(mouseEvent.getModifiers());
   PointerEventInit pointerEventInit;
 
   setIdTypeButtons(pointerEventInit, mouseEvent.pointerProperties(), buttons);
   setBubblesAndCancelable(pointerEventInit, pointerEventName);
 
-  pointerEventInit.setScreenX(mouseEvent.globalPosition().x());
-  pointerEventInit.setScreenY(mouseEvent.globalPosition().y());
-
-  IntPoint locationInFrameZoomed;
-  if (view && view->frame() && view->frame()->view()) {
-    LocalFrame* frame = view->frame();
-    FrameView* frameView = frame->view();
-    IntPoint locationInContents =
-        frameView->rootFrameToContents(mouseEvent.position());
-    locationInFrameZoomed = frameView->contentsToFrame(locationInContents);
-    float scaleFactor = 1 / frame->pageZoomFactor();
-    locationInFrameZoomed.scale(scaleFactor, scaleFactor);
-  }
-
-  // Set up initial values for coordinates.
-  pointerEventInit.setClientX(locationInFrameZoomed.x());
-  pointerEventInit.setClientY(locationInFrameZoomed.y());
-
   if (pointerEventName == EventTypeNames::pointerdown ||
       pointerEventName == EventTypeNames::pointerup) {
     WebPointerProperties::Button button = mouseEvent.pointerProperties().button;
     // TODO(mustaq): Fix when the spec starts supporting hovering erasers.
     if (mouseEvent.pointerProperties().pointerType ==
             WebPointerProperties::PointerType::Eraser &&
         button == WebPointerProperties::Button::Left)
       button = WebPointerProperties::Button::Eraser;
     pointerEventInit.setButton(static_cast<int>(button));
   } else {
     DCHECK(pointerEventName == EventTypeNames::pointermove);
     pointerEventInit.setButton(
         static_cast<int>(WebPointerProperties::Button::NoButton));
   }
-  pointerEventInit.setPressure(getPointerEventPressure(
-      mouseEvent.pointerProperties().force, pointerEventInit.buttons()));
-  pointerEventInit.setTiltX(mouseEvent.pointerProperties().tiltX);
-  pointerEventInit.setTiltY(mouseEvent.pointerProperties().tiltY);
 
   UIEventWithKeyState::setFromPlatformModifiers(pointerEventInit,
                                                 mouseEvent.getModifiers());
 
   // Make sure chorded buttons fire pointermove instead of pointerup/down.
   if ((pointerEventName == EventTypeNames::pointerdown &&
        (buttons &
         ~buttonToButtonsBitfield(mouseEvent.pointerProperties().button)) !=
            0) ||
       (pointerEventName == EventTypeNames::pointerup && buttons != 0))
     pointerEventName = EventTypeNames::pointermove;
 
   pointerEventInit.setView(view);
 
+  updateMousePointerEventInit(mouseEvent, view, &pointerEventInit);
+
+  // Created coalesced events init structure
+  HeapVector<PointerEventInit> coalescedEventInits;
+  for (const auto& coalescedMouseEvent : coalescedEvents) {
+    PointerEventInit coalescedEventInit = pointerEventInit;
+    updateMousePointerEventInit(coalescedMouseEvent, view, &coalescedEventInit);
+    coalescedEventInits.append(coalescedEventInit);
+  }
+  pointerEventInit.setCoalescedEventInits(coalescedEventInits);
+
   return PointerEvent::create(pointerEventName, pointerEventInit);
 }
 
-PointerEvent* PointerEventFactory::create(const AtomicString& type,
-                                          const PlatformTouchPoint& touchPoint,
-                                          PlatformEvent::Modifiers modifiers,
-                                          const FloatSize& pointRadius,
-                                          const FloatPoint& clientPoint,
-                                          DOMWindow* view) {
+PointerEvent* PointerEventFactory::create(
+    const PlatformTouchPoint& touchPoint,
+    const Vector<PlatformTouchPoint>& coalescedPoints,
+    PlatformEvent::Modifiers modifiers,
+    LocalFrame* targetFrame,
+    //                                          const float scaleFactor,
+    //                                          const FloatPoint& clientPoint,
+    DOMWindow* view) {
   const PlatformTouchPoint::TouchState pointState = touchPoint.state();
 
   bool pointerReleasedOrCancelled =
       pointState == PlatformTouchPoint::TouchReleased ||
       pointState == PlatformTouchPoint::TouchCancelled;
   bool pointerPressedOrReleased =
       pointState == PlatformTouchPoint::TouchPressed ||
       pointState == PlatformTouchPoint::TouchReleased;
 
   bool isEnterOrLeave = false;
 
   PointerEventInit pointerEventInit;
 
   setIdTypeButtons(pointerEventInit, touchPoint.pointerProperties(),
                    pointerReleasedOrCancelled ? 0 : 1);
-
-  pointerEventInit.setWidth(pointRadius.width());
-  pointerEventInit.setHeight(pointRadius.height());
-  pointerEventInit.setScreenX(touchPoint.screenPos().x());
-  pointerEventInit.setScreenY(touchPoint.screenPos().y());
-  pointerEventInit.setClientX(clientPoint.x());
-  pointerEventInit.setClientY(clientPoint.y());
   pointerEventInit.setButton(static_cast<int>(
       pointerPressedOrReleased ? WebPointerProperties::Button::Left
                                : WebPointerProperties::Button::NoButton));
-  pointerEventInit.setPressure(
-      getPointerEventPressure(touchPoint.force(), pointerEventInit.buttons()));
-  pointerEventInit.setTiltX(touchPoint.pointerProperties().tiltX);
-  pointerEventInit.setTiltY(touchPoint.pointerProperties().tiltY);
+
   pointerEventInit.setView(view);
+  updateTouchPointPointerEventInit(touchPoint, targetFrame, &pointerEventInit);
 
   UIEventWithKeyState::setFromPlatformModifiers(pointerEventInit, modifiers);
 
   pointerEventInit.setBubbles(!isEnterOrLeave);
   pointerEventInit.setCancelable(
       !isEnterOrLeave && pointState != PlatformTouchPoint::TouchCancelled);
 
-  return PointerEvent::create(type, pointerEventInit);
+  // Created coalesced events init structure
+  HeapVector<PointerEventInit> coalescedEventInits;
+  for (const auto& coalescedTouchPoint : coalescedPoints) {
+    PointerEventInit coalescedEventInit = pointerEventInit;
+    updateTouchPointPointerEventInit(coalescedTouchPoint, targetFrame,
+                                     &coalescedEventInit);
+    coalescedEventInits.append(coalescedEventInit);
+  }
+  pointerEventInit.setCoalescedEventInits(coalescedEventInits);
+
+  return PointerEvent::create(
+      pointerEventNameForTouchPointState(touchPoint.state()), pointerEventInit);
 }
 
 PointerEvent* PointerEventFactory::createPointerCancelEvent(
     const int pointerId,
     const WebPointerProperties::PointerType pointerType) {
   DCHECK(m_pointerIdMapping.contains(pointerId));
   m_pointerIdMapping.set(
       pointerId,
       PointerAttributes(m_pointerIdMapping.get(pointerId).incomingId, false));
 
@@ skipping 173 matching lines @@
     const WebPointerProperties& properties) const {
   if (properties.pointerType == WebPointerProperties::PointerType::Mouse)
     return PointerEventFactory::s_mouseId;
   IncomingId id(properties.pointerType, properties.id);
   if (m_pointerIncomingIdMapping.contains(id))
     return m_pointerIncomingIdMapping.get(id);
   return PointerEventFactory::s_invalidId;
 }
 
 }  // namespace blink