refactoring mouse lock to support pepper and WebKit

webkit/plugins/ppapi/ppapi_plugin_instance.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 "webkit/plugins/ppapi/ppapi_plugin_instance.h"
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/linked_ptr.h"
@@ skipping 286 matching lines @@
       desired_fullscreen_state_(false),
       fullscreen_(false),
       message_channel_(NULL),
       sad_plugin_(NULL),
       input_event_mask_(0),
       filtered_input_event_mask_(0),
       text_input_type_(kPluginDefaultTextInputType),
       text_input_caret_(0, 0, 0, 0),
       text_input_caret_bounds_(0, 0, 0, 0),
       text_input_caret_set_(false),
+      mouse_locked_to_this_instance_(false),
       lock_mouse_callback_(PP_BlockUntilComplete()) {
   pp_instance_ = HostGlobals::Get()->AddInstance(this);
 
   memset(&current_print_settings_, 0, sizeof(current_print_settings_));
   DCHECK(delegate);
   module_->InstanceCreated(this);
   delegate_->InstanceCreated(this);
   message_channel_.reset(new MessageChannel(this));
 }
 
 PluginInstance::~PluginInstance() {
   DCHECK(!fullscreen_container_);
 
   // Free all the plugin objects. This will automatically clear the back-
   // pointer from the NPObject so WebKit can't call into the plugin any more.
   //
   // Swap out the set so we can delete from it (the objects will try to
   // unregister themselves inside the delete call).
   PluginObjectSet plugin_object_copy;
   live_plugin_objects_.swap(plugin_object_copy);
   for (PluginObjectSet::iterator i = plugin_object_copy.begin();
        i != plugin_object_copy.end(); ++i)
     delete *i;
 
-  if (lock_mouse_callback_.func)
+  if (lock_mouse_callback_.func) {
+    mouse_locked_to_this_instance_ = false;
     PP_RunAndClearCompletionCallback(&lock_mouse_callback_, PP_ERROR_ABORTED);
+  }
 
   delegate_->InstanceDeleted(this);
   module_->InstanceDeleted(this);
 
   HostGlobals::Get()->InstanceDeleted(pp_instance_);
 }
 
 // NOTE: Any of these methods that calls into the plugin needs to take into
 // account that the plugin may use Var to remove the <embed> from the DOM, which
 // will make the WebPluginImpl drop its reference, usually the last one. If a
@@ skipping 1220 matching lines @@
   // Don't actually verify that the object is in the set since during module
   // deletion we'll be in the process of freeing them.
   live_plugin_objects_.erase(plugin_object);
 }
 
 bool PluginInstance::IsFullPagePlugin() const {
   WebFrame* frame = container()->element().document().frame();
   return frame->view()->mainFrame()->document().isPluginDocument();
 }
 
