Fix the wrong non-element node handling in EventHanlder and MouseEventManager

third_party/WebKit/Source/core/input/MouseEventManager.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/MouseEventManager.h"
 
 #include "core/clipboard/DataObject.h"
 #include "core/clipboard/DataTransfer.h"
 #include "core/dom/Element.h"
 #include "core/dom/ElementTraversal.h"
@@ skipping 76 matching lines @@
   node_under_mouse_ = nullptr;
   mouse_press_node_ = nullptr;
   mouse_down_may_start_autoscroll_ = false;
   mouse_down_may_start_drag_ = false;
   captures_dragging_ = false;
   is_mouse_position_unknown_ = true;
   last_known_mouse_position_ = IntPoint();
   last_known_mouse_global_position_ = IntPoint();
   mouse_pressed_ = false;
   click_count_ = 0;
-  click_node_ = nullptr;
+  click_element_ = nullptr;
   mouse_down_pos_ = IntPoint();
   mouse_down_timestamp_ = TimeTicks();
   mouse_down_ = WebMouseEvent();
   svg_pan_ = false;
   drag_start_pos_ = LayoutPoint();
   fake_mouse_move_event_timer_.Stop();
   ResetDragState();
 }
 
 MouseEventManager::~MouseEventManager() = default;
 
 DEFINE_TRACE(MouseEventManager) {
   visitor->Trace(frame_);
   visitor->Trace(scroll_manager_);
   visitor->Trace(node_under_mouse_);
   visitor->Trace(mouse_press_node_);
-  visitor->Trace(click_node_);
+  visitor->Trace(click_element_);
   SynchronousMutationObserver::Trace(visitor);
 }
 
 MouseEventManager::MouseEventBoundaryEventDispatcher::
     MouseEventBoundaryEventDispatcher(MouseEventManager* mouse_event_manager,
                                       const WebMouseEvent* web_mouse_event,
                                       EventTarget* exited_target,
                                       const String& canvas_region_id)
     : mouse_event_manager_(mouse_event_manager),
       web_mouse_event_(web_mouse_event),
