Cleaning up PointerIdManager and add id re-mapping

third_party/WebKit/Source/core/input/EventHandler.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  * Copyright (C) 2012 Digia Plc. and/or its subsidiary(-ies)
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
@@ skipping 1601 matching lines @@
         sendMouseEventsForNodeTransition(lastNodeUnderMouse.get(), m_nodeUnderMouse.get(), mouseEvent);
 }
 
 bool EventHandler::dispatchPointerEvent(Node* target, const AtomicString& eventType,
     const PlatformMouseEvent& mouseEvent, Node* relatedTarget)
 {
     if (!RuntimeEnabledFeatures::pointerEventEnabled())
         return false;
 
     RefPtrWillBeRawPtr<PointerEvent> pointerEvent = PointerEvent::create(eventType, true,
-        mouseEvent, relatedTarget, m_frame->document()->domWindow());
+        mouseEvent, relatedTarget, m_frame->document()->domWindow(),
+        m_pointerIdManager.getPrimaryId(WebPointerProperties::PointerType::Mouse));
     target->dispatchEvent(pointerEvent.get());
     return pointerEvent->defaultPrevented() || pointerEvent->defaultHandled();
 }
 
 void EventHandler::sendMouseEventsForNodeTransition(Node* exitedNode, Node* enteredNode,
     const PlatformMouseEvent& mouseEvent)
 {
     ASSERT(exitedNode != enteredNode);
 
     // Dispatch pointerout/mouseout events
@@ skipping 2016 matching lines @@
     if (!RuntimeEnabledFeatures::pointerEventEnabled())
         return;
 
     // Iterate through the touch points, sending PointerEvents to the targets as required.
     for (unsigned i = 0; i < touchInfos.size(); ++i) {
         TouchInfo& touchInfo = touchInfos[i];
         const PlatformTouchPoint& touchPoint = touchInfo.point;
         const unsigned& pointerId = touchPoint.id();
         const PlatformTouchPoint::State pointState = touchPoint.state();
 
+
         if (pointState == PlatformTouchPoint::TouchStationary || !touchInfo.knownTarget)
             continue;
 
         bool pointerReleasedOrCancelled = pointState == PlatformTouchPoint::TouchReleased
             || pointState == PlatformTouchPoint::TouchCancelled;
         const WebPointerProperties::PointerType pointerType = touchPoint.pointerProperties().pointerType;
 
-        if (pointState == PlatformTouchPoint::TouchPressed)
-            m_pointerIdManager.add(pointerType, pointerId);
+        // The id gets added the first time we call add which should TouchPressed
+        // and the consecutive calls with the same GeneratedPointer will return the same MappedId.
+        const PointerIdManager::MappedId mappedId = m_pointerIdManager.add(PointerIdManager::GeneratedPointer(pointerType, pointerId));

[mustaq, 2015/11/20 20:13:53]

This looks good. One concern is that EventHandler now has to worry too much
about PE ids w/o really doing anything with it. The state maintained through
m_pointerIdManager is unavoidable, but at least GeneratedPointer could be hidden
inside PointerEvent.

What if you just pass a PointerIdManager reference to PointerEvent::create()
methods so that the id mapping invisible to EventHandler?

Am I right that in that case, users of PointerEvent would know nothing about
mapped ids, and therefore, would pass only raw int/unsigned ids to
PointerIdManager methods? PointerEvent will be the only user of mapped ids then.

[Navid Zolghadr, 2015/11/20 20:32:22]

Then maybe in this case we can change PointerIdManager to PointerEventManager
and the new class will play the role of a factory class for PointerEvent class.
So all the create methods from PointerEvent will be moved to PointerEventManager
and then this guarantees nobody can create PointerEvent directly and everybody
goes through PointerEventManager and this class makes sure all the ids and
everything is unique. Is this a better approach then?

 
         RefPtrWillBeRawPtr<PointerEvent> pointerEvent = PointerEvent::create(
             pointerEventNameForTouchPointState(pointState),
-            m_pointerIdManager.isPrimary(pointerType, pointerId),
+            m_pointerIdManager.isPrimary(mappedId),
             touchPoint, event.modifiers(),
             touchInfo.adjustedRadius.width(), touchInfo.adjustedRadius.height(),
-            touchInfo.adjustedPagePoint.x(), touchInfo.adjustedPagePoint.y());
+            touchInfo.adjustedPagePoint.x(), touchInfo.adjustedPagePoint.y(),
+            mappedId);
 
         touchInfo.touchTarget->dispatchEvent(pointerEvent.get());
         touchInfo.consumed = pointerEvent->defaultPrevented() || pointerEvent->defaultHandled();
 
         // Remove the released/cancelled id at the end to correctly determine primary id above.
         if (pointerReleasedOrCancelled)
-            m_pointerIdManager.remove(pointerType, pointerId);
+            m_pointerIdManager.remove(mappedId);
     }
 }
 
 void EventHandler::sendPointerCancels(WillBeHeapVector<TouchInfo>& touchInfos)
 {
     if (!RuntimeEnabledFeatures::pointerEventEnabled())
         return;
 
     for (unsigned i = 0; i < touchInfos.size(); ++i) {
         TouchInfo& touchInfo = touchInfos[i];
         const PlatformTouchPoint& point = touchInfo.point;
         const unsigned& pointerId = point.id();
         const PlatformTouchPoint::State pointState = point.state();
 
         if (pointState == PlatformTouchPoint::TouchReleased
             || pointState == PlatformTouchPoint::TouchCancelled)
             continue;
 
         PointerEventInit pointerEventInit;
         pointerEventInit.setPointerId(pointerId);
         pointerEventInit.setBubbles(true);
         pointerEventInit.setCancelable(false);
 
         RefPtrWillBeRawPtr<PointerEvent> pointerEvent = PointerEvent::create(
             EventTypeNames::pointercancel, pointerEventInit);
         touchInfo.touchTarget->dispatchEvent(pointerEvent.get());
 
-        m_pointerIdManager.remove(WebPointerProperties::PointerType::Touch, pointerId);
+        m_pointerIdManager.remove(PointerIdManager::GeneratedPointer(WebPointerProperties::PointerType::Touch, pointerId));
     }
 }
 
 bool EventHandler::dispatchTouchEvents(const PlatformTouchEvent& event,
     WillBeHeapVector<TouchInfo>& touchInfos, bool freshTouchEvents, bool allTouchReleased)
 {
     // Build up the lists to use for the 'touches', 'targetTouches' and
     // 'changedTouches' attributes in the JS event. See
     // http://www.w3.org/TR/touch-events/#touchevent-interface for how these
     // lists fit together.
@@ skipping 352 matching lines @@
 PlatformEvent::Modifiers EventHandler::accessKeyModifiers()
 {
 #if OS(MACOSX)
     return static_cast<PlatformEvent::Modifiers>(PlatformEvent::CtrlKey | PlatformEvent::AltKey);
 #else
     return PlatformEvent::AltKey;
 #endif
 }
 
 } // namespace blink