BASELINE: Update Chromium to 72.0.3626.110 and Ninja to 1.9.0

Change-Id: Ic57220b00ecc929a893c91f5cc552f5d3e99e922
Reviewed-by: Michael Brüning <michael.bruning@qt.io>

1 files changed, 114 insertions, 66 deletions

diff --git a/chromium/third_party/blink/renderer/core/input/mouse_event_manager.cc b/chromium/third_party/blink/renderer/core/input/mouse_event_manager.cc
index 10775801d02..7b5b4009d8e 100644
--- a/chromium/third_party/blink/renderer/core/input/mouse_event_manager.cc
+++ b/chromium/third_party/blink/renderer/core/input/mouse_event_manager.cc
@@ -61,6 +61,27 @@ String CanvasRegionId(Node* node, const WebMouseEvent& mouse_event) {
   return canvas->GetIdFromControl(element);
 }
 
+void UpdateMouseMovementXY(const WebMouseEvent& mouse_event,
+                           const FloatPoint* last_position,
+                           MouseEventInit* initializer) {
+  if (RuntimeEnabledFeatures::MovementXYInBlinkEnabled() &&
+      mouse_event.GetType() == WebInputEvent::kMouseMove && last_position) {
+    if (RuntimeEnabledFeatures::FractionalMouseEventEnabled()) {
+      initializer->setMovementX(mouse_event.PositionInScreen().x -
+                                last_position->X());
+      initializer->setMovementY(mouse_event.PositionInScreen().y -
+                                last_position->Y());
+    } else {
+      initializer->setMovementX(
+          static_cast<int>(mouse_event.PositionInScreen().x) -
+          static_cast<int>(last_position->X()));
+      initializer->setMovementY(
+          static_cast<int>(mouse_event.PositionInScreen().y) -
+          static_cast<int>(last_position->Y()));
+    }
+  }
+}
+
 // The amount of time to wait before sending a fake mouse event triggered
 // during a scroll.
 constexpr TimeDelta kFakeMouseMoveIntervalDuringScroll =
@@ -116,7 +137,7 @@ void MouseEventManager::Clear() {
   svg_pan_ = false;
   drag_start_pos_ = LayoutPoint();
   fake_mouse_move_event_timer_.Stop();
-  ResetDragState();
+  ResetDragSource();
   ClearDragDataTransfer();
 }
 
