Send lostpointercapture on touch capturing

third_party/WebKit/Source/core/input/PointerEventManager.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/input/PointerEventManager.h"
 
 #include "core/dom/shadow/FlatTreeTraversal.h"
 #include "core/events/MouseEvent.h"
 #include "core/input/EventHandler.h"
 
@@ skipping 289 matching lines @@
     RefPtrWillBeRawPtr<PointerEvent> pointerEvent = m_pointerEventFactory.createPointerCancelEvent(point);
 
 
     processCaptureAndPositionOfPointerEvent(pointerEvent, target);
 
     // TODO(nzolghadr): crbug.com/579553 dealing with implicit touch capturing vs pointer event capturing
     dispatchPointerEvent(
         getEffectiveTargetForPointerEvent(target, pointerEvent->pointerId()),
         pointerEvent.get());
 
-    setNodeUnderPointer(pointerEvent, nullptr);
+    releasePointerCapture(pointerEvent->pointerId());
+
+    // Sending the leave/out events as well as lostpointercapture if required
+    processCaptureAndPositionOfPointerEvent(pointerEvent, nullptr);
 
     removePointer(pointerEvent);
 }
 
 WebInputEventResult PointerEventManager::sendTouchPointerEvent(

[mustaq, 2016/03/30 21:21:54]

Forgot to include the caller?

[Navid Zolghadr, 2016/03/31 14:41:47]

I'm not quite sure what you mean here. Are you talking about EventHandler that
calls this function? What should I do with that? 

[mustaq, 2016/03/31 15:24:44]

EventHandler::handleTouchEvent::freshTouchEvents would trigger setPointerCapture
here, but just realized that bool is true only when all TouchPoints are
touchstarts.

But wait, the same idea works: you can call setPointerCapture when
state==PlatformTouchPoint::TouchPressed, right? Not passing |isNew| to |create|
looks cleaner to me.

[Navid Zolghadr, 2016/03/31 16:22:25]

That definitely sounds cleaner. I haven't thought of that. 

     PassRefPtrWillBeRawPtr<EventTarget> prpTarget,
     const PlatformTouchPoint& touchPoint, PlatformEvent::Modifiers modifiers,
     const double width, const double height,
     const double clientX, const double clientY)
 {
     RefPtrWillBeRawPtr<EventTarget> target = prpTarget;
+    bool isNew = false;
 
     RefPtrWillBeRawPtr<PointerEvent> pointerEvent =
         m_pointerEventFactory.create(
         pointerEventNameForTouchPointState(touchPoint.state()),
-        touchPoint, modifiers, width, height, clientX, clientY);
+        touchPoint, modifiers, width, height, clientX, clientY, isNew);
 
     processCaptureAndPositionOfPointerEvent(pointerEvent, target);
 
     // TODO(nzolghadr): crbug.com/579553 dealing with implicit touch capturing vs pointer event capturing
     WebInputEventResult result = dispatchPointerEvent(
         getEffectiveTargetForPointerEvent(target, pointerEvent->pointerId()),
         pointerEvent.get());
 
+    // Setting the implicit capture for touch
+    if (isNew)
+        setPointerCapture(pointerEvent->pointerId(), target);
+
     if (touchPoint.state() == PlatformTouchPoint::TouchReleased
         || touchPoint.state() == PlatformTouchPoint::TouchCancelled) {
-        setNodeUnderPointer(pointerEvent, nullptr);
+        releasePointerCapture(pointerEvent->pointerId());
+
+        // Sending the leave/out events as well as lostpointercapture if required
+        processCaptureAndPositionOfPointerEvent(pointerEvent, nullptr);
+
         removePointer(pointerEvent);
     }
 
     return result;
 }
 
 WebInputEventResult PointerEventManager::sendMousePointerEvent(
     PassRefPtrWillBeRawPtr<Node> prpTarget, const AtomicString& mouseEventType,
     int clickCount, const PlatformMouseEvent& mouseEvent,
     PassRefPtrWillBeRawPtr<Node> relatedTarget,
@@ skipping 46 matching lines @@
 
 PointerEventManager::~PointerEventManager()
 {
 }
 
 void PointerEventManager::clear()
 {
     m_preventMouseEventForPointerTypeMouse = false;
     m_pointerEventFactory.clear();
     m_nodeUnderPointer.clear();
+    m_pointerCaptureTarget.clear();
+    m_pendingPointerCaptureTarget.clear();
 }
 
 void PointerEventManager::processCaptureAndPositionOfPointerEvent(
     const PassRefPtrWillBeRawPtr<PointerEvent> prpPointerEvent,
     const PassRefPtrWillBeRawPtr<EventTarget> prpHitTestTarget,
     const PassRefPtrWillBeRawPtr<EventTarget> lastNodeUnderMouse,
     const PlatformMouseEvent& mouseEvent,
     bool sendMouseEvent, bool setPointerPosition)
 {
     RefPtrWillBeRawPtr<PointerEvent> pointerEvent = prpPointerEvent;
@@ skipping 156 matching lines @@
 {
 #if ENABLE(OILPAN)
     visitor->trace(m_nodeUnderPointer);
     visitor->trace(m_pointerCaptureTarget);
     visitor->trace(m_pendingPointerCaptureTarget);
 #endif
 }
 
 
 } // namespace blink