Extract touch handling logic from EventHandler

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 "platform/geometry/FloatSize.h"
+
 namespace blink {
 
 namespace {
 
 inline int toInt(WebPointerProperties::PointerType t) { return static_cast<int>(t); }
 
 const char* pointerTypeNameForWebPointPointerType(WebPointerProperties::PointerType type)
 {
     switch (type) {
     case WebPointerProperties::PointerType::Unknown:
@@ skipping 106 matching lines @@
 
     pointerEventInit.setView(view);
     if (relatedTarget)
         pointerEventInit.setRelatedTarget(relatedTarget);
 
     return PointerEvent::create(pointerEventName, pointerEventInit);
 }
 
 PointerEvent* PointerEventFactory::create(const AtomicString& type,
     const PlatformTouchPoint& touchPoint, PlatformEvent::Modifiers modifiers,
-    const double width, const double height,
-    const double clientX, const double clientY)
+    const FloatSize& pointRadius,
+    const FloatPoint& pagePoint)
 {
     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(width);
-    pointerEventInit.setHeight(height);
+    pointerEventInit.setWidth(pointRadius.width());
+    pointerEventInit.setHeight(pointRadius.height());
     pointerEventInit.setTiltX(touchPoint.pointerProperties().tiltX);
     pointerEventInit.setTiltY(touchPoint.pointerProperties().tiltY);
     pointerEventInit.setScreenX(touchPoint.screenPos().x());
     pointerEventInit.setScreenY(touchPoint.screenPos().y());
-    pointerEventInit.setClientX(clientX);
-    pointerEventInit.setClientY(clientY);
+    pointerEventInit.setClientX(pagePoint.x());
+    pointerEventInit.setClientY(pagePoint.y());
     pointerEventInit.setButton(pointerPressedOrReleased ? LeftButton: NoButton);
     pointerEventInit.setPressure(getPointerEventPressure(
         touchPoint.force(), pointerEventInit.buttons()));
 
     UIEventWithKeyState::setFromPlatformModifiers(pointerEventInit, modifiers);
 
     pointerEventInit.setBubbles(!isEnterOrLeave);
     pointerEventInit.setCancelable(!isEnterOrLeave && pointState != PlatformTouchPoint::TouchCancelled);
 
     return PointerEvent::create(type, pointerEventInit);
@@ skipping 132 matching lines @@
     IncomingId p = m_pointerIdMapping.get(mappedId).incomingId;
     int type = p.pointerType();
     m_pointerIdMapping.remove(mappedId);
     m_pointerIncomingIdMapping.remove(p);
     if (m_primaryId[type] == mappedId)
         m_primaryId[type] = PointerEventFactory::s_invalidId;
     m_idCount[type]--;
     return true;
 }
 
-Vector<int> PointerEventFactory::getPointerIdsOfType(WebPointerProperties::PointerType pointerType)
+Vector<int> PointerEventFactory::getPointerIdsOfType(
+    WebPointerProperties::PointerType pointerType) const
 {
     Vector<int> mappedIds;
 
     for (auto iter = m_pointerIdMapping.begin(); iter != m_pointerIdMapping.end(); ++iter) {
         int mappedId = iter->key;
         if (iter->value.incomingId.pointerType() == static_cast<int>(pointerType))
             mappedIds.append(mappedId);
     }
 
     // Sorting for a predictable ordering.
     std::sort(mappedIds.begin(), mappedIds.end());
     return mappedIds;
 }
 
 bool PointerEventFactory::isPrimary(int mappedId) const
 {
     if (!m_pointerIdMapping.contains(mappedId))
         return false;
 
     IncomingId p = m_pointerIdMapping.get(mappedId).incomingId;
     return m_primaryId[p.pointerType()] == mappedId;
 }
 
 WebPointerProperties::PointerType PointerEventFactory::getPointerType(
-    const int pointerId)
+    const int pointerId) const
 {
     if (m_pointerIdMapping.contains(pointerId)) {
         return static_cast<WebPointerProperties::PointerType>(
             m_pointerIdMapping.get(pointerId).incomingId.pointerType());
     }
     return WebPointerProperties::PointerType::Unknown;
 }
 
-bool PointerEventFactory::isActive(const int pointerId)
+bool PointerEventFactory::isActive(const int pointerId) const
 {
     return m_pointerIdMapping.contains(pointerId);
 }
 
-bool PointerEventFactory::isActiveButtonsState(const int pointerId)
+bool PointerEventFactory::isActiveButtonsState(const int pointerId) const
 {
     return m_pointerIdMapping.contains(pointerId)
         && m_pointerIdMapping.get(pointerId).isActiveButtons;
 }
 
+int PointerEventFactory::getPointerEventId(
+    const WebPointerProperties& properties) const

[tdresser, 2016/04/29 15:55:04]

Is |properties| guaranteed to be unique?

[Navid Zolghadr, 2016/04/29 16:31:19]

There are two properties in the WebPointerProperties struct (i.e. pointerType
and id) which we rely on to generate pointer events. Whether it is guaranteed or
not maybe Mustaq knows better. But if it's not the other parts of the code are
quite broken. So I assume the answer would be yes and why we went down this
path.

[mustaq, 2016/04/29 17:03:05]

Navid is right: it is reasonable to assume that low-levels ids are unique per
pointer type. This is true for mouse & touch for sure. We haven't explored
multiple styli (styluses) IIRC, and definitely not multiple mouse pointers:
https://wiki.archlinux.org/index.php/Multi-pointer_X

Good question, Tim. Need to file a low-priority bug.

+{
+    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