@@ -145,7 +166,7 @@ MouseEventManager::MouseEventBoundaryEventDispatcher::
 void MouseEventManager::MouseEventBoundaryEventDispatcher::DispatchOut(
     EventTarget* target,
     EventTarget* related_target) {
-  Dispatch(target, related_target, EventTypeNames::mouseout,
+  Dispatch(target, related_target, event_type_names::kMouseout,
            CanvasRegionId(exited_target_->ToNode(), *web_mouse_event_),
            *web_mouse_event_, false);
 }
@@ -153,15 +174,15 @@ void MouseEventManager::MouseEventBoundaryEventDispatcher::DispatchOut(
 void MouseEventManager::MouseEventBoundaryEventDispatcher::DispatchOver(
     EventTarget* target,
     EventTarget* related_target) {
-  Dispatch(target, related_target, EventTypeNames::mouseover, canvas_region_id_,
-           *web_mouse_event_, false);
+  Dispatch(target, related_target, event_type_names::kMouseover,
+           canvas_region_id_, *web_mouse_event_, false);
 }
 
 void MouseEventManager::MouseEventBoundaryEventDispatcher::DispatchLeave(
     EventTarget* target,
     EventTarget* related_target,
     bool check_for_listener) {
-  Dispatch(target, related_target, EventTypeNames::mouseleave,
+  Dispatch(target, related_target, event_type_names::kMouseleave,
            CanvasRegionId(exited_target_->ToNode(), *web_mouse_event_),
            *web_mouse_event_, check_for_listener);
 }
@@ -170,18 +191,18 @@ void MouseEventManager::MouseEventBoundaryEventDispatcher::DispatchEnter(
     EventTarget* target,
     EventTarget* related_target,
     bool check_for_listener) {
-  Dispatch(target, related_target, EventTypeNames::mouseenter,
+  Dispatch(target, related_target, event_type_names::kMouseenter,
            canvas_region_id_, *web_mouse_event_, check_for_listener);
 }
 
 AtomicString
 MouseEventManager::MouseEventBoundaryEventDispatcher::GetLeaveEvent() {
-  return EventTypeNames::mouseleave;
+  return event_type_names::kMouseleave;
 }
 
 AtomicString
 MouseEventManager::MouseEventBoundaryEventDispatcher::GetEnterEvent() {
-  return EventTypeNames::mouseenter;
+  return event_type_names::kMouseenter;
 }
 
 void MouseEventManager::MouseEventBoundaryEventDispatcher::Dispatch(
@@ -192,8 +213,8 @@ void MouseEventManager::MouseEventBoundaryEventDispatcher::Dispatch(
     const WebMouseEvent& web_mouse_event,
     bool check_for_listener) {
   mouse_event_manager_->DispatchMouseEvent(target, type, web_mouse_event,
-                                           canvas_region_id, related_target,
-                                           check_for_listener);
+                                           canvas_region_id, nullptr,
+                                           related_target, check_for_listener);
 }
 
 void MouseEventManager::SendBoundaryEvents(EventTarget* exited_target,
@@ -210,40 +231,42 @@ WebInputEventResult MouseEventManager::DispatchMouseEvent(
     const AtomicString& mouse_event_type,
     const WebMouseEvent& mouse_event,
     const String& canvas_region_id,
+    const FloatPoint* last_position,
     EventTarget* related_target,
     bool check_for_listener) {
   if (target && target->ToNode() &&
       (!check_for_listener || target->HasEventListeners(mouse_event_type))) {
     Node* target_node = target->ToNode();
     int click_count = 0;
-    if (mouse_event_type == EventTypeNames::mouseup ||
-        mouse_event_type == EventTypeNames::mousedown ||
-        mouse_event_type == EventTypeNames::click ||
-        mouse_event_type == EventTypeNames::auxclick ||
-        mouse_event_type == EventTypeNames::dblclick) {
+    if (mouse_event_type == event_type_names::kMouseup ||
+        mouse_event_type == event_type_names::kMousedown ||
+        mouse_event_type == event_type_names::kClick ||
+        mouse_event_type == event_type_names::kAuxclick ||
+        mouse_event_type == event_type_names::kDblclick) {
       click_count = click_count_;
     }
     bool is_mouse_enter_or_leave =
-        mouse_event_type == EventTypeNames::mouseenter ||
-        mouse_event_type == EventTypeNames::mouseleave;
-    MouseEventInit initializer;
-    initializer.setBubbles(!is_mouse_enter_or_leave);
-    initializer.setCancelable(!is_mouse_enter_or_leave);
+        mouse_event_type == event_type_names::kMouseenter ||
+        mouse_event_type == event_type_names::kMouseleave;
+    MouseEventInit* initializer = MouseEventInit::Create();
+    initializer->setBubbles(!is_mouse_enter_or_leave);
+    initializer->setCancelable(!is_mouse_enter_or_leave);
     MouseEvent::SetCoordinatesFromWebPointerProperties(
         mouse_event.FlattenTransform(), target_node->GetDocument().domWindow(),
         initializer);
-    initializer.setButton(static_cast<short>(mouse_event.button));
-    initializer.setButtons(MouseEvent::WebInputEventModifiersToButtons(
+    UpdateMouseMovementXY(mouse_event, last_position, initializer);
+    initializer->setButton(static_cast<short>(mouse_event.button));
+    initializer->setButtons(MouseEvent::WebInputEventModifiersToButtons(
         mouse_event.GetModifiers()));
-    initializer.setView(target_node->GetDocument().domWindow());
-    initializer.setComposed(true);
-    initializer.setDetail(click_count);
-    initializer.setRegion(canvas_region_id);
-    initializer.setRelatedTarget(related_target);
+    initializer->setView(target_node->GetDocument().domWindow());
+    initializer->setComposed(true);
+    initializer->setDetail(click_count);
+    initializer->setRegion(canvas_region_id);
+    initializer->setRelatedTarget(related_target);
     UIEventWithKeyState::SetFromWebInputEventModifiers(
         initializer,
         static_cast<WebInputEvent::Modifiers>(mouse_event.GetModifiers()));
-    initializer.setSourceCapabilities(
+    initializer->setSourceCapabilities(
         target_node->GetDocument().domWindow()
             ? target_node->GetDocument()
                   .domWindow()
@@ -258,7 +281,7 @@ WebInputEventResult MouseEventManager::DispatchMouseEvent(
         mouse_event.menu_source_type);
 
     DispatchEventResult dispatch_result = target->DispatchEvent(*event);
-    return EventHandlingUtil::ToWebInputEventResult(dispatch_result);
+    return event_handling_util::ToWebInputEventResult(dispatch_result);
   }
   return WebInputEventResult::kNotHandled;
 }
@@ -275,7 +298,7 @@ WebInputEventResult MouseEventManager::SetMousePositionAndDispatchMouseEvent(
   SetNodeUnderMouse(target_node, canvas_region_id, web_mouse_event);
 
   return DispatchMouseEvent(node_under_mouse_, event_type, web_mouse_event,
-                            canvas_region_id, nullptr);
+                            canvas_region_id, nullptr, nullptr);
 }
 
 WebInputEventResult MouseEventManager::DispatchMouseClickIfNeeded(
@@ -316,7 +339,7 @@ WebInputEventResult MouseEventManager::DispatchMouseClickIfNeeded(
     mouse_down_element_->UpdateDistributionForFlatTreeTraversal();
     mouse_release_target.UpdateDistributionForFlatTreeTraversal();
     click_target_node = mouse_release_target.CommonAncestor(
-        *mouse_down_element_, EventHandlingUtil::ParentForClickEvent);
+        *mouse_down_element_, event_handling_util::ParentForClickEvent);
   }
   if (!click_target_node)
     return WebInputEventResult::kNotHandled;
@@ -338,9 +361,9 @@ WebInputEventResult MouseEventManager::DispatchMouseClickIfNeeded(
     return DispatchMouseEvent(
         click_target_node,
         (mev.Event().button == WebPointerProperties::Button::kLeft)
-            ? EventTypeNames::click
-            : EventTypeNames::auxclick,
-        mev.Event(), mev.CanvasRegionId(), nullptr);
+            ? event_type_names::kClick
+            : event_type_names::kAuxclick,
+        mev.Event(), mev.CanvasRegionId(), nullptr, nullptr);
   }
 
   return WebInputEventResult::kNotHandled;
@@ -350,6 +373,10 @@ void MouseEventManager::FakeMouseMoveEventTimerFired(TimerBase* timer) {
   TRACE_EVENT0("input", "MouseEventManager::fakeMouseMoveEventTimerFired");
   DCHECK(timer == &fake_mouse_move_event_timer_);
 
+  RecomputeMouseHoverState();
+}
+
+void MouseEventManager::RecomputeMouseHoverState() {
   if (is_mouse_position_unknown_)
     return;
 
@@ -376,9 +403,10 @@ void MouseEventManager::FakeMouseMoveEventTimerFired(TimerBase* timer) {
                                       last_known_mouse_position_,
                                       last_known_mouse_global_position_, button,
                                       0, modifiers, CurrentTimeTicks());
-  Vector<WebMouseEvent> coalesced_events;
+  Vector<WebMouseEvent> coalesced_events, predicted_events;
   frame_->GetEventHandler().HandleMouseMoveEvent(
-      TransformWebMouseEvent(view, fake_mouse_move_event), coalesced_events);
+      TransformWebMouseEvent(view, fake_mouse_move_event), coalesced_events,
+      predicted_events);
 }
 
 void MouseEventManager::CancelFakeMouseMoveEvent() {
@@ -393,9 +421,9 @@ void MouseEventManager::SetNodeUnderMouse(
   node_under_mouse_ = target;
 
   PaintLayer* layer_for_last_node =
-      EventHandlingUtil::LayerForNode(last_node_under_mouse);
+      event_handling_util::LayerForNode(last_node_under_mouse);
   PaintLayer* layer_for_node_under_mouse =
-      EventHandlingUtil::LayerForNode(node_under_mouse_.Get());
+      event_handling_util::LayerForNode(node_under_mouse_.Get());
   Page* page = frame_->GetPage();
 
   if (page && (layer_for_last_node &&
@@ -403,7 +431,7 @@ void MouseEventManager::SetNodeUnderMouse(
                 layer_for_node_under_mouse != layer_for_last_node))) {
     // The mouse has moved between layers.
     if (ScrollableArea* scrollable_area_for_last_node =
-            EventHandlingUtil::AssociatedScrollableArea(layer_for_last_node))
+            event_handling_util::AssociatedScrollableArea(layer_for_last_node))
       scrollable_area_for_last_node->MouseExitedContentArea();
   }
 
@@ -412,7 +440,7 @@ void MouseEventManager::SetNodeUnderMouse(
                 layer_for_node_under_mouse != layer_for_last_node))) {
     // The mouse has moved between layers.
     if (ScrollableArea* scrollable_area_for_node_under_mouse =
-            EventHandlingUtil::AssociatedScrollableArea(
+            event_handling_util::AssociatedScrollableArea(
                 layer_for_node_under_mouse))
       scrollable_area_for_node_under_mouse->MouseEnteredContentArea();
   }
@@ -614,7 +642,6 @@ void MouseEventManager::MayUpdateHoverWhenContentUnderMouseChanged(
   if (RuntimeEnabledFeatures::NoHoverAfterLayoutChangeEnabled() &&
       update_hover_reason ==
           MouseEventManager::UpdateHoverReason::kLayoutOrStyleChanged) {
-    frame_->LocalFrameRoot().GetEventHandler().ScheduleCursorUpdate();
     return;
   }
 
@@ -662,7 +689,7 @@ WebInputEventResult MouseEventManager::HandleMousePressEvent(
     const MouseEventWithHitTestResults& event) {
   TRACE_EVENT0("blink", "MouseEventManager::handleMousePressEvent");
 
-  ResetDragState();
+  ResetDragSource();
   CancelFakeMouseMoveEvent();
 
   frame_->GetDocument()->UpdateStyleAndLayoutIgnorePendingStylesheets();
@@ -759,10 +786,10 @@ bool MouseEventManager::HandleDragDropIfPossible(
         CurrentTimeTicks());
     HitTestRequest request(HitTestRequest::kReadOnly);
     MouseEventWithHitTestResults mev =
-        EventHandlingUtil::PerformMouseEventHitTest(frame_, request,
-                                                    mouse_drag_event);
+        event_handling_util::PerformMouseEventHitTest(frame_, request,
+                                                      mouse_drag_event);
     mouse_down_may_start_drag_ = true;
-    ResetDragState();
+    ResetDragSource();
     mouse_down_pos_ = frame_->View()->ConvertFromRootFrame(
         FlooredIntPoint(mouse_drag_event.PositionInRootFrame()));
     return HandleDrag(mev, DragInitiator::kTouch);
@@ -895,7 +922,7 @@ bool MouseEventManager::HandleDrag(const MouseEventWithHitTestResults& event,
               frame_, node, mouse_down_pos_, selection_drag_policy,
               GetDragState().drag_type_);
     } else {
-      ResetDragState();
+      ResetDragSource();
     }
 
     if (!GetDragState().drag_src_)
@@ -913,7 +940,7 @@ bool MouseEventManager::HandleDrag(const MouseEventWithHitTestResults& event,
   if (initiator == DragInitiator::kMouse &&
       !DragThresholdExceeded(
           FlooredIntPoint(event.Event().PositionInRootFrame()))) {
-    ResetDragState();
+    ResetDragSource();
     return true;
   }
 
@@ -924,7 +951,7 @@ bool MouseEventManager::HandleDrag(const MouseEventWithHitTestResults& event,
   if (!TryStartDrag(event)) {
     // Something failed to start the drag, clean up.
     ClearDragDataTransfer();
-    ResetDragState();
+    ResetDragSource();
   } else {
     // Since drag operation started we need to send a pointercancel for the
     // corresponding pointer.
@@ -933,7 +960,7 @@ bool MouseEventManager::HandleDrag(const MouseEventWithHitTestResults& event,
           WebPointerEvent::CreatePointerCausesUaActionEvent(
               WebPointerProperties::PointerType::kMouse,
               event.Event().TimeStamp()),
-          Vector<WebPointerEvent>());
+          Vector<WebPointerEvent>(), Vector<WebPointerEvent>());
     }
     // TODO(crbug.com/708278): If the drag starts with touch the touch cancel
     // should trigger the release of pointer capture.
@@ -964,7 +991,7 @@ bool MouseEventManager::TryStartDrag(
                                                 mouse_down_pos_))
     return false;
 
-  if (DispatchDragSrcEvent(EventTypeNames::dragstart, mouse_down_) !=
+  if (DispatchDragSrcEvent(event_type_names::kDragstart, mouse_down_) !=
       WebInputEventResult::kNotHandled)
     return false;
 
@@ -1001,7 +1028,7 @@ bool MouseEventManager::TryStartDrag(
     return true;
 
   // Drag was canned at the last minute - we owe m_dragSrc a DRAGEND event
-  DispatchDragSrcEvent(EventTypeNames::dragend, event.Event());
+  DispatchDragSrcEvent(event_type_names::kDragend, event.Event());
 
   return false;
 }
@@ -1033,21 +1060,21 @@ WebInputEventResult MouseEventManager::DispatchDragEvent(
       related_target->GetDocument() != drag_target->GetDocument())
     related_target = nullptr;
 
-  DragEventInit initializer;
-  initializer.setBubbles(true);
-  initializer.setCancelable(event_type != EventTypeNames::dragleave &&
-                            event_type != EventTypeNames::dragend);
+  DragEventInit* initializer = DragEventInit::Create();
+  initializer->setBubbles(true);
+  initializer->setCancelable(event_type != event_type_names::kDragleave &&
+                             event_type != event_type_names::kDragend);
   MouseEvent::SetCoordinatesFromWebPointerProperties(
       event.FlattenTransform(), frame_->GetDocument()->domWindow(),
       initializer);
-  initializer.setButton(0);
-  initializer.setButtons(
+  initializer->setButton(0);
+  initializer->setButtons(
       MouseEvent::WebInputEventModifiersToButtons(event.GetModifiers()));
-  initializer.setRelatedTarget(related_target);
-  initializer.setView(frame_->GetDocument()->domWindow());
-  initializer.setComposed(true);
-  initializer.setGetDataTransfer(data_transfer);
-  initializer.setSourceCapabilities(
+  initializer->setRelatedTarget(related_target);
+  initializer->setView(frame_->GetDocument()->domWindow());
+  initializer->setComposed(true);
+  initializer->setGetDataTransfer(data_transfer);
+  initializer->setSourceCapabilities(
       frame_->GetDocument()->domWindow()
           ? frame_->GetDocument()
                 ->domWindow()
@@ -1062,7 +1089,7 @@ WebInputEventResult MouseEventManager::DispatchDragEvent(
                                         ? MouseEvent::kFromTouch
                                         : MouseEvent::kRealOrIndistinguishable);
 
-  return EventHandlingUtil::ToWebInputEventResult(
+  return event_handling_util::ToWebInputEventResult(
       drag_target->DispatchEvent(*me));
 }
 
@@ -1081,10 +1108,10 @@ void MouseEventManager::DragSourceEndedAt(const WebMouseEvent& event,
   if (GetDragState().drag_src_) {
     GetDragState().drag_data_transfer_->SetDestinationOperation(operation);
     // The return value is ignored because dragend is not cancelable.
-    DispatchDragSrcEvent(EventTypeNames::dragend, event);
+    DispatchDragSrcEvent(event_type_names::kDragend, event);
   }
   ClearDragDataTransfer();
-  ResetDragState();
+  ResetDragSource();
   // In case the drag was ended due to an escape key press we need to ensure
   // that consecutive mousemove events don't reinitiate the drag and drop.
   mouse_down_may_start_drag_ = false;
@@ -1095,9 +1122,30 @@ DragState& MouseEventManager::GetDragState() {
   return frame_->GetPage()->GetDragController().GetDragState();
 }
 
-void MouseEventManager::ResetDragState() {
+void MouseEventManager::ResetDragSource() {
+  // Check validity of drag source.
   if (!frame_->GetPage())
     return;
+
+  Node* drag_src = GetDragState().drag_src_;
+  if (!drag_src)
+    return;
+
+  Frame* drag_src_frame = drag_src->GetDocument().GetFrame();
+  if (!drag_src_frame) {
+    // The frame containing the drag_src has been navigated away, so the
+    // drag_src is no longer has an owning frame and is invalid.
+    // See https://crbug.com/903705 for more details.
+    GetDragState().drag_src_ = nullptr;
+    return;
+  }
+
+  // Only allow resetting drag_src_ if the frame requesting reset is above the
+  // drag_src_ node's frame in the frame hierarchy. This way, unrelated frames
+  // can't reset a drag state.
+  if (!drag_src_frame->Tree().IsDescendantOf(frame_))
+    return;
+
   GetDragState().drag_src_ = nullptr;
 }