Suppressed MEs for gestures from cancelled PEs

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 243 matching lines @@
     , m_shouldOnlyFireDragOverEvent(false)
     , m_mousePositionIsUnknown(true)
     , m_mouseDownTimestamp(0)
     , m_pointerEventManager(frame)
     , m_scrollGestureHandlingNode(nullptr)
     , m_lastGestureScrollOverWidget(false)
     , m_longTapShouldInvokeContextMenu(false)
     , m_activeIntervalTimer(this, &EventHandler::activeIntervalTimerFired)
     , m_lastShowPressTimestamp(0)
     , m_deltaConsumedForScrollSequence(false)
+    , m_suppressMouseEventsFromGestures(false)
 {
 }
 
 EventHandler::~EventHandler()
 {
     ASSERT(!m_fakeMouseMoveEventTimer.isActive());
 }
 
 DEFINE_TRACE(EventHandler)
 {
@@ skipping 53 matching lines @@
     m_lastDeferredTapElement = nullptr;
     m_eventHandlerWillResetCapturingMouseEventsNode = false;
     m_mouseDownMayStartAutoscroll = false;
     m_svgPan = false;
     m_mouseDownPos = IntPoint();
     m_mouseDownTimestamp = 0;
     m_longTapShouldInvokeContextMenu = false;
     m_dragStartPos = LayoutPoint();
     m_offsetFromResizeCorner = LayoutSize();
     m_mouseDown = PlatformMouseEvent();
+    m_suppressMouseEventsFromGestures = false;
 }
 
 WebInputEventResult EventHandler::mergeEventResult(
     WebInputEventResult resultA, WebInputEventResult resultB)
 {
     // The ordering of the enumeration is specific. There are times that
     // multiple events fire and we need to combine them into a single
     // result code. The enumeration is based on the level of consumption that
     // is most significant. The enumeration is ordered with smaller specified
     // numbers first. Examples of merged results are:
@@ skipping 1709 matching lines @@
         if (gestureDomEvent) {
             DispatchEventResult gestureDomEventResult = eventTarget->dispatchEvent(gestureDomEvent);
             if (gestureDomEventResult != DispatchEventResult::NotCanceled) {
                 ASSERT(gestureDomEventResult != DispatchEventResult::CanceledByEventHandler);
                 return toWebInputEventResult(gestureDomEventResult);
             }
         }
     }
 
     switch (gestureEvent.type()) {
+    case PlatformEvent::GestureTapDown:
+        return handleGestureTapDown(targetedEvent);
     case PlatformEvent::GestureTap:
         return handleGestureTap(targetedEvent);
     case PlatformEvent::GestureShowPress:
         return handleGestureShowPress();
     case PlatformEvent::GestureLongPress:
         return handleGestureLongPress(targetedEvent);
     case PlatformEvent::GestureLongTap:
         return handleGestureLongTap(targetedEvent);
     case PlatformEvent::GestureTwoFingerTap:
         return sendContextMenuEventForGesture(targetedEvent);
-    case PlatformEvent::GestureTapDown:
     case PlatformEvent::GesturePinchBegin:
     case PlatformEvent::GesturePinchEnd:
     case PlatformEvent::GesturePinchUpdate:
     case PlatformEvent::GestureTapDownCancel:
     case PlatformEvent::GestureTapUnconfirmed:
         break;
     default:
         ASSERT_NOT_REACHED();
     }
 
@@ skipping 67 matching lines @@
     case PlatformEvent::GesturePinchBegin:
     case PlatformEvent::GesturePinchEnd:
     case PlatformEvent::GesturePinchUpdate:
         return WebInputEventResult::NotHandled;
     default:
         ASSERT_NOT_REACHED();
         return WebInputEventResult::NotHandled;
     }
 }
 
