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),
+      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 830 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*>(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);
+
+  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());
+  ::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_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();
+  } 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();
+    }
+
+    last_mouse_position_.SetPoint(event.windowX, event.windowY);
+    last_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;
     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);
+}
+