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

content/renderer/pepper_plugin_delegate_impl.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/renderer/pepper_plugin_delegate_impl.h"
 
 #include <cmath>
 #include <queue>
 
 #include "base/bind.h"
@@ skipping 34 matching lines @@
 #include "content/renderer/webplugin_delegate_proxy.h"
 #include "ipc/ipc_channel_handle.h"
 #include "media/video/capture/video_capture_proxy.h"
 #include "ppapi/c/dev/pp_video_dev.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/private/ppb_flash.h"
 #include "ppapi/c/private/ppb_flash_net_connector.h"
 #include "ppapi/proxy/host_dispatcher.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/shared_impl/ppapi_preferences.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebCursorInfo.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFileChooserCompletion.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFileChooserParams.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebInputEvent.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebPluginContainer.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebScreenInfo.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
 #include "ui/gfx/size.h"
 #include "ui/gfx/surface/transport_dib.h"
 #include "webkit/fileapi/file_system_callback_dispatcher.h"
 #include "webkit/glue/context_menu.h"
 #include "webkit/plugins/npapi/webplugin.h"
 #include "webkit/plugins/ppapi/file_path.h"
 #include "webkit/plugins/ppapi/ppb_file_io_impl.h"
@@ skipping 589 matching lines @@
   // saved pipe handle.
   // Temporarily, just call back.
   client->BrokerConnected(PlatformFileToInt(plugin_handle), result);
 }
 
 PepperPluginDelegateImpl::PepperPluginDelegateImpl(RenderView* render_view)
     : render_view_(render_view),
       has_saved_context_menu_action_(false),
       saved_context_menu_action_(0),
       id_generator_(0),
-      is_pepper_plugin_focused_(false) {
+      is_pepper_plugin_focused_(false),
+      mouse_lock_owner_(NULL),
+      mouse_locked_(false),
+      pending_lock_request_(false),
+      pending_unlock_request_(false) {
 }
 
 PepperPluginDelegateImpl::~PepperPluginDelegateImpl() {
+  DCHECK(!mouse_lock_owner_);
 }
 
 scoped_refptr<webkit::ppapi::PluginModule>
 PepperPluginDelegateImpl::CreatePepperPluginModule(
     const webkit::WebPluginInfo& webplugin_info,
     bool* pepper_plugin_was_registered) {
   *pepper_plugin_was_registered = true;
 
   // See if a module has already been loaded for this plugin.
   FilePath path(webplugin_info.path);
@@ skipping 164 matching lines @@
 void PepperPluginDelegateImpl::PluginFocusChanged(bool focused) {
   is_pepper_plugin_focused_ = focused;
   if (render_view_)
     render_view_->PpapiPluginFocusChanged();
 }
 
 void PepperPluginDelegateImpl::PluginCrashed(
     webkit::ppapi::PluginInstance* instance) {
   subscribed_to_policy_updates_.erase(instance);
   render_view_->PluginCrashed(instance->module()->path());
+
+  UnlockMouse(instance);
 }
 
 void PepperPluginDelegateImpl::InstanceCreated(
     webkit::ppapi::PluginInstance* instance) {
   active_instances_.insert(instance);
 
   // Set the initial focus.
   instance->SetContentAreaFocus(render_view_->has_focus());
 }
 
 void PepperPluginDelegateImpl::InstanceDeleted(
     webkit::ppapi::PluginInstance* instance) {
   active_instances_.erase(instance);
   subscribed_to_policy_updates_.erase(instance);
+
+  if (mouse_lock_owner_ && mouse_lock_owner_ == instance) {
+    // UnlockMouse() will determine whether a ViewHostMsg_UnlockMouse needs to
+    // be sent, and set internal state properly. We only need to forget about
+    // the current |mouse_lock_owner_|.
+    UnlockMouse(mouse_lock_owner_);
+    mouse_lock_owner_ = NULL;
+  }
 }
 
 SkBitmap* PepperPluginDelegateImpl::GetSadPluginBitmap() {
   return content::GetContentClient()->renderer()->GetSadPluginBitmap();
 }
 
 webkit::ppapi::PluginDelegate::PlatformImage2D*
 PepperPluginDelegateImpl::CreateImage2D(int width, int height) {
   uint32 buffer_size = width * height * 4;
 
@@ skipping 142 matching lines @@
   messages_waiting_replies_.Remove(message_id);
   callback->Run(error_code, base::PassPlatformFile(&file));
   // Make sure we won't leak file handle if the requester has died.
   if (file != base::kInvalidPlatformFileValue)
     base::FileUtilProxy::Close(GetFileThreadMessageLoopProxy(), file, NULL);
   delete callback;
 }
 
 void PepperPluginDelegateImpl::OnSetFocus(bool has_focus) {
   for (std::set<webkit::ppapi::PluginInstance*>::iterator i =
-         active_instances_.begin();
+           active_instances_.begin();
        i != active_instances_.end(); ++i)
     (*i)->SetContentAreaFocus(has_focus);
 }
 
 bool PepperPluginDelegateImpl::IsPluginFocused() const {
   return is_pepper_plugin_focused_;
 }
 
+void PepperPluginDelegateImpl::OnLockMouseACK(bool succeeded) {
+  DCHECK(!mouse_locked_ && pending_lock_request_);
+
+  mouse_locked_ = succeeded;
+  pending_lock_request_ = false;
+  if (pending_unlock_request_ && !succeeded) {
+    // We have sent an unlock request after the lock request. However, since
+    // the lock request has failed, the unlock request will be ignored by the
+    // browser side and there won't be any response to it.
+    pending_unlock_request_ = false;
+  }
+  // If the PluginInstance has been deleted, |mouse_lock_owner_| can be NULL.
+  if (mouse_lock_owner_) {
+    webkit::ppapi::PluginInstance* last_mouse_lock_owner = mouse_lock_owner_;
+    if (!succeeded) {
+      // Reset |mouse_lock_owner_| to NULL before calling OnLockMouseACK(), so
+      // that if OnLockMouseACK() results in calls to any mouse lock method
+      // (e.g., LockMouse()), the method will see consistent internal state.
+      mouse_lock_owner_ = NULL;
+    }
+
+    last_mouse_lock_owner->OnLockMouseACK(succeeded ? PP_OK : PP_ERROR_FAILED);
+  }
+}
+
+void PepperPluginDelegateImpl::OnMouseLockLost() {
+  DCHECK(mouse_locked_ && !pending_lock_request_);
+
+  mouse_locked_ = false;
+  pending_unlock_request_ = false;
+  // If the PluginInstance has been deleted, |mouse_lock_owner_| can be NULL.
+  if (mouse_lock_owner_) {
+    // Reset |mouse_lock_owner_| to NULL before calling OnMouseLockLost(), so
+    // that if OnMouseLockLost() results in calls to any mouse lock method
+    // (e.g., LockMouse()), the method will see consistent internal state.
+    webkit::ppapi::PluginInstance* last_mouse_lock_owner = mouse_lock_owner_;
+    mouse_lock_owner_ = NULL;
+
+    last_mouse_lock_owner->OnMouseLockLost();
+  }
+}
+
+bool PepperPluginDelegateImpl::DispatchLockedMouseEvent(
+    const WebKit::WebMouseEvent& event) {
+  if (mouse_locked_) {
+    if (mouse_lock_owner_) {
+      // |cursor_info| is ignored since it is hidden when the mouse is locked.
+      WebKit::WebCursorInfo cursor_info;
+      mouse_lock_owner_->HandleInputEvent(event, &cursor_info);
+    }
+
+    // If the mouse is locked, only the current owner of the mouse lock can
+    // process mouse events.
+    return true;
+  }
+  return false;
+}
+
 bool PepperPluginDelegateImpl::OpenFileSystem(
     const GURL& url,
     fileapi::FileSystemType type,
     long long size,
     fileapi::FileSystemCallbackDispatcher* dispatcher) {
   FileSystemDispatcher* file_system_dispatcher =
       ChildThread::current()->file_system_dispatcher();
   return file_system_dispatcher->OpenFileSystem(
       url.GetWithEmptyPath(), type, size, true /* create */, dispatcher);
 }
@@ skipping 434 matching lines @@
     DLOG(WARNING) << "Browser failed to allocate shared memory";
     return NULL;
   }
   return new base::SharedMemory(handle, false);
 }
 
 ppapi::Preferences PepperPluginDelegateImpl::GetPreferences() {
   return ppapi::Preferences(render_view_->webkit_preferences());
 }
 