+WebInputEventResult EventHandler::handleGestureTapDown(const GestureEventWithHitTestResults& targetedEvent)
+{
+    m_suppressMouseEventsFromGestures =

[dtapuska, 2016/05/27 20:54:07]

I see there is an ASSERT in debug mode for the Deque having enough elements. But
what happens in release? Is it ever a scenario when we might not have things in
the deque?

+        m_pointerEventManager.firstPrimaryPointerdownResult() != WebInputEventResult::NotHandled;
+    return WebInputEventResult::NotHandled;
+}
+
 WebInputEventResult EventHandler::handleGestureTap(const GestureEventWithHitTestResults& targetedEvent)
 {
     FrameView* frameView(m_frame->view());
     const PlatformGestureEvent& gestureEvent = targetedEvent.event();
     HitTestRequest::HitTestRequestType hitType = getHitTypeForGestureType(gestureEvent.type());
     uint64_t preDispatchDomTreeVersion = m_frame->document()->domTreeVersion();
     uint64_t preDispatchStyleVersion = m_frame->document()->styleVersion();
 
     UserGestureIndicator gestureIndicator(DefinitelyProcessingUserGesture);
 
     HitTestResult currentHitTest = targetedEvent.hitTestResult();
 
     // We use the adjusted position so the application isn't surprised to see a event with
     // co-ordinates outside the target's bounds.
     IntPoint adjustedPoint = frameView->rootFrameToContents(gestureEvent.position());
+    const unsigned modifiers = gestureEvent.getModifiers();
 
-    unsigned modifiers = gestureEvent.getModifiers();
-    PlatformMouseEvent fakeMouseMove(gestureEvent.position(), gestureEvent.globalPosition(),
-        NoButton, PlatformEvent::MouseMoved, /* clickCount */ 0,
-        static_cast<PlatformEvent::Modifiers>(modifiers),
-        PlatformMouseEvent::FromTouch, gestureEvent.timestamp(), WebPointerProperties::PointerType::Mouse);
-    dispatchMouseEvent(EventTypeNames::mousemove, currentHitTest.innerNode(), 0, fakeMouseMove);
+    if (!m_suppressMouseEventsFromGestures) {
+        PlatformMouseEvent fakeMouseMove(gestureEvent.position(), gestureEvent.globalPosition(),
+            NoButton, PlatformEvent::MouseMoved, /* clickCount */ 0,
+            static_cast<PlatformEvent::Modifiers>(modifiers),
+            PlatformMouseEvent::FromTouch, gestureEvent.timestamp(), WebPointerProperties::PointerType::Mouse);
+        dispatchMouseEvent(EventTypeNames::mousemove, currentHitTest.innerNode(), 0, fakeMouseMove);
+    }
 
     // Do a new hit-test in case the mousemove event changed the DOM.
     // Note that if the original hit test wasn't over an element (eg. was over a scrollbar) we
     // don't want to re-hit-test because it may be in the wrong frame (and there's no way the page
     // could have seen the event anyway).
     // Also note that the position of the frame may have changed, so we need to recompute the content
     // co-ordinates (updating layout/style as hitTestResultAtPoint normally would).
     // FIXME: Use a hit-test cache to avoid unnecessary hit tests. http://crbug.com/398920
     if (currentHitTest.innerNode()) {
         LocalFrame* mainFrame = m_frame->localFrameRoot();
         if (mainFrame && mainFrame->view())
             mainFrame->view()->updateLifecycleToCompositingCleanPlusScrolling();
         adjustedPoint = frameView->rootFrameToContents(gestureEvent.position());
         currentHitTest = hitTestResultInFrame(m_frame, adjustedPoint, hitType);
     }
     m_clickNode = currentHitTest.innerNode();
 
     // Capture data for showUnhandledTapUIIfNeeded.
     Node* tappedNode = m_clickNode;
     IntPoint tappedPosition = gestureEvent.position();
 
     if (m_clickNode && m_clickNode->isTextNode())
         m_clickNode = FlatTreeTraversal::parent(*m_clickNode);
 
-    PlatformMouseEvent fakeMouseDown(gestureEvent.position(), gestureEvent.globalPosition(),
-        LeftButton, PlatformEvent::MousePressed, gestureEvent.tapCount(),
-        static_cast<PlatformEvent::Modifiers>(modifiers | PlatformEvent::LeftButtonDown),
-        PlatformMouseEvent::FromTouch,  gestureEvent.timestamp(), WebPointerProperties::PointerType::Mouse);
-    WebInputEventResult mouseDownEventResult = dispatchMouseEvent(EventTypeNames::mousedown, currentHitTest.innerNode(), gestureEvent.tapCount(), fakeMouseDown);
-    selectionController().initializeSelectionState();
-    if (mouseDownEventResult == WebInputEventResult::NotHandled)
-        mouseDownEventResult = handleMouseFocus(MouseEventWithHitTestResults(fakeMouseDown, currentHitTest), InputDeviceCapabilities::firesTouchEventsSourceCapabilities());
-    if (mouseDownEventResult == WebInputEventResult::NotHandled)
-        mouseDownEventResult = handleMousePressEvent(MouseEventWithHitTestResults(fakeMouseDown, currentHitTest));
+    WebInputEventResult mouseDownEventResult = WebInputEventResult::NotHandled;
+    if (!m_suppressMouseEventsFromGestures) {
+        PlatformMouseEvent fakeMouseDown(gestureEvent.position(), gestureEvent.globalPosition(),
+            LeftButton, PlatformEvent::MousePressed, gestureEvent.tapCount(),
+            static_cast<PlatformEvent::Modifiers>(modifiers | PlatformEvent::LeftButtonDown),
+            PlatformMouseEvent::FromTouch, gestureEvent.timestamp(), WebPointerProperties::PointerType::Mouse);
+        mouseDownEventResult = dispatchMouseEvent(EventTypeNames::mousedown, currentHitTest.innerNode(), gestureEvent.tapCount(), fakeMouseDown);
+        selectionController().initializeSelectionState();
+        if (mouseDownEventResult == WebInputEventResult::NotHandled)
+            mouseDownEventResult = handleMouseFocus(MouseEventWithHitTestResults(fakeMouseDown, currentHitTest), InputDeviceCapabilities::firesTouchEventsSourceCapabilities());
+        if (mouseDownEventResult == WebInputEventResult::NotHandled)
+            mouseDownEventResult = handleMousePressEvent(MouseEventWithHitTestResults(fakeMouseDown, currentHitTest));

[Rick Byers, 2016/05/27 20:39:27]

In addition to suppressing the generation of mouse events, I believe this change
also suppresses some/all of the default behavior associated with a tap (eg.
focusing an input field).  I'm pretty sure this is what you want (since
cancelling the pointerdown for a mouse would do the same), but there may be some
subtle cases here.  Anyway maybe just expand the CL description to describe this
broader impact, ideally also add at least a little test coverage (we really
should have interop tests for that sort of thing).

[mustaq, 2016/06/02 19:26:26]

A milder approach seems to make more sense to me now: minimize the effect of
canceled pointerdown on GEs. In this particular case focusing was originally
triggered by gestureTap, and we are not suppressing gestureTaps, so let's keep
the behavior unchanged. Wdyt?

[Rick Byers, 2016/06/03 15:31:39]

I think it's important that cancelling pointerdown prevents all behavior that
cancelling the associated mousedown originally would have in the GestureTap
scenario (otherwise switching from handling MEs to PEs may break some
scenarios).  So yes, keeping the behavior unchanged makes sense.

+    }
 
     if (currentHitTest.innerNode()) {
         ASSERT(gestureEvent.type() == PlatformEvent::GestureTap);
         HitTestResult result = currentHitTest;
         result.setToShadowHostIfInUserAgentShadowRoot();
         m_frame->chromeClient().onMouseDown(result.innerNode());
     }
 
     // FIXME: Use a hit-test cache to avoid unnecessary hit tests. http://crbug.com/398920
     if (currentHitTest.innerNode()) {
         LocalFrame* mainFrame = m_frame->localFrameRoot();
         if (mainFrame && mainFrame->view())
             mainFrame->view()->updateAllLifecyclePhases();
         adjustedPoint = frameView->rootFrameToContents(gestureEvent.position());
         currentHitTest = hitTestResultInFrame(m_frame, adjustedPoint, hitType);
     }
