1 files changed, 109 insertions, 109 deletions

diff --git a/chromium/third_party/blink/renderer/core/input/pointer_event_manager.cc b/chromium/third_party/blink/renderer/core/input/pointer_event_manager.cc
index fffde3296b6..990c1a953dc 100644
--- a/chromium/third_party/blink/renderer/core/input/pointer_event_manager.cc
+++ b/chromium/third_party/blink/renderer/core/input/pointer_event_manager.cc
@@ -77,7 +77,7 @@ void PointerEventManager::Clear() {
   non_hovering_pointers_canceled_ = false;
   pointer_event_factory_.Clear();
   touch_ids_for_canceled_pointerdowns_.clear();
-  node_under_pointer_.clear();
+  element_under_pointer_.clear();
   pointer_capture_target_.clear();
   pending_pointer_capture_target_.clear();
   user_gesture_holder_.reset();
@@ -86,7 +86,7 @@ void PointerEventManager::Clear() {
 
 void PointerEventManager::Trace(blink::Visitor* visitor) {
   visitor->Trace(frame_);
-  visitor->Trace(node_under_pointer_);
+  visitor->Trace(element_under_pointer_);
   visitor->Trace(pointer_capture_target_);
   visitor->Trace(pending_pointer_capture_target_);
   visitor->Trace(touch_event_manager_);
@@ -157,7 +157,7 @@ WebInputEventResult PointerEventManager::DispatchPointerEvent(
   if (!target)
     return WebInputEventResult::kNotHandled;
 
-  const int pointer_id = pointer_event->pointerId();
+  const PointerId pointer_id = pointer_event->pointerId();
   const AtomicString& event_type = pointer_event->type();
 
   if (!frame_ || !HasPointerEventListener(frame_->GetEventHandlerRegistry()))
@@ -177,23 +177,24 @@ WebInputEventResult PointerEventManager::DispatchPointerEvent(
       UseCounter::Count(frame_, WebFeature::kPointerEventDispatchPointerDown);
 
     DCHECK(!dispatching_pointer_id_);
-    base::AutoReset<int> dispatch_holder(&dispatching_pointer_id_, pointer_id);
+    base::AutoReset<PointerId> dispatch_holder(&dispatching_pointer_id_,
+                                               pointer_id);
     DispatchEventResult dispatch_result = target->DispatchEvent(*pointer_event);
     return event_handling_util::ToWebInputEventResult(dispatch_result);
   }
   return WebInputEventResult::kNotHandled;
 }
 
-EventTarget* PointerEventManager::GetEffectiveTargetForPointerEvent(
-    EventTarget* target,
-    int pointer_id) {
-  if (EventTarget* capturing_target = GetCapturingNode(pointer_id))
+Element* PointerEventManager::GetEffectiveTargetForPointerEvent(
+    Element* target,
+    PointerId pointer_id) {
+  if (Element* capturing_target = GetCapturingElement(pointer_id))
     return capturing_target;
   return target;
 }
 
 void PointerEventManager::SendMouseAndPointerBoundaryEvents(
-    Node* entered_node,
+    Element* entered_element,
     const String& canvas_region_id,
     const WebMouseEvent& mouse_event) {
   // Mouse event type does not matter as this pointerevent will only be used
@@ -215,7 +216,7 @@ void PointerEventManager::SendMouseAndPointerBoundaryEvents(
         mouse_event.pointer_type)] = false;
   }
 
-  ProcessCaptureAndPositionOfPointerEvent(dummy_pointer_event, entered_node,
+  ProcessCaptureAndPositionOfPointerEvent(dummy_pointer_event, entered_element,
                                           canvas_region_id, &mouse_event);
 }
 
@@ -227,22 +228,22 @@ void PointerEventManager::SendBoundaryEvents(EventTarget* exited_target,
   boundary_event_dispatcher.SendBoundaryEvents(exited_target, entered_target);
 }
 
-void PointerEventManager::SetNodeUnderPointer(PointerEvent* pointer_event,
-                                              EventTarget* target) {
-  if (node_under_pointer_.Contains(pointer_event->pointerId())) {
+void PointerEventManager::SetElementUnderPointer(PointerEvent* pointer_event,
+                                                 Element* target) {
+  if (element_under_pointer_.Contains(pointer_event->pointerId())) {
     EventTargetAttributes node =
-        node_under_pointer_.at(pointer_event->pointerId());
+        element_under_pointer_.at(pointer_event->pointerId());
     if (!target) {
-      node_under_pointer_.erase(pointer_event->pointerId());
+      element_under_pointer_.erase(pointer_event->pointerId());
     } else if (target !=
-               node_under_pointer_.at(pointer_event->pointerId()).target) {
-      node_under_pointer_.Set(pointer_event->pointerId(),
-                              EventTargetAttributes(target));
+               element_under_pointer_.at(pointer_event->pointerId()).target) {
+      element_under_pointer_.Set(pointer_event->pointerId(),
+                                 EventTargetAttributes(target));
     }
     SendBoundaryEvents(node.target, target, pointer_event);
   } else if (target) {
-    node_under_pointer_.insert(pointer_event->pointerId(),
-                               EventTargetAttributes(target));
+    element_under_pointer_.insert(pointer_event->pointerId(),
+                                  EventTargetAttributes(target));
     SendBoundaryEvents(nullptr, target, pointer_event);
   }
 }
@@ -265,10 +266,10 @@ void PointerEventManager::HandlePointerInterruption(
 
     // Cancel all non-hovering pointers if the pointer is not mouse.
     if (!non_hovering_pointers_canceled_) {
-      Vector<int> non_hovering_pointer_ids =
+      Vector<PointerId> non_hovering_pointer_ids =
           pointer_event_factory_.GetPointerIdsOfNonHoveringPointers();
 
-      for (int pointer_id : non_hovering_pointer_ids) {
+      for (PointerId pointer_id : non_hovering_pointer_ids) {
         canceled_pointer_events.push_back(
             pointer_event_factory_.CreatePointerCancelEvent(
                 pointer_id, web_pointer_event.TimeStamp()));
@@ -281,9 +282,9 @@ void PointerEventManager::HandlePointerInterruption(
   for (auto pointer_event : canceled_pointer_events) {
     // If we are sending a pointercancel we have sent the pointerevent to some
     // target before.
-    DCHECK(node_under_pointer_.Contains(pointer_event->pointerId()));
-    EventTarget* target =
-        node_under_pointer_.at(pointer_event->pointerId()).target;
+    DCHECK(element_under_pointer_.Contains(pointer_event->pointerId()));
+    Element* target =
+        element_under_pointer_.at(pointer_event->pointerId()).target;
 
     DispatchPointerEvent(
         GetEffectiveTargetForPointerEvent(target, pointer_event->pointerId()),
@@ -358,7 +359,8 @@ PointerEventManager::ComputePointerEventTarget(
     const WebPointerEvent& web_pointer_event) {
   event_handling_util::PointerEventTarget pointer_event_target;
 
-  int pointer_id = pointer_event_factory_.GetPointerEventId(web_pointer_event);
+  PointerId pointer_id =
+      pointer_event_factory_.GetPointerEventId(web_pointer_event);
   // Do the hit test either when the touch first starts or when the touch
   // is not captured. |m_pendingPointerCaptureTarget| indicates the target
   // that will be capturing this event. |m_pointerCaptureTarget| may not
@@ -373,34 +375,27 @@ PointerEventManager::ComputePointerEventTarget(
         LayoutPoint(web_pointer_event.PositionInWidget())));
     HitTestResult hit_test_tesult =
         frame_->GetEventHandler().HitTestResultAtLocation(location, hit_type);
-    Node* node = hit_test_tesult.InnerNode();
-    if (node) {
-      pointer_event_target.target_frame = node->GetDocument().GetFrame();
-      if (auto* canvas = ToHTMLCanvasElementOrNull(node)) {
+    Element* target = hit_test_tesult.InnerElement();
+    if (target) {
+      pointer_event_target.target_frame = target->GetDocument().GetFrame();
+      if (auto* canvas = ToHTMLCanvasElementOrNull(target)) {
         HitTestCanvasResult* hit_test_canvas_result =
             canvas->GetControlAndIdIfHitRegionExists(
                 hit_test_tesult.PointInInnerNodeFrame());
         if (hit_test_canvas_result->GetControl())
-          node = hit_test_canvas_result->GetControl();
+          target = hit_test_canvas_result->GetControl();
         pointer_event_target.region = hit_test_canvas_result->GetId();
       }
-      // TODO(crbug.com/612456): We need to investigate whether pointer
-      // events should go to text nodes or not. If so we need to
-      // update the mouse code as well. Also this logic looks similar
-      // to the one in TouchEventManager. We should be able to
-      // refactor it better after this investigation.
-      if (node->IsTextNode())
-        node = FlatTreeTraversal::Parent(*node);
-      pointer_event_target.target_node = node;
+      pointer_event_target.target_element = target;
     }
   } else {
-    // Set the target of pointer event to the captured node as this
+    // Set the target of pointer event to the captured element as this
     // pointer is captured otherwise it would have gone to the if block
     // and perform a hit-test.
-    pointer_event_target.target_node =
-        pending_pointer_capture_target_.at(pointer_id)->ToNode();
+    pointer_event_target.target_element =
+        pending_pointer_capture_target_.at(pointer_id);
     pointer_event_target.target_frame =
-        pointer_event_target.target_node->GetDocument().GetFrame();
+        pointer_event_target.target_element->GetDocument().GetFrame();
   }
   return pointer_event_target;
 }
@@ -414,15 +409,15 @@ WebInputEventResult PointerEventManager::DispatchTouchPointerEvent(
             WebInputEvent::Type::kPointerCausedUaAction);
 
   WebInputEventResult result = WebInputEventResult::kHandledSystem;
-  if (pointer_event_target.target_node && pointer_event_target.target_frame &&
-      !non_hovering_pointers_canceled_) {
+  if (pointer_event_target.target_element &&
+      pointer_event_target.target_frame && !non_hovering_pointers_canceled_) {
     PointerEvent* pointer_event = pointer_event_factory_.Create(
         web_pointer_event, coalesced_events, predicted_events,
-        pointer_event_target.target_node
-            ? pointer_event_target.target_node->GetDocument().domWindow()
+        pointer_event_target.target_element
+            ? pointer_event_target.target_element->GetDocument().domWindow()
             : nullptr);
 
-    result = SendTouchPointerEvent(pointer_event_target.target_node,
+    result = SendTouchPointerEvent(pointer_event_target.target_element,
                                    pointer_event, web_pointer_event.hovering);
 
     // If a pointerdown has been canceled, queue the unique id to allow
@@ -442,7 +437,7 @@ WebInputEventResult PointerEventManager::DispatchTouchPointerEvent(
 }
 
 WebInputEventResult PointerEventManager::SendTouchPointerEvent(
-    EventTarget* target,
+    Element* target,
     PointerEvent* pointer_event,
     bool hovering) {
   if (non_hovering_pointers_canceled_)
@@ -516,7 +511,7 @@ WebInputEventResult PointerEventManager::HandlePointerEvent(
       }
       target = pointer_locked_element;
     } else {
-      target = ComputePointerEventTarget(event).target_node;
+      target = ComputePointerEventTarget(event).target_element;
     }
 
     PointerEvent* pointer_event =
@@ -627,12 +622,13 @@ WebInputEventResult PointerEventManager::DirectDispatchMousePointerEvent(
 }
 
 WebInputEventResult PointerEventManager::SendMousePointerEvent(
-    Node* target,
+    Element* target,
     const String& canvas_region_id,
     const WebInputEvent::Type event_type,
     const WebMouseEvent& mouse_event,
     const Vector<WebMouseEvent>& coalesced_events,
-    const Vector<WebMouseEvent>& predicted_events) {
+    const Vector<WebMouseEvent>& predicted_events,
+    bool skip_click_dispatch) {
   DCHECK(event_type == WebInputEvent::kPointerDown ||
          event_type == WebInputEvent::kPointerMove ||
          event_type == WebInputEvent::kPointerUp);
@@ -674,14 +670,14 @@ WebInputEventResult PointerEventManager::SendMousePointerEvent(
     }
   }
 
-  EventTarget* pointer_event_target = ProcessCaptureAndPositionOfPointerEvent(
+  Element* pointer_event_target = ProcessCaptureAndPositionOfPointerEvent(
       pointer_event, target, canvas_region_id, &mouse_event);
 
   // Don't send fake mouse event to the DOM.
   if (fake_event)
     return WebInputEventResult::kHandledSuppressed;
 
-  EventTarget* effective_target = GetEffectiveTargetForPointerEvent(
+  Element* effective_target = GetEffectiveTargetForPointerEvent(
       pointer_event_target, pointer_event->pointerId());
 
   if ((event_type == WebInputEvent::kPointerDown ||
@@ -706,27 +702,38 @@ WebInputEventResult PointerEventManager::SendMousePointerEvent(
         mouse_event.pointer_type)] = true;
   }
 
+  // Only calculate mouse target if either mouse compatibility event or click
+  // should be sent.
   if (pointer_event->isPrimary() &&
-      !prevent_mouse_event_for_pointer_type_[ToPointerTypeIndex(
-          mouse_event.pointer_type)]) {
-    EventTarget* mouse_target = effective_target;
-    // Event path could be null if pointer event is not dispatched and
-    // that happens for example when pointer event feature is not enabled.
+      (!prevent_mouse_event_for_pointer_type_[ToPointerTypeIndex(
+           mouse_event.pointer_type)] ||
+       (!skip_click_dispatch && event_type == WebInputEvent::kPointerUp))) {
+    Element* mouse_target = effective_target;
+    // Event path could be null if the pointer event is not dispatched.
     if (!event_handling_util::IsInDocument(mouse_target) &&
         pointer_event->HasEventPath()) {
       for (const auto& context :
            pointer_event->GetEventPath().NodeEventContexts()) {
-        if (event_handling_util::IsInDocument(&context.GetNode())) {
-          mouse_target = &context.GetNode();
+        if (context.GetNode().IsElementNode() &&
+            event_handling_util::IsInDocument(&context.GetNode())) {
+          mouse_target = ToElement(&context.GetNode());
           break;
         }
       }
     }
-    result = event_handling_util::MergeEventResult(
-        result,
-        mouse_event_manager_->DispatchMouseEvent(
-            mouse_target, MouseEventNameForPointerEventInputType(event_type),
-            mouse_event, canvas_region_id, &last_mouse_position, nullptr));
+    if (!prevent_mouse_event_for_pointer_type_[ToPointerTypeIndex(
+            mouse_event.pointer_type)]) {
+      result = event_handling_util::MergeEventResult(
+          result,
+          mouse_event_manager_->DispatchMouseEvent(
+              mouse_target, MouseEventNameForPointerEventInputType(event_type),
+              mouse_event, canvas_region_id, &last_mouse_position, nullptr));
+    }
+    if (!skip_click_dispatch && mouse_target &&
+        event_type == WebInputEvent::kPointerUp) {
+      mouse_event_manager_->DispatchMouseClickIfNeeded(
+          mouse_target, mouse_event, canvas_region_id);
+    }
   }
 
   if (pointer_event->type() == event_type_names::kPointerup ||
@@ -762,16 +769,16 @@ WebInputEventResult PointerEventManager::SendMousePointerEvent(
 }
 
 bool PointerEventManager::GetPointerCaptureState(
-    int pointer_id,
-    EventTarget** pointer_capture_target,
-    EventTarget** pending_pointer_capture_target) {
+    PointerId pointer_id,
+    Element** pointer_capture_target,
+    Element** pending_pointer_capture_target) {
   PointerCapturingMap::const_iterator it;
 
   it = pointer_capture_target_.find(pointer_id);
-  EventTarget* pointer_capture_target_temp =
+  Element* pointer_capture_target_temp =
       (it != pointer_capture_target_.end()) ? it->value : nullptr;
   it = pending_pointer_capture_target_.find(pointer_id);
-  EventTarget* pending_pointercapture_target_temp =
+  Element* pending_pointercapture_target_temp =
       (it != pending_pointer_capture_target_.end()) ? it->value : nullptr;
 
   if (pointer_capture_target)
@@ -782,33 +789,32 @@ bool PointerEventManager::GetPointerCaptureState(
   return pointer_capture_target_temp != pending_pointercapture_target_temp;
 }
 
-EventTarget* PointerEventManager::ProcessCaptureAndPositionOfPointerEvent(
+Element* PointerEventManager::ProcessCaptureAndPositionOfPointerEvent(
     PointerEvent* pointer_event,
-    EventTarget* hit_test_target,
+    Element* hit_test_target,
     const String& canvas_region_id,
     const WebMouseEvent* mouse_event) {
   ProcessPendingPointerCapture(pointer_event);
 
   PointerCapturingMap::const_iterator it =
       pointer_capture_target_.find(pointer_event->pointerId());
-  if (EventTarget* pointercapture_target =
+  if (Element* pointercapture_target =
           (it != pointer_capture_target_.end()) ? it->value : nullptr)
     hit_test_target = pointercapture_target;
 
-  SetNodeUnderPointer(pointer_event, hit_test_target);
+  SetElementUnderPointer(pointer_event, hit_test_target);
   if (mouse_event) {
-    mouse_event_manager_->SetNodeUnderMouse(
-        hit_test_target ? hit_test_target->ToNode() : nullptr, canvas_region_id,
-        *mouse_event);
+    mouse_event_manager_->SetElementUnderMouse(hit_test_target,
+                                               canvas_region_id, *mouse_event);
   }
   return hit_test_target;
 }
 
 void PointerEventManager::ProcessPendingPointerCapture(
     PointerEvent* pointer_event) {
-  EventTarget* pointer_capture_target;
-  EventTarget* pending_pointer_capture_target;
-  const int pointer_id = pointer_event->pointerId();
+  Element* pointer_capture_target;
+  Element* pending_pointer_capture_target;
+  const PointerId pointer_id = pointer_event->pointerId();
   const bool is_capture_changed = GetPointerCaptureState(
       pointer_id, &pointer_capture_target, &pending_pointer_capture_target);
 
@@ -821,8 +827,8 @@ void PointerEventManager::ProcessPendingPointerCapture(
     // Re-target lostpointercapture to the document when the element is
     // no longer participating in the tree.
     EventTarget* target = pointer_capture_target;
-    if (target->ToNode() && !target->ToNode()->isConnected()) {
-      target = target->ToNode()->ownerDocument();
+    if (!pointer_capture_target->isConnected()) {
+      target = pointer_capture_target->ownerDocument();
     }
     DispatchPointerEvent(
         target, pointer_event_factory_.CreatePointerCaptureEvent(
@@ -830,7 +836,7 @@ void PointerEventManager::ProcessPendingPointerCapture(
   }
 
   if (pending_pointer_capture_target) {
-    SetNodeUnderPointer(pointer_event, pending_pointer_capture_target);
+    SetElementUnderPointer(pointer_event, pending_pointer_capture_target);
     DispatchPointerEvent(
         pending_pointer_capture_target,
         pointer_event_factory_.CreatePointerCaptureEvent(
@@ -852,7 +858,7 @@ void PointerEventManager::ProcessPendingPointerCaptureForPointerLock(
 
 void PointerEventManager::RemoveTargetFromPointerCapturingMapping(
     PointerCapturingMap& map,
-    const EventTarget* target) {
+    const Element* target) {
   // We could have kept a reverse mapping to make this deletion possibly
   // faster but it adds some code complication which might not be worth of
   // the performance improvement considering there might not be a lot of
@@ -864,28 +870,28 @@ void PointerEventManager::RemoveTargetFromPointerCapturingMapping(
   }
 }
 
-EventTarget* PointerEventManager::GetCapturingNode(int pointer_id) {
+Element* PointerEventManager::GetCapturingElement(PointerId pointer_id) {
   if (pointer_capture_target_.Contains(pointer_id))
     return pointer_capture_target_.at(pointer_id);
   return nullptr;
 }
 
 void PointerEventManager::RemovePointer(PointerEvent* pointer_event) {
-  int pointer_id = pointer_event->pointerId();
+  PointerId pointer_id = pointer_event->pointerId();
   if (pointer_event_factory_.Remove(pointer_id)) {
     pending_pointer_capture_target_.erase(pointer_id);
     pointer_capture_target_.erase(pointer_id);
-    node_under_pointer_.erase(pointer_id);
+    element_under_pointer_.erase(pointer_id);
   }
 }
 
-void PointerEventManager::ElementRemoved(EventTarget* target) {
+void PointerEventManager::ElementRemoved(Element* target) {
   RemoveTargetFromPointerCapturingMapping(pending_pointer_capture_target_,
                                           target);
 }
 
-void PointerEventManager::SetPointerCapture(int pointer_id,
-                                            EventTarget* target) {
+void PointerEventManager::SetPointerCapture(PointerId pointer_id,
+                                            Element* target) {
   UseCounter::Count(frame_, WebFeature::kPointerEventSetCapture);
   if (pointer_event_factory_.IsActiveButtonsState(pointer_id)) {
     if (pointer_id != dispatching_pointer_id_) {
@@ -896,8 +902,8 @@ void PointerEventManager::SetPointerCapture(int pointer_id,
   }
 }
 
-void PointerEventManager::ReleasePointerCapture(int pointer_id,
-                                                EventTarget* target) {
+void PointerEventManager::ReleasePointerCapture(PointerId pointer_id,
+                                                Element* target) {
   // Only the element that is going to get the next pointer event can release
   // the capture. Note that this might be different from
   // |m_pointercaptureTarget|. |m_pointercaptureTarget| holds the element
@@ -913,22 +919,16 @@ void PointerEventManager::ReleaseMousePointerCapture() {
   ReleasePointerCapture(PointerEventFactory::kMouseId);
 }
 
-bool PointerEventManager::HasPointerCapture(int pointer_id,
-                                            const EventTarget* target) const {
+bool PointerEventManager::HasPointerCapture(PointerId pointer_id,
+                                            const Element* target) const {
   return pending_pointer_capture_target_.at(pointer_id) == target;
 }
 
-bool PointerEventManager::HasProcessedPointerCapture(
-    int pointer_id,
-    const EventTarget* target) const {
-  return pointer_capture_target_.at(pointer_id) == target;
-}
-
-void PointerEventManager::ReleasePointerCapture(int pointer_id) {
+void PointerEventManager::ReleasePointerCapture(PointerId pointer_id) {
   pending_pointer_capture_target_.erase(pointer_id);
 }
 
-bool PointerEventManager::IsActive(const int pointer_id) const {
+bool PointerEventManager::IsActive(const PointerId pointer_id) const {
   return pointer_event_factory_.IsActive(pointer_id);
 }
 
@@ -937,17 +937,17 @@ bool PointerEventManager::IsActive(const int pointer_id) const {
 // page managers to their target (event if target is in an iframe) and only
 // those managers will keep track of these pointer events.
 bool PointerEventManager::IsTouchPointerIdActiveOnFrame(
-    int pointer_id,
+    PointerId pointer_id,
     LocalFrame* frame) const {
   if (pointer_event_factory_.GetPointerType(pointer_id) !=
       WebPointerProperties::PointerType::kTouch)
     return false;
-  Node* last_node_receiving_event =
-      node_under_pointer_.Contains(pointer_id)
-          ? node_under_pointer_.at(pointer_id).target->ToNode()
+  Element* last_element_receiving_event =
+      element_under_pointer_.Contains(pointer_id)
+          ? element_under_pointer_.at(pointer_id).target
           : nullptr;
-  return last_node_receiving_event &&
-         last_node_receiving_event->GetDocument().GetFrame() == frame;
+  return last_element_receiving_event &&
+         last_element_receiving_event->GetDocument().GetFrame() == frame;
 }
 
 bool PointerEventManager::IsAnyTouchActive() const {