Implement pointer lock API for out-of-process iframes.

content/renderer/render_widget.cc

 // Copyright (c) 2012 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/renderer/render_widget.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/auto_reset.h"
@@ skipping 122 matching lines @@
 using blink::WebWidget;
 
 #define STATIC_ASSERT_ENUM(a, b)                            \
   static_assert(static_cast<int>(a) == static_cast<int>(b), \
                 "mismatching enums: " #a)
 
 namespace {
 
 typedef std::map<std::string, ui::TextInputMode> TextInputModeMap;
 
+class WebWidgetLockTarget : public content::MouseLockDispatcher::LockTarget {
+ public:
+  explicit WebWidgetLockTarget(blink::WebWidget* webwidget)
+      : webwidget_(webwidget) {}
+
+  void OnLockMouseACK(bool succeeded) override {
+    if (succeeded)
+      webwidget_->didAcquirePointerLock();
+    else
+      webwidget_->didNotAcquirePointerLock();
+  }
+
+  void OnMouseLockLost() override { webwidget_->didLosePointerLock(); }
+
+  bool HandleMouseLockedInputEvent(const blink::WebMouseEvent& event) override {
+    // The WebWidget handles mouse lock in WebKit's handleInputEvent().
+    return false;
+  }
+
+ private:
+  blink::WebWidget* webwidget_;
+};
+
 class TextInputModeMapSingleton {
  public:
   static TextInputModeMapSingleton* GetInstance() {
     return base::Singleton<TextInputModeMapSingleton>::get();
   }
   TextInputModeMapSingleton() {
     map_["verbatim"] = ui::TEXT_INPUT_MODE_VERBATIM;
     map_["latin"] = ui::TEXT_INPUT_MODE_LATIN;
     map_["latin-name"] = ui::TEXT_INPUT_MODE_LATIN_NAME;
     map_["latin-prose"] = ui::TEXT_INPUT_MODE_LATIN_PROSE;
@@ skipping 87 matching lines @@
       screen_info_(screen_info),
       device_scale_factor_(screen_info_.deviceScaleFactor),
       next_output_surface_id_(0),
 #if defined(OS_ANDROID)
       text_field_is_dirty_(false),
 #endif
       popup_origin_scale_for_emulation_(0.f),
       frame_swap_message_queue_(new FrameSwapMessageQueue()),
       resizing_mode_selector_(new ResizingModeSelector()),
       has_host_context_menu_location_(false),
+      mouse_lock_dispatcher_(nullptr),
       has_focus_(false) {
   if (!swapped_out)
     RenderProcess::current()->AddRefProcess();
   DCHECK(RenderThread::Get());
   device_color_profile_.push_back('0');
 #if defined(OS_ANDROID)
   text_input_info_history_.push_back(blink::WebTextInputInfo());
 #endif
 
   // In tests there may not be a RenderThreadImpl.
@@ skipping 46 matching lines @@
   }
   scoped_refptr<RenderWidget> widget(
       new RenderWidget(compositor_deps, blink::WebPopupTypeNone, screen_info,
                        false, hidden, false));
   widget->SetRoutingID(routing_id);
   widget->for_oopif_ = true;
   // DoInit increments the reference count on |widget|, keeping it alive after
   // this function returns.
   if (widget->DoInit(MSG_ROUTING_NONE,
                      RenderWidget::CreateWebFrameWidget(widget.get(), frame),
-                     nullptr)) {
+                     nullptr, true)) {
     return widget.get();
   }
   return nullptr;
 }
 
 // static
 blink::WebFrameWidget* RenderWidget::CreateWebFrameWidget(
     RenderWidget* render_widget,
     blink::WebLocalFrame* frame) {
   if (!frame->parent()) {
@@ skipping 23 matching lines @@
 
 void RenderWidget::SetRoutingID(int32_t routing_id) {
   routing_id_ = routing_id;
   input_handler_.reset(new RenderWidgetInputHandler(
       GetRenderWidgetInputHandlerDelegate(this), this));
 }
 
 bool RenderWidget::Init(int32_t opener_id) {
   bool success = DoInit(
       opener_id, RenderWidget::CreateWebWidget(this),
-      new ViewHostMsg_CreateWidget(opener_id, popup_type_, &routing_id_));
+      new ViewHostMsg_CreateWidget(opener_id, popup_type_, &routing_id_), true);
   if (success) {
     SetRoutingID(routing_id_);
     return true;
   }
   return false;
 }
 
 bool RenderWidget::DoInit(int32_t opener_id,
                           WebWidget* web_widget,
-                          IPC::SyncMessage* create_widget_message) {
+                          IPC::SyncMessage* create_widget_message,
+                          bool should_add_route) {
   DCHECK(!webwidget_);
 
   if (opener_id != MSG_ROUTING_NONE)
     opener_id_ = opener_id;
 
   webwidget_ = web_widget;
+  webwidget_mouse_lock_target_.reset(new WebWidgetLockTarget(webwidget_));
+  mouse_lock_dispatcher_ =
+      base::WrapUnique(new RenderWidgetMouseLockDispatcher(this));
 
   bool result = true;
   if (create_widget_message)
     result = RenderThread::Get()->Send(create_widget_message);
 
+  if (!should_add_route)
+    return true;
+
   if (result) {
     RenderThread::Get()->AddRoute(routing_id_, this);
     // Take a reference on behalf of the RenderThread.  This will be balanced
     // when we receive ViewMsg_Close.
     AddRef();
     if (RenderThreadImpl::current()) {
       RenderThreadImpl::current()->WidgetCreated();
       if (is_hidden_)
         RenderThreadImpl::current()->WidgetHidden();
     }
@@ skipping 51 matching lines @@
       emulator->scale(), emulator->offset());
 }
 #endif
 
 void RenderWidget::OnShowHostContextMenu(ContextMenuParams* params) {
   if (screen_metrics_emulator_)
     screen_metrics_emulator_->OnShowContextMenu(params);
 }
 
 bool RenderWidget::OnMessageReceived(const IPC::Message& message) {
+  if (mouse_lock_dispatcher_ &&
+      mouse_lock_dispatcher_->OnMessageReceived(message))
+    return true;
+
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(RenderWidget, message)
     IPC_MESSAGE_HANDLER(InputMsg_HandleInputEvent, OnHandleInputEvent)
     IPC_MESSAGE_HANDLER(InputMsg_CursorVisibilityChange,
                         OnCursorVisibilityChange)
     IPC_MESSAGE_HANDLER(InputMsg_ImeSetComposition, OnImeSetComposition)
     IPC_MESSAGE_HANDLER(InputMsg_ImeConfirmComposition, OnImeConfirmComposition)
     IPC_MESSAGE_HANDLER(InputMsg_MouseCaptureLost, OnMouseCaptureLost)
     IPC_MESSAGE_HANDLER(InputMsg_SetFocus, OnSetFocus)
     IPC_MESSAGE_HANDLER(InputMsg_SyntheticGestureCompleted,
@@ skipping 1620 matching lines @@
                MESSAGE_DELIVERY_POLICY_WITH_VISUAL_STATE);
 }
 
 float RenderWidget::GetOriginalDeviceScaleFactor() const {
   return
       screen_metrics_emulator_ ?
       screen_metrics_emulator_->original_screen_info().deviceScaleFactor :
       device_scale_factor_;
 }
 
+bool RenderWidget::requestPointerLock() {
+  return mouse_lock_dispatcher_->LockMouse(webwidget_mouse_lock_target_.get());
+}
+
+void RenderWidget::requestPointerUnlock() {
+  mouse_lock_dispatcher_->UnlockMouse(webwidget_mouse_lock_target_.get());
+}
+
+bool RenderWidget::isPointerLocked() {
+  return mouse_lock_dispatcher_->IsMouseLockedTo(
+      webwidget_mouse_lock_target_.get());
+}
+
 }  // namespace content