+
+    WebInputEventResult mouseUpEventResult = WebInputEventResult::NotHandled;
     PlatformMouseEvent fakeMouseUp(gestureEvent.position(), gestureEvent.globalPosition(),
         LeftButton, PlatformEvent::MouseReleased, gestureEvent.tapCount(),
         static_cast<PlatformEvent::Modifiers>(modifiers),
-        PlatformMouseEvent::FromTouch,  gestureEvent.timestamp(), WebPointerProperties::PointerType::Mouse);
-    WebInputEventResult mouseUpEventResult = dispatchMouseEvent(EventTypeNames::mouseup, currentHitTest.innerNode(), gestureEvent.tapCount(), fakeMouseUp);
+        PlatformMouseEvent::FromTouch, gestureEvent.timestamp(), WebPointerProperties::PointerType::Mouse);
+    if (!m_suppressMouseEventsFromGestures) {
+        mouseUpEventResult = dispatchMouseEvent(EventTypeNames::mouseup, currentHitTest.innerNode(), gestureEvent.tapCount(), fakeMouseUp);
+    }
 
     WebInputEventResult clickEventResult = WebInputEventResult::NotHandled;
     if (m_clickNode) {
         if (currentHitTest.innerNode()) {
             // Updates distribution because a mouseup (or mousedown) event listener can make the
             // tree dirty at dispatchMouseEvent() invocation above.
             // Unless distribution is updated, commonAncestor would hit ASSERT.
             // Both m_clickNode and currentHitTest.innerNode()) don't need to be updated
             // because commonAncestor() will exit early if their documents are different.
             m_clickNode->updateDistribution();
             Node* clickTargetNode = currentHitTest.innerNode()->commonAncestor(*m_clickNode, parentForClickEvent);
             clickEventResult = dispatchMouseEvent(EventTypeNames::click, clickTargetNode, gestureEvent.tapCount(), fakeMouseUp);
         }
         m_clickNode = nullptr;
     }
 