@@ skipping 101 matching lines @@
     target_node = FlatTreeTraversal::Parent(*target_node);
 
   SetNodeUnderMouse(target_node, canvas_region_id, web_mouse_event);
 
   return DispatchMouseEvent(node_under_mouse_, event_type, web_mouse_event,
                             canvas_region_id, nullptr);
 }
 
 WebInputEventResult MouseEventManager::DispatchMouseClickIfNeeded(
     const MouseEventWithHitTestResults& mev,
-    Node* release_node) {
+    Element& mouse_release_target) {
   // We only prevent click event when the click may cause contextmenu to popup.
   // However, we always send auxclick.
   bool context_menu_event =
       !RuntimeEnabledFeatures::auxclickEnabled() &&
       mev.Event().button == WebPointerProperties::Button::kRight;
 #if OS(MACOSX)
   // FIXME: The Mac port achieves the same behavior by checking whether the
   // context menu is currently open in WebPage::mouseEvent(). Consider merging
   // the implementations.
   if (mev.Event().button == WebPointerProperties::Button::kLeft &&
       mev.Event().GetModifiers() & WebInputEvent::Modifiers::kControlKey)
     context_menu_event = true;
 #endif
 
-  WebInputEventResult click_event_result = WebInputEventResult::kNotHandled;
   const bool should_dispatch_click_event =
-      click_count_ > 0 && !context_menu_event && release_node && click_node_ &&
-      release_node->CanParticipateInFlatTree() &&
-      click_node_->CanParticipateInFlatTree() &&
+      click_count_ > 0 && !context_menu_event && click_element_ &&
+      mouse_release_target.CanParticipateInFlatTree() &&
+      click_element_->CanParticipateInFlatTree() &&
       !(frame_->GetEventHandler()
             .GetSelectionController()
             .HasExtendedSelection() &&
         IsLinkSelection(mev));
-  if (should_dispatch_click_event) {
-    Node* click_target_node = nullptr;
-    if (click_node_ == release_node) {
-      click_target_node = click_node_;
-    } else if (click_node_->GetDocument() == release_node->GetDocument()) {
-      // Updates distribution because a 'mouseup' event listener can make the
-      // tree dirty at dispatchMouseEvent() invocation above.
-      // Unless distribution is updated, commonAncestor would hit ASSERT.
-      click_node_->UpdateDistribution();
-      release_node->UpdateDistribution();
-      click_target_node = release_node->CommonAncestor(
-          *click_node_, EventHandlingUtil::ParentForClickEvent);
-    }
-    if (click_target_node) {
-      click_event_result = DispatchMouseEvent(
-          click_target_node,
-          !RuntimeEnabledFeatures::auxclickEnabled() ||
-                  (mev.Event().button == WebPointerProperties::Button::kLeft)
-              ? EventTypeNames::click
-              : EventTypeNames::auxclick,
-          mev.Event(), mev.CanvasRegionId(), nullptr);
-    }
+  if (!should_dispatch_click_event)
+    return WebInputEventResult::kNotHandled;
+
+  Node* click_target_node = nullptr;
+  if (click_element_ == mouse_release_target) {
+    click_target_node = click_element_;
+  } else if (click_element_->GetDocument() ==
+             mouse_release_target.GetDocument()) {
+    // Updates distribution because a 'mouseup' event listener can make the
+    // tree dirty at dispatchMouseEvent() invocation above.
+    // Unless distribution is updated, commonAncestor would hit ASSERT.
+    click_element_->UpdateDistribution();
+    mouse_release_target.UpdateDistribution();
+    click_target_node = mouse_release_target.CommonAncestor(
+        *click_element_, EventHandlingUtil::ParentForClickEvent);
   }
-  return click_event_result;
+  if (!click_target_node)
+    return WebInputEventResult::kNotHandled;
+  return DispatchMouseEvent(
+      click_target_node,
+      !RuntimeEnabledFeatures::auxclickEnabled() ||
+              (mev.Event().button == WebPointerProperties::Button::kLeft)
+          ? EventTypeNames::click
+          : EventTypeNames::auxclick,
+      mev.Event(), mev.CanvasRegionId(), nullptr);
 }
 
 void MouseEventManager::FakeMouseMoveEventTimerFired(TimerBase* timer) {
   TRACE_EVENT0("input", "MouseEventManager::fakeMouseMoveEventTimerFired");
   DCHECK(timer == &fake_mouse_move_event_timer_);
   DCHECK(!mouse_pressed_);
 
   if (is_mouse_position_unknown_)
     return;
 
@@ skipping 80 matching lines @@
   if (last_node_under_mouse &&
       last_node_under_mouse->GetDocument() != frame_->GetDocument()) {
     last_node_under_mouse = nullptr;
   }
 
   SendBoundaryEvents(last_node_under_mouse, node_under_mouse_, canvas_region_id,
                      web_mouse_event);
 }
 
 void MouseEventManager::NodeChildrenWillBeRemoved(ContainerNode& container) {
-  if (container == click_node_)
+  if (container == click_element_)
     return;
-  if (!container.IsShadowIncludingInclusiveAncestorOf(click_node_.Get()))
+  if (!container.IsShadowIncludingInclusiveAncestorOf(click_element_.Get()))
     return;
-  click_node_ = nullptr;
+  click_element_ = nullptr;
 }
 
 void MouseEventManager::NodeWillBeRemoved(Node& node_to_be_removed) {
   if (node_to_be_removed.IsShadowIncludingInclusiveAncestorOf(
-          click_node_.Get())) {
+          click_element_.Get())) {
     // We don't dispatch click events if the mousedown node is removed
     // before a mouseup event. It is compatible with IE and Firefox.
-    click_node_ = nullptr;
+    click_element_ = nullptr;
   }
 }
 
 Node* MouseEventManager::GetNodeUnderMouse() {
   return node_under_mouse_;
 }
 
 WebInputEventResult MouseEventManager::HandleMouseFocus(
     const HitTestResult& hit_test_result,
     InputDeviceCapabilities* source_capabilities) {
@@ skipping 591 matching lines @@
   if (!svg_pan_)
     return false;
   svg_pan_ = !is_release_event;
   frame_->GetDocument()->AccessSVGExtensions().UpdatePan(
       frame_->View()->RootFrameToContents(last_known_mouse_position_));
   return true;
 }
 
 void MouseEventManager::InvalidateClick() {
   click_count_ = 0;
-  click_node_ = nullptr;
+  click_element_ = nullptr;
 }
 
 bool MouseEventManager::MousePressed() {
   return mouse_pressed_;
 }
 
 void MouseEventManager::SetMousePressed(bool mouse_pressed) {
   mouse_pressed_ = mouse_pressed;
 }
 
 bool MouseEventManager::CapturesDragging() const {
   return captures_dragging_;
 }
 
 void MouseEventManager::SetCapturesDragging(bool captures_dragging) {
   captures_dragging_ = captures_dragging;
 }
 
 Node* MouseEventManager::MousePressNode() {
   return mouse_press_node_;
 }
 
 void MouseEventManager::SetMousePressNode(Node* node) {
   mouse_press_node_ = node;
 }
 
-void MouseEventManager::SetClickNode(Node* node) {
-  SetContext(node ? node->ownerDocument() : nullptr);
-  click_node_ = node;
+void MouseEventManager::SetClickElement(Element* element) {
+  SetContext(element ? element->ownerDocument() : nullptr);
+  click_element_ = element;
 }
 
 void MouseEventManager::SetClickCount(int click_count) {
   click_count_ = click_count;
 }
 
 bool MouseEventManager::MouseDownMayStartDrag() {
   return mouse_down_may_start_drag_;
 }
 
 }  // namespace blink