Support mouse lock in Flash fullscreen mode.

content/renderer/render_view_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/render_view_impl.h"
 
 #include <algorithm>
 #include <cmath>
 #include <string>
 #include <vector>
@@ skipping 429 matching lines @@
   PendingFileChooser(const content::FileChooserParams& p,
                      WebFileChooserCompletion* c)
       : params(p),
         completion(c) {
   }
   content::FileChooserParams params;
   WebFileChooserCompletion* completion;  // MAY BE NULL to skip callback.
 };
 
 namespace {
 

[scheib, 2012/05/29 21:47:14]

Consider moving to a new implementation file? render_view_impl.cc is already
huge, and the initial goal of creating the mouse lock dispatcher object was to
move details out.

[yzshen1, 2012/05/30 06:41:30]

Good point. Thanks!

On 2012/05/29 21:47:14, scheib wrote:

+// RenderViewMouseLockDispatcher is owned by RenderViewImpl.
+class RenderViewMouseLockDispatcher : public MouseLockDispatcher,

[brettw, 2012/05/29 21:27:10]

Could you move this to a separate file for just this class? I'm loath to make
render_view_impl.cc any longer...

[yzshen1, 2012/05/30 06:41:30]

Done. Thanks!

On 2012/05/29 21:27:10, brettw wrote:

+                                      public content::RenderViewObserver {
+ public:
+  explicit RenderViewMouseLockDispatcher(RenderViewImpl* render_view_impl);
+  virtual ~RenderViewMouseLockDispatcher();
+
+ private:
+  // MouseLockDispatcher implementation.
+  virtual void SendLockMouseRequest() OVERRIDE;
+  virtual void SendUnlockMouseRequest() OVERRIDE;
+
+  // RenderView::Observer implementation.
+  virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
+
+  void OnMsgLockMouseACK(bool succeeded);
+
+  RenderViewImpl* render_view_impl_;
+
+  DISALLOW_COPY_AND_ASSIGN(RenderViewMouseLockDispatcher);
+};
+
+RenderViewMouseLockDispatcher::RenderViewMouseLockDispatcher(
+    RenderViewImpl* render_view_impl)
+    : content::RenderViewObserver(render_view_impl),
+      render_view_impl_(render_view_impl) {
+}
+
+RenderViewMouseLockDispatcher::~RenderViewMouseLockDispatcher() {
+}
+
+void RenderViewMouseLockDispatcher::SendLockMouseRequest() {
+  bool user_gesture =
+      render_view_impl_->webview() &&
+      render_view_impl_->webview()->mainFrame() &&
+      render_view_impl_->webview()->mainFrame()->isProcessingUserGesture();
+
+  Send(new ViewHostMsg_LockMouse(routing_id(), user_gesture, false));
+}
+
+void RenderViewMouseLockDispatcher::SendUnlockMouseRequest() {
+  Send(new ViewHostMsg_UnlockMouse(routing_id()));
+}
+
+bool RenderViewMouseLockDispatcher::OnMessageReceived(
+    const IPC::Message& message) {
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP(RenderViewMouseLockDispatcher, message)
+    IPC_MESSAGE_HANDLER(ViewMsg_LockMouse_ACK, OnMsgLockMouseACK)
+    IPC_MESSAGE_FORWARD(ViewMsg_MouseLockLost,
+                        static_cast<MouseLockDispatcher*>(this),
+                        MouseLockDispatcher::OnMouseLockLost)
+    IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP()
+  return handled;
+}
+
+void RenderViewMouseLockDispatcher::OnMsgLockMouseACK(bool succeeded) {
+  // Notify the base class.
+  OnLockMouseACK(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 && render_view_impl_->webwidget())
+    render_view_impl_->webwidget()->mouseCaptureLost();
+}
+
 class WebWidgetLockTarget : public MouseLockDispatcher::LockTarget {
  public:
   explicit WebWidgetLockTarget(WebKit::WebWidget* webwidget)
       : webwidget_(webwidget) {}
 
   virtual void OnLockMouseACK(bool succeeded) OVERRIDE {
     if (succeeded)
       webwidget_->didAcquirePointerLock();
     else
       webwidget_->didNotAcquirePointerLock();
@@ skipping 151 matching lines @@
 
   new MHTMLGenerator(this);
 #if defined(OS_MACOSX)
   new TextInputClientObserver(this);
 #endif  // defined(OS_MACOSX)
 
   // The next group of objects all implement RenderViewObserver, so are deleted
   // along with the RenderView automatically.
   devtools_agent_ = new DevToolsAgent(this);
   renderer_accessibility_ = new RendererAccessibility(this, accessibility_mode);
-  mouse_lock_dispatcher_ = new MouseLockDispatcher(this);
+  mouse_lock_dispatcher_ = new RenderViewMouseLockDispatcher(this);
   intents_host_ = new WebIntentsHost(this);
 
   new IdleUserDetector(this);
 
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
   if (command_line.HasSwitch(switches::kDomAutomationController))
     enabled_bindings_ |= content::BINDINGS_POLICY_DOM_AUTOMATION;
 
   ProcessViewLayoutFlags(command_line);
 
@@ skipping 4903 matching lines @@
 bool RenderViewImpl::WebWidgetHandlesCompositorScheduling() const {
   return !!RenderThreadImpl::current()->compositor_thread();
 }
 
 void RenderViewImpl::OnJavaBridgeInit() {
   DCHECK(!java_bridge_dispatcher_);
 #if defined(ENABLE_JAVA_BRIDGE)
   java_bridge_dispatcher_ = new JavaBridgeDispatcher(this);
 #endif
 }