Gather UMA for click retarget due to DOM changes

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 12 matching lines @@
 #include "core/input/InputDeviceCapabilities.h"
 #include "core/input/KeyboardEventManager.h"
 #include "core/layout/HitTestResult.h"
 #include "core/layout/api/LayoutViewItem.h"
 #include "core/page/AutoscrollController.h"
 #include "core/page/DragController.h"
 #include "core/page/DragState.h"
 #include "core/page/FocusController.h"
 #include "core/paint/PaintLayer.h"
 #include "core/svg/SVGDocumentExtensions.h"
+#include "platform/Histogram.h"
 #include "platform/geometry/FloatQuad.h"
 
 namespace blink {
 
 namespace {
 
 String CanvasRegionId(Node* node, const WebMouseEvent& mouse_event) {
   if (!node->IsElementNode())
     return String();
 
@@ skipping 45 matching lines @@
   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_element_ = nullptr;
+  mouse_down_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_element_);
+  visitor->Trace(mouse_down_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 117 matching lines @@
 #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
 
   const bool should_dispatch_click_event =
-      click_count_ > 0 && !context_menu_event && click_element_ &&
+      click_count_ > 0 && !context_menu_event && mouse_down_element_ &&
       mouse_release_target.CanParticipateInFlatTree() &&
-      click_element_->CanParticipateInFlatTree() &&
+      mouse_down_element_->CanParticipateInFlatTree() &&
+      mouse_down_element_->isConnected() &&
       !(frame_->GetEventHandler()
             .GetSelectionController()
             .HasExtendedSelection() &&
         IsLinkSelection(mev));
   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() ==
+  if (mouse_down_element_ == mouse_release_target) {
+    click_target_node = mouse_down_element_;
+  } else if (mouse_down_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_down_element_->UpdateDistribution();
     mouse_release_target.UpdateDistribution();
     click_target_node = mouse_release_target.CommonAncestor(
-        *click_element_, EventHandlingUtil::ParentForClickEvent);
+        *mouse_down_element_, EventHandlingUtil::ParentForClickEvent);
   }
   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);
+
+  DEFINE_STATIC_LOCAL(BooleanHistogram, histogram,
+                      ("Event.ClickNotFiredDueToDomManipulation"));
+
+  if (click_element_ && click_element_->CanParticipateInFlatTree() &&
+      click_element_->isConnected()) {
+    DCHECK(click_element_ == mouse_down_element_);
+    histogram.Count(false);
+  } else {
+    histogram.Count(true);
+  }
+
+  if ((click_element_ && click_element_->CanParticipateInFlatTree() &&
+       click_element_->isConnected()) ||
+      RuntimeEnabledFeatures::clickRetargettingEnabled()) {
+    return DispatchMouseEvent(
+        click_target_node,
+        !RuntimeEnabledFeatures::auxclickEnabled() ||
+                (mev.Event().button == WebPointerProperties::Button::kLeft)
+            ? EventTypeNames::click
+            : EventTypeNames::auxclick,
+        mev.Event(), mev.CanvasRegionId(), nullptr);
+  }
+
+  return WebInputEventResult::kNotHandled;
 }
 
 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 85 matching lines @@
   SendBoundaryEvents(last_node_under_mouse, node_under_mouse_, canvas_region_id,
                      web_mouse_event);
 }
 
 void MouseEventManager::NodeChildrenWillBeRemoved(ContainerNode& container) {
   if (container == click_element_)
     return;
   if (!container.IsShadowIncludingInclusiveAncestorOf(click_element_.Get()))
     return;
   click_element_ = nullptr;
+
+  // TODO(crbug.com/716694): Do not reset mouse_down_element_ for the purpose of
+  // gathering data.
 }
 
 void MouseEventManager::NodeWillBeRemoved(Node& node_to_be_removed) {
   if (node_to_be_removed.IsShadowIncludingInclusiveAncestorOf(
           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_element_ = nullptr;
+
+    // TODO(crbug.com/716694): Do not reset mouse_down_element_ for the purpose
+    // of gathering data.
   }
 }
 
 Node* MouseEventManager::GetNodeUnderMouse() {
   return node_under_mouse_;
 }
 
 WebInputEventResult MouseEventManager::HandleMouseFocus(
     const HitTestResult& hit_test_result,
     InputDeviceCapabilities* source_capabilities) {
@@ skipping 585 matching lines @@
     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_element_ = nullptr;
+  mouse_down_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::SetClickElement(Element* element) {
   SetContext(element ? element->ownerDocument() : nullptr);
   click_element_ = element;
+  mouse_down_element_ = element;
 }
 
 void MouseEventManager::SetClickCount(int click_count) {
   click_count_ = click_count;
 }
 
 bool MouseEventManager::MouseDownMayStartDrag() {
   return mouse_down_may_start_drag_;
 }
 
 }  // namespace blink