Pointerevent capture APIs

third_party/WebKit/Source/core/events/PointerEventManager.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"
 
 namespace blink {
 
 namespace {
 
@@ skipping 10 matching lines @@
         return "pen";
     case WebPointerProperties::PointerType::Mouse:
         return "mouse";
     }
     ASSERT_NOT_REACHED();
     return "";
 }
 
 } // namespace
 
-const PointerEventManager::MappedId PointerEventManager::s_invalidId = 0;
+const int PointerEventManager::s_invalidId = 0;
 
 // Mouse id is 1 to behave the same as MS Edge for compatibility reasons.
-const PointerEventManager::MappedId PointerEventManager::s_mouseId = 1;
+const int 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
+    if (m_pointerCaptureTarget.contains(pointerEvent->pointerId()))
+        return m_pointerCaptureTarget.get(pointerEvent->pointerId());
     return nullptr;
 }
 
+void PointerEventManager::removeTargetFromPointerCapturingMapping(PointerCapturingMap& map, EventTarget* target)
+{
+    // We could have kept a reverse mapping to make this deletion possibly
+    // faster but it adds some code complication which might not be worth of
+    // the performance improvement considering there might not be a lot of
+    // active pointer or pointer captures at the same time.
+    PointerCapturingMap tmp = m_pointerCaptureTarget;
+    for (PointerCapturingMap::iterator it = tmp.begin(); it != tmp.end(); ++it) {
+        if (it->value == target)
+            map.remove(it->key);
+    }
+}
+
+EventTarget* PointerEventManager::getMouseCapturingNode()
+{
+    if (m_pointerCaptureTarget.contains(s_mouseId))
+        return m_pointerCaptureTarget.get(s_mouseId);
+    return nullptr;
+}
+
+void PointerEventManager::elementRemoved(EventTarget* target)
+{
+    removeTargetFromPointerCapturingMapping(m_pointerCaptureTarget, target);
+    removeTargetFromPointerCapturingMapping(m_pendingPointerCaptureTarget, target);
+    // TODO(nzolghadr): Process sending lostpointercapture to the document
+}
+
+void PointerEventManager::setPointerCapture(int pointerId, EventTarget* target)
+{
+    if (isActiveButtons(pointerId))
+        m_pendingPointerCaptureTarget.set(pointerId, target);
+}
+
+void PointerEventManager::releasePointerCapture(int pointerId, EventTarget* target)
+{
+    if (m_pointerCaptureTarget.contains(pointerId) &&  m_pointerCaptureTarget.get(pointerId) == target)
+        implicitReleasePointerCapture(pointerId);
+}
+
+void PointerEventManager::implicitReleasePointerCapture(int pointerId)
+{
+    if (m_pendingPointerCaptureTarget.contains(pointerId))
+        m_pendingPointerCaptureTarget.remove(pointerId);
+}
 void PointerEventManager::setIdAndType(PointerEventInit &pointerEventInit,
-    const WebPointerProperties &pointerProperties)
+    const WebPointerProperties &pointerProperties, int buttons)
 {
     const WebPointerProperties::PointerType pointerType = pointerProperties.pointerType;
-    MappedId pointerId = add(PointerEventManager::IncomingId(toInt(pointerType), pointerProperties.id));
+    int pointerId = addAndUpdateButtons(PointerEventManager::IncomingId(toInt(pointerType), pointerProperties.id), buttons);
     pointerEventInit.setPointerId(pointerId);
     pointerEventInit.setPointerType(pointerTypeNameForWebPointPointerType(pointerType));
     pointerEventInit.setIsPrimary(isPrimary(pointerId));
+    processPendingPointerCapture(pointerId);
+}
+
+void PointerEventManager::processPendingPointerCapture(int pointerId)
+{
+    // TODO(nzolghadr): Process sending got/lostpointercapture
+
+    if (!m_pendingPointerCaptureTarget.contains(pointerId))
+        m_pointerCaptureTarget.remove(pointerId);
+    else
+        m_pointerCaptureTarget.set(pointerId, m_pendingPointerCaptureTarget.get(pointerId));
 }
 
 PassRefPtrWillBeRawPtr<PointerEvent> PointerEventManager::create(const AtomicString& type,
     const PlatformMouseEvent& mouseEvent,
     PassRefPtrWillBeRawPtr<Node> relatedTarget,
     PassRefPtrWillBeRawPtr<AbstractView> view)
 {
     PointerEventInit pointerEventInit;
+    int buttons = MouseEvent::platformModifiersToButtons(mouseEvent.modifiers());
 
-    setIdAndType(pointerEventInit, mouseEvent.pointerProperties());
+    setIdAndType(pointerEventInit, mouseEvent.pointerProperties(), buttons);
 
     pointerEventInit.setScreenX(mouseEvent.globalPosition().x());
     pointerEventInit.setScreenY(mouseEvent.globalPosition().y());
     pointerEventInit.setClientX(mouseEvent.position().x());
     pointerEventInit.setClientY(mouseEvent.position().y());
 
     pointerEventInit.setButton(mouseEvent.button());
-    pointerEventInit.setButtons(MouseEvent::platformModifiersToButtons(mouseEvent.modifiers()));
+    pointerEventInit.setButtons(buttons);
 
     UIEventWithKeyState::setFromPlatformModifiers(pointerEventInit, mouseEvent.modifiers());
 
     pointerEventInit.setBubbles(type != EventTypeNames::pointerenter
         && type != EventTypeNames::pointerleave);
     pointerEventInit.setCancelable(type != EventTypeNames::pointerenter
         && type != EventTypeNames::pointerleave && type != EventTypeNames::pointercancel);
 
     pointerEventInit.setView(view);
-    if (relatedTarget)
+    if (relatedTarget && !m_pointerCaptureTarget.contains(pointerEventInit.pointerId()))
         pointerEventInit.setRelatedTarget(relatedTarget);
 
     return PointerEvent::create(type, pointerEventInit);
 }
 
 PassRefPtrWillBeRawPtr<PointerEvent> PointerEventManager::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;
 
     PointerEventInit pointerEventInit;
