Fixed & refactored mouse event firing at gesture context menu

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 854 matching lines @@
     // m_selectionInitiationState is initialized after dispatching mousedown
     // event in order not to keep the selection by DOM APIs because we can't
     // give the user the chance to handle the selection by user action like
     // dragging if we keep the selection in case of mousedown. FireFox also has
     // the same behavior and it's more compatible with other browsers.
     selectionController().initializeSelectionState();
     HitTestResult hitTestResult = hitTestResultInFrame(m_frame, documentPoint, HitTestRequest::ReadOnly);
     InputDeviceCapabilities* sourceCapabilities = mouseEvent.getSyntheticEventType() == PlatformMouseEvent::FromTouch ? InputDeviceCapabilities::firesTouchEventsSourceCapabilities() :
         InputDeviceCapabilities::doesntFireTouchEventsSourceCapabilities();
     if (eventResult == WebInputEventResult::NotHandled)
-        eventResult = handleMouseFocus(MouseEventWithHitTestResults(mev.event(), hitTestResult), sourceCapabilities);
+        eventResult = handleMouseFocus(hitTestResult, sourceCapabilities);
     m_capturesDragging = eventResult == WebInputEventResult::NotHandled || mev.scrollbar();
 
     // If the hit testing originally determined the event was in a scrollbar, refetch the MouseEventWithHitTestResults
     // in case the scrollbar widget was destroyed when the mouse event was handled.
     if (mev.scrollbar()) {
         const bool wasLastScrollBar = mev.scrollbar() == m_lastScrollbarUnderMouse.get();
         HitTestRequest request(HitTestRequest::ReadOnly | HitTestRequest::Active);
         mev = m_frame->document()->prepareMouseEvent(request, documentPoint, mouseEvent);
         if (wasLastScrollBar && mev.scrollbar() != m_lastScrollbarUnderMouse.get())
             m_lastScrollbarUnderMouse = nullptr;
@@ skipping 625 matching lines @@
 
 // TODO(mustaq): Make PE drive ME dispatch & bookkeeping in EventHandler.
 WebInputEventResult EventHandler::updatePointerTargetAndDispatchEvents(const AtomicString& mouseEventType, Node* targetNode, int clickCount, const PlatformMouseEvent& mouseEvent)
 {
     ASSERT(mouseEventType == EventTypeNames::mousedown
         || mouseEventType == EventTypeNames::mousemove
         || mouseEventType == EventTypeNames::mouseup);
 
     Node* lastNodeUnderMouse = updateMouseEventTargetNode(targetNode, mouseEvent);
 
-    if (mouseEvent.getSyntheticEventType() == PlatformMouseEvent::FromTouch)

[bokan, 2016/08/26 16:55:14]

Help me understand, why was this removed?

[mustaq, 2016/08/26 17:19:03]

This was added as a quick fix to prevent PE-firing after gesture events, see [A]
in crrev.com/2141993003 description. The main problem was that gesture code went
through the whole "raw" mouse handling code
(EventHandler::handleMousePressEvent(PlatformMouseEvent), which includes, among
other things, firing PointerEvents. The fix here replaces the call to
handleMousePressEvent(PlatformMouseEvent) with the tasks we really need, and PEs
are not one of them. We didn't include this fix in that CL because we wanted to
push a fix in quickly w/o risking breakages.

[bokan, 2016/08/26 17:31:53]

So is this now ok because gesture events don't come down this path?

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

Right: from the overall event handling perspective, this code has been taken by
the TE that has triggered the GE, so the GE handler shouldn't go though this
again.

-        return dispatchMouseEvent(mouseEventType, m_nodeUnderMouse, clickCount, mouseEvent);
-
     Node* newNodeUnderMouse = nullptr;
     const auto& eventResult = m_pointerEventManager.sendMousePointerEvent(
         m_nodeUnderMouse, mouseEventType, clickCount, mouseEvent,
         lastNodeUnderMouse, &newNodeUnderMouse);
     m_nodeUnderMouse = newNodeUnderMouse;
     return eventResult;
 }
 
 void EventHandler::setClickNode(Node* node)
 {
     m_clickNode = node;
 }
 
-WebInputEventResult EventHandler::handleMouseFocus(const MouseEventWithHitTestResults& targetedEvent, InputDeviceCapabilities* sourceCapabilities)
+WebInputEventResult EventHandler::handleMouseFocus(const HitTestResult& hitTestResult, InputDeviceCapabilities* sourceCapabilities)
 {
     // If clicking on a frame scrollbar, do not mess up with content focus.
-    if (targetedEvent.hitTestResult().scrollbar() && !m_frame->contentLayoutItem().isNull()) {
-        if (targetedEvent.hitTestResult().scrollbar()->getScrollableArea() == m_frame->contentLayoutItem().getScrollableArea())
+    if (hitTestResult.scrollbar() && !m_frame->contentLayoutItem().isNull()) {
+        if (hitTestResult.scrollbar()->getScrollableArea() == m_frame->contentLayoutItem().getScrollableArea())
             return WebInputEventResult::NotHandled;
     }
 
     // The layout needs to be up to date to determine if an element is focusable.
     m_frame->document()->updateStyleAndLayoutIgnorePendingStylesheets();
 
     Element* element = nullptr;
     if (m_nodeUnderMouse)
         element = m_nodeUnderMouse->isElementNode() ? toElement(m_nodeUnderMouse) : m_nodeUnderMouse->parentOrShadowHostElement();
     for (; element; element = element->parentOrShadowHostElement()) {
@@ skipping 13 matching lines @@
         // TODO(yosin) We should not create |Range| object for calling
         // |isNodeFullyContained()|.
         if (createRange(m_frame->selection().selection().toNormalizedEphemeralRange())->isNodeFullyContained(*element)
             && element->isDescendantOf(m_frame->document()->focusedElement()))
             return WebInputEventResult::NotHandled;
     }
 
 
     // Only change the focus when clicking scrollbars if it can transfered to a
     // mouse focusable node.
-    if (!element && targetedEvent.hitTestResult().scrollbar())
+    if (!element && hitTestResult.scrollbar())
         return WebInputEventResult::HandledSystem;
 
     if (Page* page = m_frame->page()) {
         // If focus shift is blocked, we eat the event. Note we should never
         // clear swallowEvent if the page already set it (e.g., by canceling
         // default behavior).
         if (element) {
             if (slideFocusOnShadowHostIfNecessary(*element))
                 return WebInputEventResult::HandledSystem;
             if (!page->focusController().setFocusedElement(element, m_frame, FocusParams(SelectionBehaviorOnFocus::None, WebFocusTypeMouse, sourceCapabilities)))
@@ skipping 516 matching lines @@
     result.setInnerNode(targetNode);
     doc->updateHoverActiveState(request, result.innerElement());
 
     // The contextmenu event is a mouse event even when invoked using the keyboard.
     // This is required for web compatibility.
     PlatformEvent::EventType eventType = PlatformEvent::MousePressed;
     if (m_frame->settings() && m_frame->settings()->showContextMenuOnMouseUp())
         eventType = PlatformEvent::MouseReleased;
 
     PlatformMouseEvent mouseEvent(locationInRootFrame, globalPosition,
-        WebPointerProperties::Button::Right, eventType, 1,
+        WebPointerProperties::Button::NoButton, eventType, /* clickCount */ 0,
         PlatformEvent::NoModifiers, PlatformMouseEvent::RealOrIndistinguishable,
         WTF::monotonicallyIncreasingTime(), WebPointerProperties::PointerType::Mouse);
 
     return sendContextMenuEvent(mouseEvent, overrideTargetElement);
 }
 
 void EventHandler::scheduleHoverStateUpdate()
 {
     if (!m_hoverTimer.isActive())
         m_hoverTimer.startOneShot(0, BLINK_FROM_HERE);
@@ skipping 477 matching lines @@
 
 FrameHost* EventHandler::frameHost() const
 {
     if (!m_frame->page())
         return nullptr;
 
     return &m_frame->page()->frameHost();
 }
 
 } // namespace blink