refactoring mouse lock to support pepper and WebKit

content/renderer/render_view_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/render_view_impl.h"
 
 #include <algorithm>
 #include <cmath>
 #include <string>
 #include <vector>
@@ skipping 68 matching lines @@
 #include "content/renderer/websharedworker_proxy.h"
 #include "media/base/filter_collection.h"
 #include "media/base/media_switches.h"
 #include "media/base/message_loop_factory_impl.h"
 #include "net/base/escape.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_util.h"
 #include "ppapi/c/private/ppb_flash_net_connector.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebAccessibilityObject.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebCString.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebCursorInfo.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDataSource.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebDragData.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebElement.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFileChooserParams.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFileSystemCallbacks.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFindOptions.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFormControlElement.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFormElement.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
@@ skipping 260 matching lines @@
       speech_input_dispatcher_(NULL),
       device_orientation_dispatcher_(NULL),
       p2p_socket_dispatcher_(NULL),
       devtools_agent_(NULL),
       renderer_accessibility_(NULL),
       session_storage_namespace_id_(session_storage_namespace_id),
       handling_select_range_(false),
 #if defined(OS_WIN)
       focused_plugin_id_(-1),
 #endif
-      ALLOW_THIS_IN_INITIALIZER_LIST(pepper_delegate_(this)) {
+      ALLOW_THIS_IN_INITIALIZER_LIST(pepper_delegate_(this)),
+      mouse_locked_(false),
+      pending_lock_request_(false),
+      pending_unlock_request_(false),
+      mouse_lock_webwidget_owner_(NULL),
+      mouse_lock_pinstance_owner_(NULL) {
   routing_id_ = routing_id;
   if (opener_id != MSG_ROUTING_NONE)
     opener_id_ = opener_id;
 
 #if defined(ENABLE_NOTIFICATIONS)
   notification_provider_ = new NotificationProvider(this);
 #else
   notification_provider_ = NULL;
 #endif
 
@@ skipping 1491 matching lines @@
 
 bool RenderViewImpl::enterFullScreen() {
   Send(new ViewHostMsg_ToggleFullscreen(routing_id_, true));
   return true;
 }
 
 void RenderViewImpl::exitFullScreen() {
   Send(new ViewHostMsg_ToggleFullscreen(routing_id_, false));
 }
 
+void RenderViewImpl::lockPointer() {
+  // HACK
+  bool succeeded = true;
+  mouse_locked_ = succeeded;
+  if (webview()) {
+    fprintf(stderr, "RenderViewImpl::lockPointer() webview()->lockPointerAck();\n");
+    webview()->OnLockMouseACK2(succeeded);
+  } else {
+    fprintf(stderr, "RenderViewImpl::lockPointer() NULL webview();\n");
+  }
+}
+
+void RenderViewImpl::unlockPointer() {
+  // HACK
+  OnMouseLockLost();
+}
+
+bool RenderViewImpl::isPointerLocked() {
+  fprintf(stderr, "RenderViewImpl::isPointerLocked()\n");
+  return mouse_locked_;
+}
+
 // WebKit::WebFrameClient -----------------------------------------------------
 
 WebPlugin* RenderViewImpl::createPlugin(WebFrame* frame,
                                         const WebPluginParams& params) {
   WebPlugin* plugin = NULL;
   if (content::GetContentClient()->renderer()->OverrideCreatePlugin(
           this, frame, params, &plugin)) {
     return plugin;
   }
 
@@ skipping 2385 matching lines @@
   WebView* doomed = webview();
   RenderWidget::Close();
   g_view_map.Get().erase(doomed);
 }
 
 void RenderViewImpl::DidHandleKeyEvent() {
   edit_commands_.clear();
 }
 
 bool RenderViewImpl::WillHandleMouseEvent(const WebKit::WebMouseEvent& event) {
-  return pepper_delegate_.HandleMouseEvent(event);
+  pepper_delegate_.WillHandleMouseEvent();
+
+  if (mouse_locked_) {
+    // |cursor_info| is ignored since it is hidden when the mouse is locked.
+    WebKit::WebCursorInfo cursor_info;
+
+    DCHECK(!mouse_lock_webwidget_owner_ || !mouse_lock_pinstance_owner_);
+    if (mouse_lock_webwidget_owner_)
+      mouse_lock_webwidget_owner_->HandleMouseLockedInputEvent(event);
+    if (mouse_lock_pinstance_owner_)
+      mouse_lock_pinstance_owner_->HandleMouseLockedInputEvent(event);
+
+    // If the mouse is locked, only the current owner of the mouse lock can
+    // process mouse events.
+    return true;
+  }
+  return false;
 }
 
 void RenderViewImpl::DidHandleMouseEvent(const WebKit::WebMouseEvent& event) {
   FOR_EACH_OBSERVER(RenderViewObserver, observers_, DidHandleMouseEvent(event));
 }
 
 void RenderViewImpl::DidHandleTouchEvent(const WebTouchEvent& event) {
   FOR_EACH_OBSERVER(RenderViewObserver, observers_, DidHandleTouchEvent(event));
 }
 
@@ skipping 467 matching lines @@
 
 void RenderViewImpl::OnEnableViewSourceMode() {
   if (!webview())
     return;
   WebFrame* main_frame = webview()->mainFrame();
   if (!main_frame)
     return;
   main_frame->enableViewSourceMode(true);
 }
 
+bool RenderViewImpl::LockMouseInternal(WebKit::WebWidget* webwidget,
+    webkit::ppapi::PluginInstance* pinstance) {
+  DCHECK(!(webwidget && pinstance)); // Only one mouse lock target at a time.
+  fprintf(stderr, "RenderViewImpl::LockMouseInternal(%s, %s)  ", webwidget ? "webwidget" : "NULL", pinstance ? "pinstance" : "NULL");
+
+  if (MouseLockedOrPendingAction())
+  {
+    fprintf(stderr, "return false; // (locked or pending)\n");
+    return false;
+  }
+
+  pending_lock_request_ = true;
+  DCHECK(!mouse_lock_webwidget_owner_ && !mouse_lock_pinstance_owner_);
+  mouse_lock_webwidget_owner_ = webwidget;
+  mouse_lock_pinstance_owner_ = pinstance;
+
+  Send(new ViewHostMsg_LockMouse(routing_id()));
+  fprintf(stderr, "return true;\n");
+  return true;
+}
+
+void RenderViewImpl::UnlockMouseInternal(WebKit::WebWidget* webwidget,
+    webkit::ppapi::PluginInstance* pinstance) {
+  fprintf(stderr, "RenderViewImpl::UnlockMouseInternal(%s, %s) \n", webwidget ? "webwidget" : "NULL", pinstance ? "pinstance" : "NULL");
+  if (!MouseLockedOrPendingAction())
+  {
+    fprintf(stderr, "RenderViewImpl::LockMouseInternal()  if (!MouseLockedOrPendingAction()) return\n");
+    return;
+  }
+  if (pending_unlock_request_)

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

nit: It seems better to put this in the if-block of line 4854.
(I agree that the current logic is correct, but the other way is easier to
understand.)

+  {
+    fprintf(stderr, "RenderViewImpl::LockMouseInternal()  if (pending_unlock_request_) return\n");
+    return;
+  }
+
+  // Ignore unless the unlock request is for the current lock holder.
+  if (webwidget == mouse_lock_webwidget_owner_ ||
+      pinstance == mouse_lock_pinstance_owner_) {
+    pending_unlock_request_ = true;
+    Send(new ViewHostMsg_UnlockMouse(routing_id()));
+  }
+  else
+  {
+    fprintf(stderr, "RenderViewImpl::LockMouseInternal()  not the current target\n");
+  }
+}
+
 void RenderViewImpl::OnLockMouseACK(bool succeeded) {
   // Mouse Lock removes the system cursor and provides all mouse motion as
   // .movementX/Y values on events all sent to a fixed target. This requires
   // content to specifically request the mode to be entered.
   // Mouse Capture is implicitly given for the duration of a drag event, and
   // sends all mouse events to the initial target of the drag.
   // If Lock is entered it supercedes any in progress Capture.
   if (succeeded)
     OnMouseCaptureLost();
 
-  pepper_delegate_.OnLockMouseACK(succeeded);
+  //scheibXXX
+  // was: pepper_delegate_.OnLockMouseACK(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 (mouse_lock_webwidget_owner_ || mouse_lock_pinstance_owner_) {
+    WebKit::WebWidget* last_webwidget_owner = mouse_lock_webwidget_owner_;
+    webkit::ppapi::PluginInstance* last_pinstance_owner =
+        mouse_lock_pinstance_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_webwidget_owner_ = NULL;
+      mouse_lock_pinstance_owner_ = NULL;
+    }
+
+    DCHECK(!mouse_lock_webwidget_owner_ || !mouse_lock_pinstance_owner_);
+    if (last_webwidget_owner)
+      last_webwidget_owner->OnLockMouseACK2(succeeded);
+    if (last_pinstance_owner)
+      last_pinstance_owner->OnLockMouseACK2(succeeded);
+  }
+  //scheibXXX
+  // end was: pepper_delegate_.OnLockMouseACK(succeeded);
 }
 
 void RenderViewImpl::OnMouseLockLost() {
-  pepper_delegate_.OnMouseLockLost();
+  DCHECK(mouse_locked_ && !pending_lock_request_);
+
+  mouse_locked_ = false;
+  pending_unlock_request_ = false;
+  if (mouse_lock_webwidget_owner_ || mouse_lock_pinstance_owner_) {
+    WebKit::WebWidget* last_webwidget_owner = mouse_lock_webwidget_owner_;
+    webkit::ppapi::PluginInstance* last_pinstance_owner =
+        mouse_lock_pinstance_owner_;
+
+    // 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_webwidget_owner_ = NULL;
+    mouse_lock_pinstance_owner_ = NULL;
+
+    DCHECK(!mouse_lock_webwidget_owner_ || !mouse_lock_pinstance_owner_);
+    if (last_webwidget_owner)
+      last_webwidget_owner->OnMouseLockLost2();
+    if (last_pinstance_owner)
+      last_pinstance_owner->OnMouseLockLost2();
+  }
 }
 
 bool RenderViewImpl::WebWidgetHandlesCompositorScheduling() const {
   return !!RenderThreadImpl::current()->compositor_thread();
 }
 
 void RenderViewImpl::OnJavaBridgeInit(
     const IPC::ChannelHandle& channel_handle) {
   DCHECK(!java_bridge_dispatcher_.get());
 #if defined(ENABLE_JAVA_BRIDGE)
   java_bridge_dispatcher_.reset(new JavaBridgeDispatcher(this, channel_handle));
 #endif
 }