Send node transition events for touch events

third_party/WebKit/Source/core/events/PointerEventFactory.cpp

 // Copyright 2015 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/PointerEventManager.h"
+#include "core/events/PointerEventFactory.h"

[Ian Vollick, 2016/02/12 15:01:17]

Although the net result seems clearer, this patch is made a little confusing by
moving PointerEventManager to PointerEventFactory as well as introducing a new
class named PointerEventManager which does different stuff.

Is this a correct interpretation of what's happening here:
 * Since the old PointerEventManager was behaving mostly as a factory, you've
made it official and added some more factory stuff.
 * You've refactored some event management stuff out of EventHandler into a new
PointerEventManager class that it aggregates?

[mustaq, 2016/02/12 15:17:40]

Yes, mainly to isolate:
  (a) PointerEvent states & dispatches, and
  (b) PointerEvent creation & id-management
from each other and also from EventHandler.

Navid, please mention this in the CL description.

[Navid Zolghadr, 2016/02/12 16:30:47]

Done

 
 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:
         return "";
     case WebPointerProperties::PointerType::Touch:
         return "touch";
     case WebPointerProperties::PointerType::Pen:
         return "pen";
     case WebPointerProperties::PointerType::Mouse:
         return "mouse";
     }
     ASSERT_NOT_REACHED();
     return "";
 }
 
 } // namespace
 
-const PointerEventManager::MappedId PointerEventManager::s_invalidId = 0;
+const int PointerEventFactory::s_invalidId = 0;
 
 // Mouse id is 1 to behave the same as MS Edge for compatibility reasons.
-const PointerEventManager::MappedId PointerEventManager::s_mouseId = 1;
-
-EventTarget* PointerEventManager::getCapturingNode(PassRefPtrWillBeRawPtr<PointerEvent> pointerEvent)
-{
-    // TODO(nzolghadr): Add APIs to set the capturing nodes and return the correct node here
-    return nullptr;
-}
+const int PointerEventFactory::s_mouseId = 1;
 
 float getPointerEventPressure(float force, int buttons)
 {
     if (std::isnan(force))
         return buttons ? 0.5 : 0;
     return force;
 }
 
