Suppressed MEs for gestures from cancelled PEs

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/ElementTraversal.h"
 #include "core/dom/shadow/FlatTreeTraversal.h"
 #include "core/events/MouseEvent.h"
 #include "core/frame/FrameView.h"
@@ skipping 437 matching lines @@
             }
         } else {
             // Set the target of pointer event to the captured node as this
             // pointer is captured otherwise it would have gone to the if block
             // and perform a hit-test.
             touchInfo.touchNode = m_pendingPointerCaptureTarget
                 .get(pointerId)->toNode();
             touchInfo.targetFrame = touchInfo.touchNode->document().frame();
         }
 
-        WebInputEventResult result = WebInputEventResult::NotHandled;
-
         // Do not send pointer events for stationary touches or null targetFrame
         if (touchInfo.touchNode && touchInfo.targetFrame
             && touchPoint.state() != PlatformTouchPoint::TouchStationary
             && !m_inCanceledStateForPointerTypeTouch) {
             FloatPoint pagePoint = touchInfo.targetFrame->view()
                 ->rootFrameToContents(touchInfo.point.pos());
             float scaleFactor = 1.0f / touchInfo.targetFrame->pageZoomFactor();
             FloatPoint scrollPosition = touchInfo.targetFrame->view()->scrollPosition();
             FloatPoint framePoint = pagePoint.scaledBy(scaleFactor);
             framePoint.moveBy(scrollPosition.scaledBy(-scaleFactor));
             PointerEvent* pointerEvent = m_pointerEventFactory.create(
                 pointerEventNameForTouchPointState(touchPoint.state()),
                 touchPoint, event.getModifiers(),
                 touchPoint.radius().scaledBy(scaleFactor),
                 framePoint,
                 touchInfo.touchNode ?
                     touchInfo.touchNode->document().domWindow() : nullptr);
 
-            result = sendTouchPointerEvent(touchInfo.touchNode, pointerEvent);
+            WebInputEventResult result = sendTouchPointerEvent(touchInfo.touchNode, pointerEvent);
+
+            // If a pointerdown has been canceled, queue the unique id to allow
+            // suppressing mouse events from gesture events. For mouse events
+            // fired from GestureTap & GestureLongPress (which are triggered by
+            // single touches only), it is enough to queue the ids only for
+            // primary pointers.
+            // TODO(mustaq): What about other cases (e.g. GestureTwoFingerTap)?
+            if (result != WebInputEventResult::NotHandled
+                && pointerEvent->type() == EventTypeNames::pointerdown
+                && pointerEvent->isPrimary()) {
+                m_touchIdsForCanceledPointerdowns.append(event.uniqueTouchEventId());
+            }
         }
-        // TODO(crbug.com/507408): Right now we add the touch point only if
-        // its pointer event is NotHandled (e.g. preventDefault is called in
-        // the pointer event listener). This behavior needs to change as it
-        // may create some inconsistent touch event sequence.
-        if (result == WebInputEventResult::NotHandled) {
-            touchInfos.append(touchInfo);
-        }
+
+        touchInfos.append(touchInfo);
     }
 }
 
 WebInputEventResult PointerEventManager::sendTouchPointerEvent(
     EventTarget* target, PointerEvent* pointerEvent)
 {
     if (m_inCanceledStateForPointerTypeTouch)
         return WebInputEventResult::NotHandled;
 
     processCaptureAndPositionOfPointerEvent(pointerEvent, target);
@@ skipping 95 matching lines @@
 {
 }
 
 void PointerEventManager::clear()
 {
     for (auto& entry : m_preventMouseEventForPointerType)
         entry = false;
     m_touchEventManager.clear();
     m_inCanceledStateForPointerTypeTouch = false;
     m_pointerEventFactory.clear();
+    m_touchIdsForCanceledPointerdowns.clear();
     m_nodeUnderPointer.clear();
     m_pointerCaptureTarget.clear();
     m_pendingPointerCaptureTarget.clear();
 }
 
 void PointerEventManager::processCaptureAndPositionOfPointerEvent(
     PointerEvent* pointerEvent,
     EventTarget* hitTestTarget,
     EventTarget* lastNodeUnderMouse,
     const PlatformMouseEvent& mouseEvent,
@@ skipping 155 matching lines @@
 bool PointerEventManager::isActive(const int pointerId) const
 {
     return m_pointerEventFactory.isActive(pointerId);
 }
 
 bool PointerEventManager::isAnyTouchActive() const
 {
     return m_touchEventManager.isAnyTouchActive();
 }
 
+bool PointerEventManager::primaryPointerdownCanceled(uint32_t uniqueTouchEventId)
+{
+    // It's safe to assume that uniqueTouchEventIds won't wrap back to 0 from
+    // 2^32-1 (>4.2 billion): even with a generous 100 unique ids per touch
+    // sequence & one sequence per 10 second, it takes 13+ years to wrap back.
+    while (!m_touchIdsForCanceledPointerdowns.isEmpty()) {
+        uint32_t firstId = m_touchIdsForCanceledPointerdowns.first();
+        if (firstId > uniqueTouchEventId)
+            return false;
+        m_touchIdsForCanceledPointerdowns.takeFirst();
+        if (firstId == uniqueTouchEventId)
+            return true;
+    }
+    return false;
+}
+
 DEFINE_TRACE(PointerEventManager)
 {
     visitor->trace(m_frame);
     visitor->trace(m_nodeUnderPointer);
     visitor->trace(m_pointerCaptureTarget);
     visitor->trace(m_pendingPointerCaptureTarget);
     visitor->trace(m_touchEventManager);
 }
 
 
 } // namespace blink