Fix movementX/Y attributes for touch pointer events

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 84 matching lines @@
 }
 
 float getPointerEventPressure(float force, int buttons) {
   if (std::isnan(force))
     return buttons ? 0.5 : 0;
   return force;
 }
 
 void updateTouchPointerEventInit(const PlatformTouchPoint& touchPoint,
                                  LocalFrame* targetFrame,
+                                 double lastClientX,
+                                 double lastClientY,
                                  PointerEventInit* pointerEventInit) {
   // This function should not update attributes like pointerId, isPrimary,
   // and pointerType which is the same among the coalesced events and the
   // dispatched event.
 
   if (targetFrame) {
     FloatPoint pagePoint =
         targetFrame->view()->rootFrameToContents(touchPoint.pos());
     float scaleFactor = 1.0f / targetFrame->pageZoomFactor();
     FloatPoint scrollPosition(targetFrame->view()->getScrollOffset());
     FloatPoint clientPoint = pagePoint.scaledBy(scaleFactor);
     clientPoint.moveBy(scrollPosition.scaledBy(-scaleFactor));
 
     pointerEventInit->setClientX(clientPoint.x());
     pointerEventInit->setClientY(clientPoint.y());
 
+    // We leave movementX/Y to be zero for anything except pointerdown and
+    // pointermove.
+    if (touchPoint.state() == PlatformTouchPoint::TouchMoved ||
+        touchPoint.state() == PlatformTouchPoint::TouchPressed) {

[mustaq, 2017/01/11 19:55:16]

Did you mean TouchReleased instead?

[Navid Zolghadr, 2017/01/16 18:57:23]

I did mean release. But after the issue that I filed with pointerlock I kind of
got convinced to only set these for move events. So now I only check for move
here.

+      pointerEventInit->setMovementX(clientPoint.x() - lastClientX);
+      pointerEventInit->setMovementY(clientPoint.y() - lastClientY);
+    }
+
     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);
@@ skipping 17 matching lines @@
     IntPoint locationInContents =
         frameView->rootFrameToContents(mouseEvent.position());
     locationInFrameZoomed = frameView->contentsToFrame(locationInContents);
     float scaleFactor = 1 / frame->pageZoomFactor();
     locationInFrameZoomed.scale(scaleFactor, scaleFactor);
   }
 
   pointerEventInit->setClientX(locationInFrameZoomed.x());
   pointerEventInit->setClientY(locationInFrameZoomed.y());
 
+  pointerEventInit->setMovementX(mouseEvent.movementDelta().x());
+  pointerEventInit->setMovementY(mouseEvent.movementDelta().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;
 
@@ skipping 128 matching lines @@
 
   PointerEventInit pointerEventInit;
 
   setIdTypeButtons(pointerEventInit, touchPoint.pointerProperties(),
                    pointerReleasedOrCancelled ? 0 : 1);
   pointerEventInit.setButton(static_cast<int>(
       pointerPressedOrReleased ? WebPointerProperties::Button::Left
                                : WebPointerProperties::Button::NoButton));
 
   pointerEventInit.setView(view);
-  updateTouchPointerEventInit(touchPoint, targetFrame, &pointerEventInit);
+  PointerAttributes lastPointerAttributes =
+      m_pointerIdMapping.get(pointerEventInit.pointerId());
+  double lastClientX = lastPointerAttributes.clientX;
+  double lastClientY = lastPointerAttributes.clientY;
+  updateTouchPointerEventInit(touchPoint, targetFrame, lastClientX, lastClientY,
+                              &pointerEventInit);
+  lastPointerAttributes.clientX = pointerEventInit.clientX();
+  lastPointerAttributes.clientY = pointerEventInit.clientY();
+  m_pointerIdMapping.set(pointerEventInit.pointerId(), lastPointerAttributes);
 
   UIEventWithKeyState::setFromPlatformModifiers(pointerEventInit, modifiers);
 
   setEventSpecificFields(pointerEventInit, type);
 
   if (type == EventTypeNames::pointermove) {
     HeapVector<Member<PointerEvent>> coalescedPointerEvents;
     for (const auto& coalescedTouchPoint : coalescedPoints) {
       DCHECK_EQ(touchPoint.state(), coalescedTouchPoint.state());
       DCHECK_EQ(touchPoint.pointerProperties().id,
                 coalescedTouchPoint.pointerProperties().id);
       DCHECK_EQ(touchPoint.pointerProperties().pointerType,
                 coalescedTouchPoint.pointerProperties().pointerType);
       PointerEventInit coalescedEventInit = pointerEventInit;
-      updateTouchPointerEventInit(coalescedTouchPoint, targetFrame,
-                                  &coalescedEventInit);
+      updateTouchPointerEventInit(coalescedTouchPoint, targetFrame, lastClientX,
+                                  lastClientY, &coalescedEventInit);
+      lastClientX = pointerEventInit.clientX();
+      lastClientY = pointerEventInit.clientY();
       coalescedPointerEvents.push_back(
           PointerEvent::create(type, coalescedEventInit));
     }
     pointerEventInit.setCoalescedEvents(coalescedPointerEvents);
   }
 
   return PointerEvent::create(type, 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));
