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

content/browser/renderer_host/render_widget_host.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.h"
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/i18n/rtl.h"
@@ skipping 165 matching lines @@
     IPC_MESSAGE_HANDLER(ViewHostMsg_Blur, OnMsgBlur)
     IPC_MESSAGE_HANDLER(ViewHostMsg_SetCursor, OnMsgSetCursor)
     IPC_MESSAGE_HANDLER(ViewHostMsg_ImeUpdateTextInputState,
                         OnMsgImeUpdateTextInputState)
     IPC_MESSAGE_HANDLER(ViewHostMsg_ImeCompositionRangeChanged,
                         OnMsgImeCompositionRangeChanged)
     IPC_MESSAGE_HANDLER(ViewHostMsg_ImeCancelComposition,
                         OnMsgImeCancelComposition)
     IPC_MESSAGE_HANDLER(ViewHostMsg_DidActivateAcceleratedCompositing,
                         OnMsgDidActivateAcceleratedCompositing)
+    IPC_MESSAGE_HANDLER(ViewHostMsg_LockMouse, OnMsgLockMouse)
+    IPC_MESSAGE_HANDLER(ViewHostMsg_UnlockMouse, OnMsgUnlockMouse)
 #if defined(OS_POSIX)
     IPC_MESSAGE_HANDLER(ViewHostMsg_GetScreenInfo, OnMsgGetScreenInfo)
     IPC_MESSAGE_HANDLER(ViewHostMsg_GetWindowRect, OnMsgGetWindowRect)
     IPC_MESSAGE_HANDLER(ViewHostMsg_GetRootWindowRect, OnMsgGetRootWindowRect)
 #endif
 #if defined(OS_MACOSX)
     IPC_MESSAGE_HANDLER(ViewHostMsg_PluginFocusChanged,
                         OnMsgPluginFocusChanged)
     IPC_MESSAGE_HANDLER(ViewHostMsg_StartPluginIme,
                         OnMsgStartPluginIme)
@@ skipping 162 matching lines @@
 
 void RenderWidgetHost::GotFocus() {
   Focus();
 }
 
 void RenderWidgetHost::Focus() {
   Send(new ViewMsg_SetFocus(routing_id_, true));
 }
 
 void RenderWidgetHost::Blur() {
+  if (IsMouseLocked())
+    view_->UnlockMouse();
+
   Send(new ViewMsg_SetFocus(routing_id_, false));
 }
 
 void RenderWidgetHost::LostCapture() {
   Send(new ViewMsg_MouseCaptureLost(routing_id_));
 }
 
+void RenderWidgetHost::LostMouseLock() {
+  Send(new ViewMsg_MouseLockLost(routing_id_));
+}
+
 void RenderWidgetHost::ViewDestroyed() {
+  if (IsMouseLocked())
+    view_->UnlockMouse();
+
   // TODO(evanm): tracking this may no longer be necessary;
   // eliminate this function if so.
   SetView(NULL);
 }
 
 void RenderWidgetHost::SetIsLoading(bool is_loading) {
   is_loading_ = is_loading;
   if (!view_)
     return;
   view_->SetIsLoading(is_loading);
@@ skipping 118 matching lines @@
   TRACE_EVENT0("renderer_host", "RenderWidgetHost::ForwardMouseEvent");
   if (ignore_input_events_ || process_->ignore_input_events())
     return;
 
   // Avoid spamming the renderer with mouse move events.  It is important
   // to note that WM_MOUSEMOVE events are anyways synthetic, but since our
   // thread is able to rapidly consume WM_MOUSEMOVE events, we may get way
   // more WM_MOUSEMOVE events than we wish to send to the renderer.
   if (mouse_event.type == WebInputEvent::MouseMove) {
     if (mouse_move_pending_) {
-      next_mouse_move_.reset(new WebMouseEvent(mouse_event));
+      if (!next_mouse_move_.get()) {
+        next_mouse_move_.reset(new WebMouseEvent(mouse_event));
+      } else {
+        // Accumulate movement deltas.
+        int x = next_mouse_move_->movementX;
+        int y = next_mouse_move_->movementY;
+        *next_mouse_move_ = mouse_event;
+        next_mouse_move_->movementX += x;
+        next_mouse_move_->movementY += y;
+      }
       return;
     }
     mouse_move_pending_ = true;
   } else if (mouse_event.type == WebInputEvent::MouseDown) {
     OnUserGesture();
   }
 
   ForwardInputEvent(mouse_event, sizeof(WebMouseEvent), false);
 }
 
@@ skipping 234 matching lines @@
 
 void RenderWidgetHost::ImeConfirmComposition() {
   Send(new ViewMsg_ImeConfirmComposition(routing_id(), string16()));
 }
 
 void RenderWidgetHost::ImeCancelComposition() {
   Send(new ViewMsg_ImeSetComposition(routing_id(), string16(),
             std::vector<WebKit::WebCompositionUnderline>(), 0, 0));
 }
 
+bool RenderWidgetHost::IsMouseLocked() const {
+  return view_ ? view_->mouse_locked() : false;
+}
+
 void RenderWidgetHost::Destroy() {
   NotificationService::current()->Notify(
       content::NOTIFICATION_RENDER_WIDGET_HOST_DESTROYED,
       Source<RenderWidgetHost>(this),
       NotificationService::NoDetails());
 
   // Tell the view to die.
   // Note that in the process of the view shutting down, it can call a ton
   // of other messages on us.  So if you do any other deinitialization here,
   // do it after this call to view_->Destroy().
@@ skipping 325 matching lines @@
     view_->GpuRenderingStateDidChange();
 #elif defined(OS_WIN)
   if (view_)
     view_->ShowCompositorHostWindow(is_accelerated_compositing_active_);
 #elif defined(TOOLKIT_USES_GTK)
   if (view_)
     view_->AcceleratedCompositingActivated(activated);
 #endif
 }
 
+void RenderWidgetHost::OnMsgLockMouse() {
+  // TODO(yzshen): Only allow to lock the mouse when in fullscreen mode, and
+  // make sure that the mouse is unlocked when leaving fullscreen mode.
+  if (!view_ || !view_->HasFocus() || !view_->LockMouse()) {
+    Send(new ViewMsg_LockMouse_ACK(routing_id_, false));
+  } else {
+    Send(new ViewMsg_LockMouse_ACK(routing_id_, true));
+  }
+}
+
+void RenderWidgetHost::OnMsgUnlockMouse() {
+  if (IsMouseLocked())
+    view_->UnlockMouse();
+}
+
 #if defined(OS_POSIX)
 void RenderWidgetHost::OnMsgGetScreenInfo(gfx::NativeViewId window_id,
                                           WebKit::WebScreenInfo* results) {
   if (view_)
     view_->GetScreenInfo(results);
   else
     RenderWidgetHostView::GetDefaultScreenInfo(results);
 }
 
 void RenderWidgetHost::OnMsgGetWindowRect(gfx::NativeViewId window_id,
@@ skipping 121 matching lines @@
     view_->CreatePluginContainer(deferred_plugin_handles_[i]);
 #endif
   }
 
   deferred_plugin_handles_.clear();
 }
 
 void RenderWidgetHost::StartUserGesture() {
   OnUserGesture();
 }