+void PepperPluginDelegateImpl::LockMouse(
+    webkit::ppapi::PluginInstance* instance) {
+  DCHECK(instance);
+  if (!MouseLockedOrPending()) {
+    DCHECK(!mouse_lock_owner_);
+    pending_lock_request_ = true;
+    mouse_lock_owner_ = instance;
+
+    render_view_->Send(
+        new ViewHostMsg_LockMouse(render_view_->routing_id()));
+  } else if (instance != mouse_lock_owner_) {
+    // Another plugin instance is using mouse lock. Fail immediately.
+    instance->OnLockMouseACK(PP_ERROR_FAILED);
+  } else {
+    if (mouse_locked_) {
+      instance->OnLockMouseACK(PP_OK);
+    } else if (pending_lock_request_) {
+      instance->OnLockMouseACK(PP_ERROR_INPROGRESS);
+    } else {
+      // The only case left here is
+      // !mouse_locked_ && !pending_lock_request_ && pending_unlock_request_,
+      // which is not possible.
+      NOTREACHED();
+      instance->OnLockMouseACK(PP_ERROR_FAILED);
+    }
+  }
+}
+
+void PepperPluginDelegateImpl::UnlockMouse(
+    webkit::ppapi::PluginInstance* instance) {
+  DCHECK(instance);
+
+  // If no one is using mouse lock or the user is not |instance|, ignore
+  // the unlock request.
+  if (MouseLockedOrPending() && mouse_lock_owner_ == instance) {
+    if (mouse_locked_ || pending_lock_request_) {
+      DCHECK(!mouse_locked_ || !pending_lock_request_);
+      if (!pending_unlock_request_) {
+        pending_unlock_request_ = true;
+
+        render_view_->Send(
+            new ViewHostMsg_UnlockMouse(render_view_->routing_id()));
+      }
+    } else {
+      // The only case left here is
+      // !mouse_locked_ && !pending_lock_request_ && pending_unlock_request_,
+      // which is not possible.
+      NOTREACHED();
+    }
+  }
+}
+
 int PepperPluginDelegateImpl::GetRoutingId() const {
   return render_view_->routing_id();
 }
 
 void PepperPluginDelegateImpl::PublishInitialPolicy(
     scoped_refptr<webkit::ppapi::PluginInstance> instance,
     const std::string& policy) {
   instance->HandlePolicyUpdate(policy);
 }