-void PluginInstance::OnLockMouseACK(int32_t result) {
+void PluginInstance::OnLockMouseACK2(bool succeeded) {
+  fprintf(stderr, "PluginInstance::OnLockMouseACK2(%d)\n", succeeded);
   if (!lock_mouse_callback_.func) {
     NOTREACHED();
+    fprintf(stderr, "PluginInstance::OnLockMouseACK2 !!!!!\n");
     return;
   }
-
-  PP_RunAndClearCompletionCallback(&lock_mouse_callback_, result);
+  mouse_locked_to_this_instance_ = succeeded;
+  PP_RunAndClearCompletionCallback(&lock_mouse_callback_,
+                                   succeeded ? PP_OK : PP_ERROR_FAILED);
 }
 
-void PluginInstance::OnMouseLockLost() {
+void PluginInstance::OnMouseLockLost2() {
+  fprintf(stderr, "PluginInstance::OnMouseLockLost2()\n");
   if (LoadMouseLockInterface())
     plugin_mouse_lock_interface_->MouseLockLost(pp_instance());
+  mouse_locked_to_this_instance_ = false;
+}
+
+void PluginInstance::HandleMouseLockedInputEvent(
+    const WebKit::WebMouseEvent& event) {
+  // |cursor_info| is ignored since it is hidden when the mouse is locked.
+  WebKit::WebCursorInfo cursor_info;
+  HandleInputEvent(event, &cursor_info);
 }
 
 void PluginInstance::SimulateInputEvent(const InputEventData& input_event) {
   WebView* web_view = container()->element().document().frame()->view();
   if (!web_view) {
     NOTREACHED();
     return;
   }
 
   std::vector<linked_ptr<WebInputEvent> > events =
@@ skipping 263 matching lines @@
   }
   delegate()->ZoomLimitsChanged(minimum_factor, maximium_factor);
 }
 
 void PluginInstance::PostMessage(PP_Instance instance, PP_Var message) {
   message_channel_->PostMessageToJavaScript(message);
 }
 
 int32_t PluginInstance::LockMouse(PP_Instance instance,
                                   PP_CompletionCallback callback) {
+  fprintf(stderr, "PluginInstance::LockMouse: ");
   if (!callback.func) {
     // Don't support synchronous call.
     return PP_ERROR_BLOCKS_MAIN_THREAD;
   }
-  if (lock_mouse_callback_.func)
+  if (lock_mouse_callback_.func) // a lock is pending
+  {
+    fprintf(stderr, "lock_mouse_callback_.func PP_ERROR_INPROGRESS\n");
     return PP_ERROR_INPROGRESS;
+  }
+  if (mouse_locked_to_this_instance_)
+  {
+    fprintf(stderr, "mouse_locked_to_this_instance_ PP_OK\n");
+    return PP_OK;
+  }
   if (!CanAccessMainFrame())
     return PP_ERROR_NOACCESS;
 
-  lock_mouse_callback_ = callback;
-  // We will be notified on completion via OnLockMouseACK(), either
-  // synchronously or asynchronously.
-  delegate()->LockMouse(this);
-  return PP_OK_COMPLETIONPENDING;
+  if (delegate()->LockMouse(this)) {

[yzshen1, 2012/01/04 00:50:00]

It seems better to *not* have |mouse_locked_to_this_instance_|: we have the same
information stored in render_view. it is error-prone to keep track of the same
state in two places.

We could consider:
- let LockMouse return an enum value (pending/your are already the
owner!/failed)
- have a delegate()->IsCurrentMouseLockOwner(instance).

(Sorry, I know we discussed about this issue before. But reading the code makes
me think that it is not a good solution.)

+    fprintf(stderr, "delegate()->LockMouse(this) == true\n");
+    lock_mouse_callback_ = callback;
+    return PP_OK_COMPLETIONPENDING;
+  } else
+  {
+    fprintf(stderr, "delegate()->LockMouse(this) == false  PP_ERROR_FAILED\n");
+    return PP_ERROR_FAILED;
+  }
 }
 
 void PluginInstance::UnlockMouse(PP_Instance instance) {
+  fprintf(stderr, "PluginInstance::UnlockMouse\n");
   delegate()->UnlockMouse(this);
 }
 
 PP_Var PluginInstance::ResolveRelativeToDocument(
     PP_Instance instance,
     PP_Var relative,
     PP_URLComponents_Dev* components) {
   StringVar* relative_string = StringVar::FromPPVar(relative);
   if (!relative_string)
     return PP_MakeNull();
@@ skipping 119 matching lines @@
   screen_size_for_fullscreen_ = gfx::Size();
   WebElement element = container_->element();
   element.setAttribute(WebString::fromUTF8(kWidth), width_before_fullscreen_);
   element.setAttribute(WebString::fromUTF8(kHeight), height_before_fullscreen_);
   element.setAttribute(WebString::fromUTF8(kBorder), border_before_fullscreen_);
   element.setAttribute(WebString::fromUTF8(kStyle), style_before_fullscreen_);
 }
 
 }  // namespace ppapi
 }  // namespace webkit