Fix mouse lock perf issue on Windows.

content/browser/renderer_host/render_widget_host_view_win.cc

 // Copyright (c) 2011 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 "content/browser/renderer_host/render_widget_host_view_win.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 70 matching lines @@
 const int kMaxTooltipLength = 1024;
 
 // A custom MSAA object id used to determine if a screen reader is actively
 // listening for MSAA events.
 const int kIdCustom = 1;
 
 // The delay before the compositor host window is destroyed. This gives the GPU
 // process a grace period to stop referencing it.
 const int kDestroyCompositorHostWindowDelay = 10000;
 
+// In mouse lock mode, the cursor needs to be moved to the center of the view if
+// it approaches the border. |kMouseLockBorderPercentage| specifies the width of
+// the border area, in percentage of the corresponding dimension.
+const int kMouseLockBorderPercentage = 15;
+
 // A callback function for EnumThreadWindows to enumerate and dismiss
 // any owned popop windows
 BOOL CALLBACK DismissOwnedPopups(HWND window, LPARAM arg) {
   const HWND toplevel_hwnd = reinterpret_cast<HWND>(arg);
 
   if (::IsWindowVisible(window)) {
     const HWND owner = ::GetWindow(window, GW_OWNER);
     if (toplevel_hwnd == owner) {
       ::PostMessage(window, WM_CANCELMODE, 0, 0);
     }
@@ skipping 226 matching lines @@
       close_on_deactivate_(false),
       being_destroyed_(false),
       tooltip_hwnd_(NULL),
       tooltip_showing_(false),
       weak_factory_(this),
       parent_hwnd_(NULL),
       is_loading_(false),
       overlay_color_(0),
       text_input_type_(ui::TEXT_INPUT_TYPE_NONE),
       is_fullscreen_(false),
+      ignore_move_to_center_message_(false),
       ignore_mouse_movement_(true),
       composition_range_(ui::Range::InvalidRange()),
       ignore_next_lbutton_message_at_same_location(false),
       last_pointer_down_location_(0),
       touch_state_(this) {
   render_widget_host_->SetView(this);
   registrar_.Add(this,
                  content::NOTIFICATION_RENDERER_PROCESS_TERMINATED,
                  content::NotificationService::AllBrowserContextsAndSources());
 }
@@ skipping 1050 matching lines @@
     last_pointer_down_location_ = 0;
     if (last_location == lparam)
       return 0;
   }
 
   if (message == WM_MOUSELEAVE)
     ignore_mouse_movement_ = true;
 
   if (mouse_locked_) {
     HandleLockedMouseEvent(message, wparam, lparam);
-    MoveCursorToCenter();
+    MoveCursorToCenterIfNecessary();
     return 0;
   }
 
   if (::IsWindow(tooltip_hwnd_)) {
     // Forward mouse events through to the tooltip window
     MSG msg;
     msg.hwnd = m_hWnd;
     msg.message = message;
     msg.wParam = wparam;
     msg.lParam = lparam;
@@ skipping 467 matching lines @@
   // locked, no mouse message is relayed to the tooltip window, so we don't need
   // to worry that it will reappear.
   if (::IsWindow(tooltip_hwnd_) && tooltip_showing_) {
     ::SendMessage(tooltip_hwnd_, TTM_POP, 0, 0);
     // Sending a TTM_POP message doesn't seem to actually hide the tooltip
     // window, although we will receive a TTN_POP notification. As a result,
     // ShowWindow() is explicitly called to hide the window.
     ::ShowWindow(tooltip_hwnd_, SW_HIDE);
   }
 
-  // TODO(yzshen): Show an invisible cursor instead of using
-  // ::ShowCursor(FALSE), so that MoveCursorToCenter() works with Remote
-  // Desktop.
+  // TODO(yzshen): ShowCursor(FALSE) causes SetCursorPos() to be ignored on
+  // Remote Desktop.
   ::ShowCursor(FALSE);
 
-  MoveCursorToCenter();
+  last_locked_global_mouse_position_ = last_unlocked_global_mouse_position_;
+  MoveCursorToCenterIfNecessary();
 
   CRect rect;
   GetWindowRect(&rect);
   ::ClipCursor(&rect);
 
   return true;
 }
 
 void RenderWidgetHostViewWin::UnlockMouse() {
   if (!mouse_locked_)
     return;
 
   mouse_locked_ = false;
 
   ::ClipCursor(NULL);
-  ::SetCursorPos(last_global_mouse_position_.x(),
-                 last_global_mouse_position_.y());
+  ::SetCursorPos(last_unlocked_global_mouse_position_.x(),
+                 last_unlocked_global_mouse_position_.y());
   ::ShowCursor(TRUE);
 
   if (render_widget_host_)
     render_widget_host_->LostMouseLock();
 }
 
 void RenderWidgetHostViewWin::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
@@ skipping 361 matching lines @@
 void RenderWidgetHostViewWin::ForwardMouseEventToRenderer(UINT message,
                                                           WPARAM wparam,
                                                           LPARAM lparam) {
   if (!render_widget_host_)
     return;
 
   WebMouseEvent event(
       WebInputEventFactory::mouseEvent(m_hWnd, message, wparam, lparam));
 
   if (mouse_locked_) {
-    CPoint center = GetClientCenter();
+    event.movementX = event.globalX - last_locked_global_mouse_position_.x();
+    event.movementY = event.globalY - last_locked_global_mouse_position_.y();
+    last_locked_global_mouse_position_.SetPoint(event.globalX, event.globalY);
 
-    event.movementX = event.windowX - center.x;
-    event.movementY = event.windowY - center.y;
-    event.x = last_mouse_position_.x();
-    event.y = last_mouse_position_.y();
-    event.windowX = last_mouse_position_.x();
-    event.windowY = last_mouse_position_.y();
-    event.globalX = last_global_mouse_position_.x();
-    event.globalY = last_global_mouse_position_.y();
+    event.x = last_unlocked_mouse_position_.x();
+    event.y = last_unlocked_mouse_position_.y();
+    event.windowX = last_unlocked_mouse_position_.x();
+    event.windowY = last_unlocked_mouse_position_.y();
+    event.globalX = last_unlocked_global_mouse_position_.x();
+    event.globalY = last_unlocked_global_mouse_position_.y();
   } else {
     if (ignore_mouse_movement_) {
       ignore_mouse_movement_ = false;
       event.movementX = 0;
       event.movementY = 0;
     } else {
-      event.movementX = event.globalX - last_global_mouse_position_.x();
-      event.movementY = event.globalY - last_global_mouse_position_.y();
+      event.movementX =
+          event.globalX - last_unlocked_global_mouse_position_.x();
+      event.movementY =
+          event.globalY - last_unlocked_global_mouse_position_.y();
     }
 
-    last_mouse_position_.SetPoint(event.windowX, event.windowY);
-    last_global_mouse_position_.SetPoint(event.globalX, event.globalY);
+    last_unlocked_mouse_position_.SetPoint(event.windowX, event.windowY);
+    last_unlocked_global_mouse_position_.SetPoint(event.globalX, event.globalY);
   }
 
   // Send the event to the renderer before changing mouse capture, so that the
   // capturelost event arrives after mouseup.
   render_widget_host_->ForwardMouseEvent(event);
 
   switch (event.type) {
     case WebInputEvent::MouseMove:
       TrackMouseLeave(true);
       break;
@@ skipping 37 matching lines @@
   EnsureTooltip();
   ShowWindow(IsActivatable() ? SW_SHOW : SW_SHOWNA);
 }
 
 CPoint RenderWidgetHostViewWin::GetClientCenter() const {
   CRect rect;
   GetClientRect(&rect);
   return rect.CenterPoint();
 }
 
-void RenderWidgetHostViewWin::MoveCursorToCenter() const {
-  CPoint center = GetClientCenter();
-  ClientToScreen(&center);
-  if (!::SetCursorPos(center.x, center.y))
-    LOG_GETLASTERROR(WARNING) << "Failed to set cursor position.";
+void RenderWidgetHostViewWin::MoveCursorToCenterIfNecessary() {
+  DCHECK(mouse_locked_);
+
+  CRect rect;
+  GetWindowRect(&rect);
+  int border_x = rect.Width() * kMouseLockBorderPercentage / 100;
+  int border_y = rect.Height() * kMouseLockBorderPercentage / 100;
+
+  bool should_move =
+      last_locked_global_mouse_position_.x() < rect.left + border_x ||
+      last_locked_global_mouse_position_.x() > rect.right - border_x ||
+      last_locked_global_mouse_position_.y() < rect.top + border_y ||
+      last_locked_global_mouse_position_.y() > rect.bottom - border_y;
+
+  if (should_move) {
+    ignore_move_to_center_message_ = true;
+    CPoint center = rect.CenterPoint();
+    if (!::SetCursorPos(center.x, center.y))
+      LOG_GETLASTERROR(WARNING) << "Failed to set cursor position.";
+  }
 }
 
 void RenderWidgetHostViewWin::HandleLockedMouseEvent(UINT message,
                                                      WPARAM wparam,
                                                      LPARAM lparam) {
   DCHECK(mouse_locked_);
 
-  if (message == WM_MOUSEMOVE) {
+  if (message == WM_MOUSEMOVE && ignore_move_to_center_message_) {
     CPoint center = GetClientCenter();
-    // Ignore WM_MOUSEMOVE messages generated by MoveCursorToCenter().
-    if (LOWORD(lparam) == center.x && HIWORD(lparam) == center.y)
+    // Ignore WM_MOUSEMOVE messages generated by
+    // MoveCursorToCenterIfNecessary().
+    if (LOWORD(lparam) == center.x && HIWORD(lparam) == center.y) {

[scheib, 2011/12/03 04:13:01]

Perhaps I'm being paranoid, but: consider caching the target point of the mouse
move and using that as an exit condition of ignoring mouse movements.
Daydreaming the scenario: If the window rect moves we'd be stuck. In the future
if we take out full screen requirement and JS is moving a window around while
mouse lock is active...

[yzshen1, 2011/12/05 01:16:42]

I have also considered this scenario. But it won't get stuck: we don't discard
*every* message when |ignore_move_to_center_message_| is true; instead, we only
discard one mouse move message.

If the window is moved between MoveCursorToCenterIfNecessary() and receiving the
corresponding mouse move message, what will happen is:
1) the move-to-center message is used to compute mouse movement value, and may
result in a spike.
2) |ignore_move_to_center_message_| is not changed to false, so in the future,
it may absorb a 'normal' mouse move message, which happens to be at the center
of the view.

I think it is rare, and not a big deal. But your approach seems better. I have
made the change. Thanks!

+      ignore_move_to_center_message_ = false;
+      ClientToScreen(&center);
+      last_locked_global_mouse_position_.SetPoint(center.x, center.y);
       return;
+    }
   }
 
   ForwardMouseEventToRenderer(message, wparam, lparam);
 }
 
 LRESULT RenderWidgetHostViewWin::OnDocumentFeed(RECONVERTSTRING* reconv) {
   size_t target_offset;
   size_t target_length;
   bool has_composition;
   if (!composition_range_.is_empty()) {
@@ skipping 75 matching lines @@
 
   size_t offset = selection_range_.GetMin() - selection_text_offset_;
   memcpy(reinterpret_cast<char*>(reconv) + sizeof(RECONVERTSTRING),
          selection_text_.c_str() + offset, len * sizeof(WCHAR));
 
   // According to Microsft API document, IMR_RECONVERTSTRING and
   // IMR_DOCUMENTFEED should return reconv, but some applications return
   // need_size.
   return reinterpret_cast<LRESULT>(reconv);
 }