Pointerevent capture APIs

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 1643 matching lines @@
 
     bool dispatchResult = target->dispatchEvent(pointerEvent.get());
     return eventToEventResult(pointerEvent, dispatchResult);
 }
 
 void EventHandler::sendNodeTransitionEvents(Node* exitedNode, Node* enteredNode,
     const PlatformMouseEvent& mouseEvent)
 {
     ASSERT(exitedNode != enteredNode);
 
-    // Dispatch pointerout/mouseout events
-    if (isNodeInDocument(exitedNode)) {
-        sendPointerAndMouseTransitionEvents(exitedNode, EventTypeNames::mouseout, mouseEvent, enteredNode, false);
+    if (m_pointerEventManager.getMouseCapturingNode()) {
+        EventTarget* target = m_pointerEventManager.getMouseCapturingNode();

[mustaq, 2016/02/06 04:36:31]

s/target/capturingNode/

[Navid Zolghadr, 2016/02/08 15:58:43]

Done.

+        if (target == exitedNode)
+            enteredNode = nullptr;
+        else if (target == enteredNode)
+            exitedNode = nullptr;

[mustaq, 2016/02/06 04:36:31]

Perhaps this won't happen but not sure: any chance this could be wrong when the
pointer was first captured?

[Navid Zolghadr, 2016/02/08 15:58:43]

Do you have any particular scenario in mind? I can't imagine any problematic one
here.

+        else
+            return;
     }
 
     // A note on mouseenter and mouseleave: These are non-bubbling events, and they are dispatched if there
     // is a capturing event handler on an ancestor or a normal event handler on the element itself. This special
     // handling is necessary to avoid O(n^2) capturing event handler checks.
     //
     //   Note, however, that this optimization can possibly cause some unanswered/missing/redundant mouseenter or
     // mouseleave events in certain contrived eventhandling scenarios, e.g., when:
     // - the mouseleave handler for a node sets the only capturing-mouseleave-listener in its ancestor, or
     // - DOM mods in any mouseenter/mouseleave handler changes the common ancestor of exited & entered nodes, etc.
@@ skipping 12 matching lines @@
             exitedAncestors.append(node);
         }
     }
     if (isNodeInDocument(enteredNode)) {
         enteredNode->updateDistribution();
         for (Node* node = enteredNode; node; node = ComposedTreeTraversal::parent(*node)) {
             enteredAncestors.append(node);
         }
     }
 
