refactoring mouse lock to support pepper and WebKit

content/renderer/pepper_plugin_delegate_impl.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/pepper_plugin_delegate_impl.h"
 
 #include <cmath>
 #include <queue>
 
 #include "base/bind.h"
@@ skipping 834 matching lines @@
   // Temporarily, just call back.
   client->BrokerConnected(ppapi::PlatformFileToInt(plugin_handle), result);
 }
 
 PepperPluginDelegateImpl::PepperPluginDelegateImpl(RenderViewImpl* render_view)
     : content::RenderViewObserver(render_view),
       render_view_(render_view),
       has_saved_context_menu_action_(false),
       saved_context_menu_action_(0),
       focused_plugin_(NULL),
-      mouse_lock_owner_(NULL),
-      mouse_locked_(false),
-      pending_lock_request_(false),
-      pending_unlock_request_(false),
       last_mouse_event_target_(NULL) {
 }
 
 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 283 matching lines @@
   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);
 
-  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;
-  }
+  UnlockMouse(instance);
+
   if (last_mouse_event_target_ == instance)
     last_mouse_event_target_ = NULL;
   if (focused_plugin_ == instance)
     PluginFocusChanged(instance, false);
 }
 
 SkBitmap* PepperPluginDelegateImpl::GetSadPluginBitmap() {
   return content::GetContentClient()->renderer()->GetSadPluginBitmap();
 }
 
@@ skipping 170 matching lines @@
   for (std::set<webkit::ppapi::PluginInstance*>::iterator i =
            active_instances_.begin();
        i != active_instances_.end(); ++i)
     (*i)->PageVisibilityChanged(is_visible);
 }
 
 bool PepperPluginDelegateImpl::IsPluginFocused() const {
   return focused_plugin_ != NULL;
 }
 
-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::HandleMouseEvent(
-    const WebKit::WebMouseEvent& event) {
+void PepperPluginDelegateImpl::WillHandleMouseEvent() {
   // This method is called for every mouse event that the render view receives.
   // And then the mouse event is forwarded to WebKit, which dispatches it to the
   // event target. Potentially a Pepper plugin will receive the event.
   // In order to tell whether a plugin gets the last mouse event and which it
   // is, we set |last_mouse_event_target_| to NULL here. If a plugin gets the
   // event, it will notify us via DidReceiveMouseEvent() and set itself as
   // |last_mouse_event_target_|.
   last_mouse_event_target_ = NULL;
-
-  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(
@@ skipping 517 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(
+bool 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);
-    }
-  }
+  return render_view_->PpapiLockMouse(instance);
 }
 
 void PepperPluginDelegateImpl::UnlockMouse(
     webkit::ppapi::PluginInstance* instance) {
-  DCHECK(instance);
+  render_view_->PpapiUnlockMouse(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();
-    }
-  }
+bool PepperPluginDelegateImpl::IsMouseLocked(
+    webkit::ppapi::PluginInstance* instance) {
+  return render_view_->PpapiIsMouseLockedTo(instance);
 }
 
 void PepperPluginDelegateImpl::DidChangeCursor(
     webkit::ppapi::PluginInstance* instance,
     const WebKit::WebCursorInfo& cursor) {
   // Update the cursor appearance immediately if the requesting plugin is the
   // one which receives the last mouse event. Otherwise, the new cursor won't be
   // picked up until the plugin gets the next input event. That is bad if, e.g.,
   // the plugin would like to set an invisible cursor when there isn't any user
   // input for a while.
@@ skipping 139 matching lines @@
 
 bool PepperPluginDelegateImpl::CanUseSocketAPIs() {
   WebView* webview = render_view_->webview();
   WebFrame* main_frame = webview ? webview->mainFrame() : NULL;
   GURL url(main_frame ? GURL(main_frame->document().url()) : GURL());
   if (!url.is_valid())
     return false;
 
   return content::GetContentClient()->renderer()->AllowSocketAPI(url);
 }