Add a flag to update hover effect when a layout is changed

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 38 matching lines @@
       Traversal<HTMLCanvasElement>::FirstAncestorOrSelf(*element);
   // In this case, the event target is canvas and mouse rerouting doesn't
   // happen.
   if (canvas == element)
     return String();
   return canvas->GetIdFromControl(element);
 }
 
 // The amount of time to wait before sending a fake mouse event triggered
 // during a scroll.
-const double kFakeMouseMoveInterval = 0.1;
+constexpr double kFakeMouseMoveIntervalDuringScroll = 0.1;
+
+// The amount of time to wait before sending a fake mouse event on style and
+// layout changes sets to 50Hz, same as common screen refresh rate.
+constexpr double kFakeMouseMoveIntervalPerFrame = 0.02;
 
 // TODO(crbug.com/653490): Read these values from the OS.
 #if OS(MACOSX)
 const int kDragThresholdX = 3;
 const int kDragThresholdY = 3;
 constexpr TimeDelta kTextDragDelay = TimeDelta::FromSecondsD(0.15);
 #else
 const int kDragThresholdX = 4;
 const int kDragThresholdY = 4;
 constexpr TimeDelta kTextDragDelay = TimeDelta::FromSecondsD(0.0);
@@ skipping 231 matching lines @@
             : 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;
 
   LocalFrameView* view = frame_->View();
   if (!view)
     return;
 
   if (!frame_->GetPage() || !frame_->GetPage()->GetFocusController().IsActive())
     return;
 
   // Don't dispatch a synthetic mouse move event if the mouse cursor is not
   // visible to the user.
   if (!frame_->GetPage()->IsCursorVisible())
     return;
 
+  WebPointerEvent::Button button = WebPointerProperties::Button::kNoButton;
+  int modifiers = KeyboardEventManager::GetCurrentModifierState() |
+                  WebInputEvent::kRelativeMotionEvent;
+  if (mouse_pressed_) {
+    button = WebPointerProperties::Button::kLeft;
+    modifiers |= WebInputEvent::kLeftButtonDown;
+  }
   WebMouseEvent fake_mouse_move_event(
       WebInputEvent::kMouseMove,
       WebFloatPoint(last_known_mouse_position_.X(),
                     last_known_mouse_position_.Y()),
       WebFloatPoint(last_known_mouse_global_position_.X(),
                     last_known_mouse_global_position_.Y()),
-      WebPointerProperties::Button::kNoButton, 0,
-      KeyboardEventManager::GetCurrentModifierState() |
-          WebInputEvent::Modifiers::kRelativeMotionEvent,
-      TimeTicks::Now().InSeconds());
+      button, 0, modifiers, TimeTicks::Now().InSeconds());
   // TODO(dtapuska): Update m_lastKnowMousePosition to be viewport coordinates.
   fake_mouse_move_event.SetFrameScale(1);
   Vector<WebMouseEvent> coalesced_events;
   frame_->GetEventHandler().HandleMouseMoveEvent(fake_mouse_move_event,
                                                  coalesced_events);
 }
 
 void MouseEventManager::CancelFakeMouseMoveEvent() {
   fake_mouse_move_event_timer_.Stop();
 }
@@ skipping 226 matching lines @@
 FloatPoint MouseEventManager::LastKnownMousePositionGlobal() {
   return last_known_mouse_global_position_;
 }
 
 void MouseEventManager::SetLastKnownMousePosition(const WebMouseEvent& event) {
   is_mouse_position_unknown_ = false;
   last_known_mouse_position_ = event.PositionInRootFrame();
   last_known_mouse_global_position_ = event.PositionInScreen();
 }
 
-void MouseEventManager::DispatchFakeMouseMoveEventSoon() {
-  if (mouse_pressed_)
+void MouseEventManager::DispatchFakeMouseMoveEventSoon(
+    MouseEventManager::FakeMouseMoveReason fake_mouse_move_reason) {
+  if (fake_mouse_move_reason ==
+          MouseEventManager::FakeMouseMoveReason::kDuringScroll &&
+      mouse_pressed_)
     return;
 
+  // TODO(lanwei): When the mouse position is unknown, we do not send the fake
+  // mousemove event for now, so we cannot update the hover states and mouse
+  // cursor. We should keep the last mouse position somewhere in browser.
+  // Please see crbug.com/307375, crbug.com/714378.
   if (is_mouse_position_unknown_)
     return;
 
   // Reschedule the timer, to prevent dispatching mouse move events
   // during a scroll. This avoids a potential source of scroll jank.
-  fake_mouse_move_event_timer_.StartOneShot(kFakeMouseMoveInterval,
-                                            BLINK_FROM_HERE);
+  // Or dispatch a fake mouse move to update hover states when the layout
+  // changes.
+  double interval =
+      fake_mouse_move_reason ==
+              MouseEventManager::FakeMouseMoveReason::kDuringScroll
+          ? kFakeMouseMoveIntervalDuringScroll
+          : kFakeMouseMoveIntervalPerFrame;
+  fake_mouse_move_event_timer_.StartOneShot(interval, BLINK_FROM_HERE);
 }
 
 void MouseEventManager::DispatchFakeMouseMoveEventSoonInQuad(
     const FloatQuad& quad) {
   LocalFrameView* view = frame_->View();
   if (!view)
     return;
 
   if (!quad.ContainsPoint(
           view->RootFrameToContents(last_known_mouse_position_)))
     return;
 
-  DispatchFakeMouseMoveEventSoon();
+  DispatchFakeMouseMoveEventSoon(
+      MouseEventManager::FakeMouseMoveReason::kDuringScroll);
 }
 
 WebInputEventResult MouseEventManager::HandleMousePressEvent(
     const MouseEventWithHitTestResults& event) {
   TRACE_EVENT0("blink", "MouseEventManager::handleMousePressEvent");
 
   ResetDragState();
   CancelFakeMouseMoveEvent();
 
   frame_->GetDocument()->UpdateStyleAndLayoutIgnorePendingStylesheets();
@@ skipping 128 matching lines @@
   //    never sees the mouse release event, which is supposed to reset
   //    m_mousePressed... so m_mousePressed ends up remaining true until the
   //    event handler finally gets another mouse released event. Oops.
   // 2. Dragging doesn't start until after a mouse press event, but a drag
   //    that ends as a result of a mouse release does not send a mouse release
   //    event. As a result, m_mousePressed also ends up remaining true until
   //    the next mouse release event seen by the EventHandler.
   // 3. When pressing Esc key while dragging and the object is outside of the
   //    we get a mouse leave event here
   if (event.Event().button != WebPointerProperties::Button::kLeft ||
-      event.Event().GetType() == WebInputEvent::kMouseLeave)
+      event.Event().GetType() == WebInputEvent::kMouseLeave) {
     mouse_pressed_ = false;
+  }
 
   if (!mouse_pressed_)
     return WebInputEventResult::kNotHandled;
 
   if (event.Event().pointer_type ==
       blink::WebPointerProperties::PointerType::kPen)
     return WebInputEventResult::kNotHandled;
 
   if (HandleDrag(event, DragInitiator::kMouse))
     return WebInputEventResult::kHandledSystem;
@@ skipping 322 matching lines @@
 }
 
 void MouseEventManager::SetClickCount(int click_count) {
   click_count_ = click_count;
 }
 
 bool MouseEventManager::MouseDownMayStartDrag() {
   return mouse_down_may_start_drag_;
 }
 
+bool MouseEventManager::FakeMouseMovePending() const {
+  return fake_mouse_move_event_timer_.IsActive();
+}
+
 }  // namespace blink