+    // Dispatch pointerout/mouseout events
+    if (isNodeInDocument(exitedNode)) {
+        sendPointerAndMouseTransitionEvents(exitedNode, EventTypeNames::mouseout, mouseEvent, enteredNode, false);
+    }
+
     size_t numExitedAncestors = exitedAncestors.size();
     size_t numEnteredAncestors = enteredAncestors.size();
 
     size_t exitedAncestorIndex = numExitedAncestors;
     size_t enteredAncestorIndex = numEnteredAncestors;
     for (size_t j = 0; j < numExitedAncestors; j++) {
         for (size_t i = 0; i < numEnteredAncestors; i++) {
             if (exitedAncestors[j] == enteredAncestors[i]) {
                 exitedAncestorIndex = j;
                 enteredAncestorIndex = i;
@@ skipping 42 matching lines @@
 {
     updateMouseEventTargetNode(targetNode, mouseEvent);
     if (!m_nodeUnderMouse)
         return WebInputEventResult::NotHandled;
 
     RefPtrWillBeRawPtr<MouseEvent> event = MouseEvent::create(eventType, m_nodeUnderMouse->document().domWindow(), mouseEvent, clickCount, nullptr);
     bool dispatchResult = m_nodeUnderMouse->dispatchEvent(event);
     return eventToEventResult(event, dispatchResult);
 }
 
+bool EventHandler::isPointerEventActive(int pointerId)
+{
+    return m_pointerEventManager.isActive(pointerId);
+}
+
+void EventHandler::setPointerCapture(int pointerId, EventTarget* target)
+{
+    m_pointerEventManager.setPointerCapture(pointerId, target);
+}
+
+void EventHandler::releasePointerCapture(int pointerId, EventTarget* target)
+{
+    m_pointerEventManager.releasePointerCapture(pointerId, target);
+}
+
+void EventHandler::elementRemoved(EventTarget* target)
+{
+    m_pointerEventManager.elementRemoved(target);
+}
+
 EventTarget* EventHandler::getEffectiveTargetForPointerEvent(
     EventTarget* target, PassRefPtrWillBeRawPtr<PointerEvent> pointerEvent)
 {
     EventTarget* capturingNode = m_pointerEventManager.getCapturingNode(pointerEvent.get());
     if (capturingNode)
         target = capturingNode;
     return target;
 }
 
 void EventHandler::sendPointerAndMouseTransitionEvents(Node* target, const AtomicString& mouseEventType,
     const PlatformMouseEvent& mouseEvent, Node* relatedTarget, bool checkForListener)
 {
     ASSERT(mouseEventType == EventTypeNames::mouseenter
         || mouseEventType == EventTypeNames::mouseleave
         || mouseEventType == EventTypeNames::mouseover
         || mouseEventType == EventTypeNames::mouseout);
 
     AtomicString pointerEventType = pointerEventNameForMouseEventName(mouseEventType);
     RefPtrWillBeRawPtr<PointerEvent> pointerEvent = m_pointerEventManager.create(pointerEventType,
         mouseEvent, relatedTarget, m_frame->document()->domWindow());
 
-    // Suppress these events if the target is not the capturing element
-    if (target != getEffectiveTargetForPointerEvent(target, pointerEvent))
+
+    int isAncestor = false;

[mustaq, 2016/02/06 04:36:31]

I guess you can avoid the loop below for mouseover & mouseout, right? If this is
the case, please make it conditional.

Alternatively, can we instead trim the node parent lists even in
sendNodeTransitionEvents(), to save some iterations there?

[Navid Zolghadr, 2016/02/08 15:58:43]

I believe I can get rid of this for now as the change I made in
sendNodeTransitionEvents will take care of this. I started by adding this change
and later that I added the changes in sendNodeTransitionEvents I forgot to
remove these changes here. Basically this change has not effect as the for loop
always return true and there is no need for this portion of the change here.

+    for (Node* node = target; node; node = ComposedTreeTraversal::parent(*node)) {
+        if (node == target) {

[mustaq, 2016/02/06 04:36:31]

I think the loop should start at node = capturingNode, right?

+            isAncestor = true;
+            break;
+        }
+    }
+    // Suppress these events if the target is not the capturing element inclusive ancestors

[mustaq, 2016/02/06 04:36:31]

Is it clearer?
"...if target is not an (inclusive) ancestor of the capturing element"

+    if (!isAncestor)
         return;
 
     if (!checkForListener || target->hasEventListeners(pointerEventType))
         dispatchPointerEvent(target, pointerEvent);
 
     if (!checkForListener || target->hasEventListeners(mouseEventType))
         target->dispatchMouseEvent(mouseEvent, mouseEventType, 0, relatedTarget);
 }
 
 // TODO(mustaq): Make PE drive ME dispatch & bookkeeping in EventHandler.
@@ skipping 23 matching lines @@
 
     if (result != WebInputEventResult::NotHandled && pointerEventType == EventTypeNames::pointerdown)
         m_preventMouseEventForPointerTypeMouse = true;
 
     if (!m_preventMouseEventForPointerTypeMouse) {
         RefPtrWillBeRawPtr<MouseEvent> event = MouseEvent::create(mouseEventType, m_nodeUnderMouse->document().domWindow(), mouseEvent, clickCount, nullptr);
         bool dispatchResult = target->dispatchEvent(event);
         result = mergeEventResult(result, eventToEventResult(event, dispatchResult));
     }
 
+    if (pointerEvent->buttons() == 0)
+        m_pointerEventManager.implicitReleasePointerCapture(pointerEvent->pointerId());
+
     return result;
 }
 
 WebInputEventResult EventHandler::handleMouseFocus(const MouseEventWithHitTestResults& targetedEvent, InputDeviceCapabilities* sourceCapabilities)
 {
     // If clicking on a frame scrollbar, do not mess up with content focus.
     if (targetedEvent.hitTestResult().scrollbar() && m_frame->contentLayoutObject()) {
         if (targetedEvent.hitTestResult().scrollbar()->scrollableArea() == m_frame->contentLayoutObject()->scrollableArea())
             return WebInputEventResult::NotHandled;
     }
@@ skipping 2330 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