Mouse lock implementation, including the renderer side and the Windows version of the browser side.

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.
 
 // Need a few defines from Win 7 headers for WM_GESTURE and
 // ChangeWindowMessageFilterEx.
 // TODO(jschuh): See crbug.com/92941 for longterm fix.
 #include <windows.h>
 #if(WINVER < 0x0601)
 typedef struct tagCHANGEFILTERSTRUCT {
@@ skipping 225 matching lines @@
       about_to_validate_and_paint_(false),
       close_on_deactivate_(false),
       being_destroyed_(false),
       tooltip_hwnd_(NULL),
       tooltip_showing_(false),
       shutdown_factory_(this),
       parent_hwnd_(NULL),
       is_loading_(false),
       overlay_color_(0),
       text_input_type_(ui::TEXT_INPUT_TYPE_NONE),
-      is_fullscreen_(false) {
+      is_fullscreen_(false),
+      last_x_(0),
+      last_y_(0),
+      last_global_x_(0),
+      last_global_y_(0),
+      ignore_mouse_movement_(true) {
   render_widget_host_->SetView(this);
   registrar_.Add(this,
                  content::NOTIFICATION_RENDERER_PROCESS_TERMINATED,
                  NotificationService::AllSources());
 }
 
 RenderWidgetHostViewWin::~RenderWidgetHostViewWin() {
+  UnlockMouse();
   ResetTooltip();
 }
 
 void RenderWidgetHostViewWin::CreateWnd(HWND parent) {
   Create(parent);  // ATL function to create the window.
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewWin, RenderWidgetHostView implementation:
 
@@ skipping 832 matching lines @@
 
   switch (header->code) {
     case TTN_GETDISPINFO: {
       NMTTDISPINFOW* tooltip_info = reinterpret_cast<NMTTDISPINFOW*>(header);
       tooltip_info->szText[0] = L'\0';
       tooltip_info->lpszText = const_cast<wchar_t*>(tooltip_text_.c_str());
       ::SendMessage(
         tooltip_hwnd_, TTM_SETMAXTIPWIDTH, 0, kTooltipMaxWidthPixels);
       SetMsgHandled(TRUE);
       break;
-                          }
+    }
     case TTN_POP:
       tooltip_showing_ = false;
       SetMsgHandled(TRUE);
       break;
     case TTN_SHOW:
+      // Tooltip shouldn't be shown when the mouse is locked.
+      DCHECK(!mouse_locked_);
       tooltip_showing_ = true;
       SetMsgHandled(TRUE);
       break;
   }
   return 0;
 }
 
 LRESULT RenderWidgetHostViewWin::OnImeSetContext(
     UINT message, WPARAM wparam, LPARAM lparam, BOOL& handled) {
   if (!render_widget_host_)
@@ skipping 100 matching lines @@
   ime_input_.DestroyImeWindow(m_hWnd);
   // Let WTL call ::DefWindowProc() and release its resources.
   handled = FALSE;
   return 0;
 }
 
 LRESULT RenderWidgetHostViewWin::OnMouseEvent(UINT message, WPARAM wparam,
                                               LPARAM lparam, BOOL& handled) {
   handled = TRUE;
 
+  if (message == WM_MOUSELEAVE)
+    ignore_mouse_movement_ = true;
+
+  if (mouse_locked_) {
+    HandleLockedMouseEvent(message, wparam, lparam);
+    MoveCursorToCenter();
+    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;
     SendMessage(tooltip_hwnd_, TTM_RELAYEVENT, NULL,
                 reinterpret_cast<LPARAM>(&msg));
   }
@@ skipping 43 matching lines @@
 
   ForwardMouseEventToRenderer(message, wparam, lparam);
   return 0;
 }
 
 LRESULT RenderWidgetHostViewWin::OnKeyEvent(UINT message, WPARAM wparam,
                                             LPARAM lparam, BOOL& handled) {
   handled = TRUE;
 
   // Force fullscreen windows to close on Escape.
-  if (is_fullscreen_ && (message == WM_KEYDOWN || message == WM_KEYUP) &&
-      wparam == VK_ESCAPE) {
-    SendMessage(WM_CANCELMODE);
-    return 0;
+  if ((message == WM_KEYDOWN || message == WM_KEYUP) && wparam == VK_ESCAPE) {
+    if (mouse_locked_)
+      UnlockMouse();
+    if (is_fullscreen_)
+      SendMessage(WM_CANCELMODE);
+   return 0;
   }
 
   // If we are a pop-up, forward tab related messages to our parent HWND, so
   // that we are dismissed appropriately and so that the focus advance in our
   // parent.
   // TODO(jcampan): http://b/issue?id=1192881 Could be abstracted in the
   //                FocusManager.
   if (close_on_deactivate_ &&
       (((message == WM_KEYDOWN || message == WM_KEYUP) && (wparam == VK_TAB)) ||
         (message == WM_CHAR && wparam == L'\t'))) {
@@ skipping 164 matching lines @@
 void RenderWidgetHostViewWin::OnAccessibilityNotifications(
     const std::vector<ViewHostMsg_AccessibilityNotification_Params>& params) {
   if (!browser_accessibility_manager_.get()) {
     browser_accessibility_manager_.reset(
         BrowserAccessibilityManager::CreateEmptyDocument(
             m_hWnd, static_cast<WebAccessibility::State>(0), this));
   }
   browser_accessibility_manager_->OnAccessibilityNotifications(params);
 }
 
+bool RenderWidgetHostViewWin::LockMouse() {
+  if (mouse_locked_)
+    return true;
+
+  mouse_locked_ = true;
+
+  // Hide the tooltip window if it is currently visible. When the mouse is
+  // 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.
+  ::ShowCursor(FALSE);
+
+  MoveCursorToCenter();
+
+  CRect rect;
+  GetWindowRect(&rect);
+  ::ClipCursor(&rect);

[brettw, 2011/09/14 22:17:58]

Is this the behavior we want? What if the window is very small and I move the
mouse a lot? Can we just do SetCapture instead? Maybe this is the best way, I
just want to be sure.

[scheib, 2011/09/14 22:24:50]

On Linux I found that clipping the cursor was necessary beyond capture. Capture
didn't protect against a button up to button down state change, only a persisted
down.

We should re-evaluate on Windows if we haven't yet. However, I also found on
Linux that windows had to be pretty small to have an impact, e.g. less than
400x400.

[yzshen1, 2011/09/19 20:48:41]

Vincent and I have discussed this issue before.

SetCapture doesn't work for this scenario because it sends out-of-window mouse
messages to the window only when the mouse button was pressed while the mouse
was over the capturing window and the button is still down.

But you are right: if the window is very small and you move the mouse a lot, you
will hit the boundaries. :) Currently, we only plan to allow this feature in
fullscreen mode, so it won't be a big problem for now.

We have considered the idea of using raw mouse input device data (WM_INPUT), in
order to avoid manipulating cursor in such a hacky way. But it comes with
another problem -- we cannot obtain post-ballistics movement easily. If we
finally decide to allow this feature in non-fullscreen mode, we could
re-consider WM_INPUT and emulate the system ballistic algorithms.


On 2011/09/14 22:17:58, brettw wrote:

+
+  return true;
+}
+
+void RenderWidgetHostViewWin::UnlockMouse() {
+  if (!mouse_locked_)
+    return;
+
+  mouse_locked_ = false;
+
+  ::ClipCursor(NULL);
+  ::SetCursorPos(last_global_x_, last_global_y_);
+  ::ShowCursor(TRUE);
+
+  if (render_widget_host_)
+    render_widget_host_->LostMouseLock();
+}
+
 void RenderWidgetHostViewWin::Observe(int type,
                                       const NotificationSource& source,
                                       const NotificationDetails& details) {
   DCHECK(type == content::NOTIFICATION_RENDERER_PROCESS_TERMINATED);
 
   // Get the RenderProcessHost that posted this notification, and exit
   // if it's not the one associated with this host view.
   RenderProcessHost* render_process_host =
       Source<RenderProcessHost>(source).ptr();
   DCHECK(render_process_host);
@@ skipping 300 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.windowX - center.x;
+    event.movementY = event.windowY - center.y;
+    event.x = last_x_;
+    event.y = last_y_;
+    event.windowX = last_x_;
+    event.windowY = last_y_;
+    event.globalX = last_global_x_;
+    event.globalY = last_global_y_;
+  } else {
+    if (ignore_mouse_movement_) {
+      ignore_mouse_movement_ = false;
+      event.movementX = 0;
+      event.movementY = 0;
+    } else {
+      event.movementX = event.globalX - last_global_x_;
+      event.movementY = event.globalY - last_global_y_;
+    }
+
+    last_x_ = event.windowX;
+    last_y_ = event.windowY;
+    last_global_x_ = event.globalX;
+    last_global_y_ = 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;
     case WebInputEvent::MouseLeave:
       TrackMouseLeave(false);
@@ skipping 28 matching lines @@
                                                       DWORD ex_style) {
   parent_hwnd_ = parent_hwnd;
   Create(parent_hwnd_, NULL, NULL, WS_POPUP, ex_style);
   MoveWindow(pos.x(), pos.y(), pos.width(), pos.height(), TRUE);
   // To show tooltip on popup window.(e.g. title in <select>)
   // Popups default to showing, which means |DidBecomeSelected()| isn't invoked.
   // Ensure the tooltip is created otherwise tooltips are never shown.
   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::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)
+      return;
+  }
+
+  ForwardMouseEventToRenderer(message, wparam, lparam);
+}
+