-void PointerEventManager::setIdAndType(PointerEventInit &pointerEventInit,
+void PointerEventFactory::setIdAndType(PointerEventInit &pointerEventInit,
     const WebPointerProperties &pointerProperties)
 {
     const WebPointerProperties::PointerType pointerType = pointerProperties.pointerType;
-    MappedId pointerId = add(PointerEventManager::IncomingId(toInt(pointerType), pointerProperties.id));
+    int pointerId = add(PointerEventFactory::IncomingId(toInt(pointerType), pointerProperties.id));
     pointerEventInit.setPointerId(pointerId);
     pointerEventInit.setPointerType(pointerTypeNameForWebPointPointerType(pointerType));
     pointerEventInit.setIsPrimary(isPrimary(pointerId));
 }
 
-PassRefPtrWillBeRawPtr<PointerEvent> PointerEventManager::create(const AtomicString& type,
+PassRefPtrWillBeRawPtr<PointerEvent> PointerEventFactory::create(const AtomicString& type,
     const PlatformMouseEvent& mouseEvent,
     PassRefPtrWillBeRawPtr<Node> relatedTarget,
     PassRefPtrWillBeRawPtr<AbstractView> view)
 {
     PointerEventInit pointerEventInit;
 
     setIdAndType(pointerEventInit, mouseEvent.pointerProperties());
 
     pointerEventInit.setScreenX(mouseEvent.globalPosition().x());
     pointerEventInit.setScreenY(mouseEvent.globalPosition().y());
@@ skipping 12 matching lines @@
     pointerEventInit.setCancelable(type != EventTypeNames::pointerenter
         && type != EventTypeNames::pointerleave && type != EventTypeNames::pointercancel);
 
     pointerEventInit.setView(view);
     if (relatedTarget)
         pointerEventInit.setRelatedTarget(relatedTarget);
 
     return PointerEvent::create(type, pointerEventInit);
 }
 
-PassRefPtrWillBeRawPtr<PointerEvent> PointerEventManager::create(const AtomicString& type,
+PassRefPtrWillBeRawPtr<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 PlatformTouchPoint::State pointState = touchPoint.state();
 
     bool pointerReleasedOrCancelled = pointState == PlatformTouchPoint::TouchReleased
         || pointState == PlatformTouchPoint::TouchCancelled;
 
     bool isEnterOrLeave = false;
@@ skipping 17 matching lines @@
 
     UIEventWithKeyState::setFromPlatformModifiers(pointerEventInit, modifiers);
 
     pointerEventInit.setBubbles(!isEnterOrLeave);
     pointerEventInit.setCancelable(!isEnterOrLeave && pointState != PlatformTouchPoint::TouchCancelled);
 
     return PointerEvent::create(type, pointerEventInit);
 }
 
 
-PassRefPtrWillBeRawPtr<PointerEvent> PointerEventManager::createPointerCancel(const PlatformTouchPoint& touchPoint)
+PassRefPtrWillBeRawPtr<PointerEvent> PointerEventFactory::createPointerCancel(const PlatformTouchPoint& touchPoint)
 {
     PointerEventInit pointerEventInit;
 
     setIdAndType(pointerEventInit, touchPoint.pointerProperties());
 
     pointerEventInit.setBubbles(true);
     pointerEventInit.setCancelable(false);
 
     return PointerEvent::create(EventTypeNames::pointercancel, pointerEventInit);
 }
 
-PointerEventManager::PointerEventManager()
+PassRefPtrWillBeRawPtr<PointerEvent> PointerEventFactory::create(
+    PassRefPtrWillBeRawPtr<PointerEvent> pointerevent,

[Ian Vollick, 2016/02/12 15:01:17]

nit: camel case.

[Navid Zolghadr, 2016/02/12 16:30:47]

Done

+    const AtomicString& type,
+    PassRefPtrWillBeRawPtr<EventTarget> relatedTarget)
+{
+    PointerEventInit pointerEventInit;
+
+    pointerEventInit.setPointerId(pointerevent->pointerId());
+    pointerEventInit.setPointerType(pointerevent->pointerType());
+    pointerEventInit.setIsPrimary(pointerevent->isPrimary());
+    pointerEventInit.setWidth(pointerevent->width());
+    pointerEventInit.setHeight(pointerevent->height());
+    pointerEventInit.setTiltX(pointerevent->tiltX());
+    pointerEventInit.setTiltY(pointerevent->tiltY());
+    pointerEventInit.setScreenX(pointerevent->screenX());
+    pointerEventInit.setScreenY(pointerevent->screenY());
+    pointerEventInit.setClientX(pointerevent->clientX());
+    pointerEventInit.setClientY(pointerevent->clientY());
+    pointerEventInit.setButton(pointerevent->button());
+    pointerEventInit.setButtons(pointerevent->buttons());
+    pointerEventInit.setPressure(pointerevent->pressure());
+
+    pointerEventInit.setBubbles(type != EventTypeNames::pointerenter
+        && type != EventTypeNames::pointerleave);
+    pointerEventInit.setCancelable(type != EventTypeNames::pointerenter
+        && type != EventTypeNames::pointerleave
+        && type != EventTypeNames::pointercancel);
+    if (relatedTarget)
+        pointerEventInit.setRelatedTarget(relatedTarget);
+
+    return PointerEvent::create(type, pointerEventInit);
+}
+
+PointerEventFactory::PointerEventFactory()
 {
     clear();
 }
 
-PointerEventManager::~PointerEventManager()
+PointerEventFactory::~PointerEventFactory()
 {
     clear();
 }
 
-void PointerEventManager::clear()
+void PointerEventFactory::clear()
 {
     for (int type = 0; type <= toInt(WebPointerProperties::PointerType::LastEntry); type++) {
-        m_primaryId[type] = PointerEventManager::s_invalidId;
+        m_primaryId[type] = PointerEventFactory::s_invalidId;
         m_idCount[type] = 0;
     }
     m_idMapping.clear();
     m_idReverseMapping.clear();
 
     // Always add mouse pointer in initialization and never remove it.
     // No need to add it to m_idMapping as it is not going to be used with the existing APIs
     m_primaryId[toInt(WebPointerProperties::PointerType::Mouse)] = s_mouseId;
     m_idReverseMapping.add(s_mouseId, IncomingId(toInt(WebPointerProperties::PointerType::Mouse), 0));
 
-    m_currentId = PointerEventManager::s_mouseId+1;
+    m_currentId = PointerEventFactory::s_mouseId+1;
 }
 
-PointerEventManager::MappedId PointerEventManager::add(const IncomingId p)
+int PointerEventFactory::add(const IncomingId p)
 {
     // Do not add extra mouse pointer as it was added in initialization
     if (p.first == toInt(WebPointerProperties::PointerType::Mouse))
         return s_mouseId;
 
     int type = p.first;
     if (m_idMapping.contains(p))
         return m_idMapping.get(p);
     // We do not handle the overflow of m_currentId as it should be very rare
-    MappedId mappedId = m_currentId++;
+    int mappedId = m_currentId++;
     if (!m_idCount[type])
         m_primaryId[type] = mappedId;
     m_idCount[type]++;
     m_idMapping.add(p, mappedId);
     m_idReverseMapping.add(mappedId, p);
-    return static_cast<PointerEventManager::MappedId>(mappedId);
+    return static_cast<int>(mappedId);
 }
 
-void PointerEventManager::remove(const PassRefPtrWillBeRawPtr<PointerEvent> pointerEvent)
+void PointerEventFactory::remove(
+    const PassRefPtrWillBeRawPtr<PointerEvent> pointerEvent)
 {
-    MappedId mappedId = pointerEvent->pointerId();
+    int mappedId = pointerEvent->pointerId();
     // Do not remove mouse pointer id as it should always be there
     if (mappedId == s_mouseId || !m_idReverseMapping.contains(mappedId))
         return;
 
     IncomingId p = m_idReverseMapping.get(mappedId);
     int type = p.first;
     m_idReverseMapping.remove(mappedId);
     m_idMapping.remove(p);
     if (m_primaryId[type] == mappedId)
-        m_primaryId[type] = PointerEventManager::s_invalidId;
+        m_primaryId[type] = PointerEventFactory::s_invalidId;
     m_idCount[type]--;
 }
 
-bool PointerEventManager::isPrimary(PointerEventManager::MappedId mappedId) const
+bool PointerEventFactory::isPrimary(int mappedId) const
 {
     if (!m_idReverseMapping.contains(mappedId))
         return false;
 
     IncomingId p = m_idReverseMapping.get(mappedId);
     int type = p.first;
     return m_primaryId[type] == mappedId;
 }
 
 
 } // namespace blink