-    if (mouseUpEventResult == WebInputEventResult::NotHandled)
+    if (!m_suppressMouseEventsFromGestures && mouseUpEventResult == WebInputEventResult::NotHandled)
         mouseUpEventResult = handleMouseReleaseEvent(MouseEventWithHitTestResults(fakeMouseUp, currentHitTest));
 
     WebInputEventResult eventResult = mergeEventResult(mergeEventResult(mouseDownEventResult, mouseUpEventResult), clickEventResult);
     if (eventResult == WebInputEventResult::NotHandled && tappedNode && m_frame->page()) {
         bool domTreeChanged = preDispatchDomTreeVersion != m_frame->document()->domTreeVersion();
         bool styleChanged = preDispatchStyleVersion != m_frame->document()->styleVersion();
 
         IntPoint tappedPositionInViewport = frameHost()->visualViewport().rootFrameToViewport(tappedPosition);
         m_frame->chromeClient().showUnhandledTapUIIfNeeded(tappedPositionInViewport, tappedNode, domTreeChanged || styleChanged);
     }
     return eventResult;
 }
 
 WebInputEventResult EventHandler::handleGestureLongPress(const GestureEventWithHitTestResults& targetedEvent)
 {
     const PlatformGestureEvent& gestureEvent = targetedEvent.event();
     IntPoint adjustedPoint = gestureEvent.position();
 
     unsigned modifiers = gestureEvent.getModifiers();
 
     // FIXME: Ideally we should try to remove the extra mouse-specific hit-tests here (re-using the
     // supplied HitTestResult), but that will require some overhaul of the touch drag-and-drop code
     // and LongPress is such a special scenario that it's unlikely to matter much in practice.
 
     m_longTapShouldInvokeContextMenu = false;
     if (m_frame->settings() && m_frame->settings()->touchDragDropEnabled() && m_frame->view()) {
+        // TODO(mustaq): Suppressing long-tap MouseEvents could break
+        // drag-drop. Will do separately because of the risk. crbug.com/606938.
         PlatformMouseEvent mouseDownEvent(adjustedPoint, gestureEvent.globalPosition(), LeftButton, PlatformEvent::MousePressed, 1,
             static_cast<PlatformEvent::Modifiers>(modifiers | PlatformEvent::LeftButtonDown),
             PlatformMouseEvent::FromTouch, WTF::monotonicallyIncreasingTime(), WebPointerProperties::PointerType::Mouse);
         m_mouseDown = mouseDownEvent;
 
         PlatformMouseEvent mouseDragEvent(adjustedPoint, gestureEvent.globalPosition(), LeftButton, PlatformEvent::MouseMoved, 1,
             static_cast<PlatformEvent::Modifiers>(modifiers | PlatformEvent::LeftButtonDown),
             PlatformMouseEvent::FromTouch, WTF::monotonicallyIncreasingTime(), WebPointerProperties::PointerType::Mouse);
         HitTestRequest request(HitTestRequest::ReadOnly);
         MouseEventWithHitTestResults mev = prepareMouseEvent(request, mouseDragEvent);
@@ skipping 1337 matching lines @@
         if (!rect.contains(roundedIntPoint(point)))
             return result;
     }
     frame->contentLayoutItem().hitTest(result);
     return result;
 }
 
 WebInputEventResult EventHandler::handleTouchEvent(const PlatformTouchEvent& event)
 {
     TRACE_EVENT0("blink", "EventHandler::handleTouchEvent");
-
     return m_pointerEventManager.handleTouchEvents(event);
 }
 
 void EventHandler::userGestureUtilized()
 {
     // This is invoked for UserGestureIndicators created in TouchEventManger::handleTouchEvent which perhaps
     // represent touch actions which shouldn't be considered a user-gesture.
     UseCounter::count(m_frame, UseCounter::TouchDragUserGestureUsed);
 }
 
@@ skipping 55 matching lines @@
 
 FrameHost* EventHandler::frameHost() const
 {
     if (!m_frame->page())
         return nullptr;
 
     return &m_frame->page()->frameHost();
 }
 
 } // namespace blink