+    int buttons = pointerReleasedOrCancelled ? 0 : 1;
 
-    setIdAndType(pointerEventInit, touchPoint.pointerProperties());
+    setIdAndType(pointerEventInit, touchPoint.pointerProperties(), buttons);
 
     pointerEventInit.setWidth(width);
     pointerEventInit.setHeight(height);
     pointerEventInit.setPressure(touchPoint.force());
     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.setButton(0);
-    pointerEventInit.setButtons(pointerReleasedOrCancelled ? 0 : 1);
+    pointerEventInit.setButtons(buttons);
 
     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)
 {
     PointerEventInit pointerEventInit;
 
-    setIdAndType(pointerEventInit, touchPoint.pointerProperties());
+    setIdAndType(pointerEventInit, touchPoint.pointerProperties(), 0);
 
     pointerEventInit.setBubbles(true);
     pointerEventInit.setCancelable(false);
 
     return PointerEvent::create(EventTypeNames::pointercancel, pointerEventInit);
 }
 
 PointerEventManager::PointerEventManager()
 {
     clear();
 }
 
 PointerEventManager::~PointerEventManager()
 {
     clear();
 }
 
 void PointerEventManager::clear()
 {
     for (int type = 0; type <= toInt(WebPointerProperties::PointerType::LastEntry); type++) {
         m_primaryId[type] = PointerEventManager::s_invalidId;
         m_idCount[type] = 0;
     }
+    m_pointerCaptureTarget.clear();
+    m_pendingPointerCaptureTarget.clear();
     m_idMapping.clear();
     m_idReverseMapping.clear();
+    m_lastButtons.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_lastButtons.add(s_mouseId, 0);
 
     m_currentId = PointerEventManager::s_mouseId+1;
 }
 
-PointerEventManager::MappedId PointerEventManager::add(const IncomingId p)
+int PointerEventManager::addAndUpdateButtons(const IncomingId p, const int buttons)
+{
+    int mappedId = add(p);
+    m_lastButtons.set(mappedId, buttons);
+    return mappedId;
+}
+
+int PointerEventManager::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 mappedId;
 }
 
 void PointerEventManager::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;
+    implicitReleasePointerCapture(mappedId);
     m_idReverseMapping.remove(mappedId);
     m_idMapping.remove(p);
     if (m_primaryId[type] == mappedId)
         m_primaryId[type] = PointerEventManager::s_invalidId;
     m_idCount[type]--;
 }
 
-bool PointerEventManager::isPrimary(PointerEventManager::MappedId mappedId) const
+bool PointerEventManager::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;
 }
 
+bool PointerEventManager::isActive(const int pointerId)
+{
+    return m_idReverseMapping.contains(pointerId);
+}
+
+bool PointerEventManager::isActiveButtons(const int pointerId)
+{
+    return m_lastButtons.contains(pointerId) && m_lastButtons.get(pointerId);
+}
 
 } // namespace blink