+      pointerId, PointerAttributes(m_pointerIdMapping.get(pointerId).incomingId,
+                                   false, 0, 0));
 
   PointerEventInit pointerEventInit;
 
   pointerEventInit.setPointerId(pointerId);
   pointerEventInit.setPointerType(
       pointerTypeNameForWebPointPointerType(pointerType));
   pointerEventInit.setIsPrimary(isPrimary(pointerId));
 
   setEventSpecificFields(pointerEventInit, EventTypeNames::pointercancel);
 
@@ skipping 64 matching lines @@
   for (int type = 0;
        type <= toInt(WebPointerProperties::PointerType::LastEntry); type++) {
     m_primaryId[type] = PointerEventFactory::s_invalidId;
     m_idCount[type] = 0;
   }
   m_pointerIncomingIdMapping.clear();
   m_pointerIdMapping.clear();
 
   // Always add mouse pointer in initialization and never remove it.
   // No need to add it to m_pointerIncomingIdMapping as it is not going to be
-  // used with the existing APIs
+  // used with the existing APIs.
+  // We don't need to set clientX/Y for the mouse as that will only be used to
+  // set movementX/Y which for mouse it comes from the browser. See Pointer Lock
+  // spec: https://www.w3.org/TR/pointerlock/.
   m_primaryId[toInt(WebPointerProperties::PointerType::Mouse)] = s_mouseId;
   m_pointerIdMapping.add(
       s_mouseId,
       PointerAttributes(IncomingId(WebPointerProperties::PointerType::Mouse, 0),
-                        0));
+                        0, 0, 0));
 
   m_currentId = PointerEventFactory::s_mouseId + 1;
 }
 
 int PointerEventFactory::addIdAndActiveButtons(const IncomingId p,
                                                bool isActiveButtons) {
   // Do not add extra mouse pointer as it was added in initialization
   if (p.pointerType() == WebPointerProperties::PointerType::Mouse) {
-    m_pointerIdMapping.set(s_mouseId, PointerAttributes(p, isActiveButtons));
+    m_pointerIdMapping.set(s_mouseId,
+                           PointerAttributes(p, isActiveButtons, 0, 0));
     return s_mouseId;
   }
 
   if (m_pointerIncomingIdMapping.contains(p)) {
     int mappedId = m_pointerIncomingIdMapping.get(p);
-    m_pointerIdMapping.set(mappedId, PointerAttributes(p, isActiveButtons));
+    PointerAttributes lastPointerAttributes = m_pointerIdMapping.get(mappedId);
+    m_pointerIdMapping.set(
+        mappedId,
+        PointerAttributes(p, isActiveButtons, lastPointerAttributes.clientX,
+                          lastPointerAttributes.clientY));
     return mappedId;
   }
   int typeInt = p.pointerTypeInt();
   // We do not handle the overflow of m_currentId as it should be very rare
   int mappedId = m_currentId++;
   if (!m_idCount[typeInt])
     m_primaryId[typeInt] = mappedId;
   m_idCount[typeInt]++;
   m_pointerIncomingIdMapping.add(p, mappedId);
-  m_pointerIdMapping.add(mappedId, PointerAttributes(p, isActiveButtons));
+
+  // Zero initialization should be fine as we only set the movementX/Y for
+  // pointermove and pointerup.
+  m_pointerIdMapping.add(mappedId, PointerAttributes(p, isActiveButtons, 0, 0));
   return mappedId;
 }
 
 bool PointerEventFactory::remove(const int mappedId) {
   // Do not remove mouse pointer id as it should always be there
   if (mappedId == s_mouseId || !m_pointerIdMapping.contains(mappedId))
     return false;
 
   IncomingId p = m_pointerIdMapping.get(mappedId).incomingId;
   int typeInt = p.pointerTypeInt();
@@ skipping 49 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