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, we need to prevent the (invisible) cursor from hitting
+// the border of the view, in order to get valid movement information. However,
+// forcing the cursor back to the center of the view after each mouse move
+// doesn't work well. It reduces the frequency of useful WM_MOUSEMOVE messages
+// significantly. Therefore, we move the cursor to the center of the view only
+// 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
+// any owned popup 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 1294 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();
+  move_to_center_request_.pending = false;
+  last_mouse_position_.locked_global = last_mouse_position_.unlocked_global;
+  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_mouse_position_.unlocked_global.x(),
+                 last_mouse_position_.unlocked_global.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_mouse_position_.locked_global.x();
+    event.movementY = event.globalY - last_mouse_position_.locked_global.y();
+    last_mouse_position_.locked_global.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_mouse_position_.unlocked.x();
+    event.y = last_mouse_position_.unlocked.y();
+    event.windowX = last_mouse_position_.unlocked.x();
+    event.windowY = last_mouse_position_.unlocked.y();
+    event.globalX = last_mouse_position_.unlocked_global.x();
+    event.globalY = last_mouse_position_.unlocked_global.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_mouse_position_.unlocked_global.x();
+      event.movementY =
+          event.globalY - last_mouse_position_.unlocked_global.y();
     }
 
-    last_mouse_position_.SetPoint(event.windowX, event.windowY);
-    last_global_mouse_position_.SetPoint(event.globalX, event.globalY);
+    last_mouse_position_.unlocked.SetPoint(event.windowX, event.windowY);
+    last_mouse_position_.unlocked_global.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_mouse_position_.locked_global.x() < rect.left + border_x ||
+      last_mouse_position_.locked_global.x() > rect.right - border_x ||
+      last_mouse_position_.locked_global.y() < rect.top + border_y ||
+      last_mouse_position_.locked_global.y() > rect.bottom - border_y;
+
+  if (should_move) {
+    move_to_center_request_.pending = true;
+    move_to_center_request_.target = rect.CenterPoint();
+    if (!::SetCursorPos(move_to_center_request_.target.x(),
+                        move_to_center_request_.target.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) {
-    CPoint center = GetClientCenter();
-    // Ignore WM_MOUSEMOVE messages generated by MoveCursorToCenter().
-    if (LOWORD(lparam) == center.x && HIWORD(lparam) == center.y)
+  if (message == WM_MOUSEMOVE && move_to_center_request_.pending) {
+    // Ignore WM_MOUSEMOVE messages generated by
+    // MoveCursorToCenterIfNecessary().
+    CPoint current_position(LOWORD(lparam), HIWORD(lparam));
+    ClientToScreen(&current_position);
+    if (move_to_center_request_.target.x() == current_position.x &&
+        move_to_center_request_.target.y() == current_position.y) {
+      move_to_center_request_.pending = false;
+      last_mouse_position_.locked_global = move_to_center_request_.target;
       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);
 }