Allow mouse-input to be enabled even if the plugin does not have keyboard focus.

remoting/client/plugin/pepper_input_handler.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 "remoting/client/plugin/pepper_input_handler.h"
 
 #include "base/logging.h"
 #include "ppapi/cpp/image_data.h"
 #include "ppapi/cpp/input_event.h"
 #include "ppapi/cpp/module_impl.h"
 #include "ppapi/cpp/mouse_cursor.h"
 #include "ppapi/cpp/point.h"
 #include "ppapi/cpp/var.h"
 #include "remoting/proto/event.pb.h"
 #include "ui/events/keycodes/dom4/keycode_converter.h"
 
 namespace remoting {
 
 PepperInputHandler::PepperInputHandler(
     pp::Instance* instance,
     protocol::InputStub* input_stub)
     : pp::MouseLock(instance),
       instance_(instance),
       input_stub_(input_stub),
       callback_factory_(this),
       has_focus_(false),
+      send_mouse_input_when_unfocused_(false),

[Wez, 2014/05/22 01:14:23]

nit: You could call this (and the related method, etc) move_mouse_when_blurred;
setter could then be set_mmwb(bool) (even if the API we export to JS never
really needs the bool=false capability).

[Jamie, 2014/05/22 01:32:09]

Since it controls more than just mouse movements, I prefer to keep this
terminology. I've changed the interface on PIH as you suggest. I was in two
minds as to whether to do the same for the JS API; I decided against it for
consistency with enableMediaSourceRendering, but LMK if you disagree.

       mouse_lock_state_(MouseLockDisallowed),
       wheel_delta_x_(0),
       wheel_delta_y_(0),
       wheel_ticks_x_(0),
       wheel_ticks_y_(0) {
 }
 
 PepperInputHandler::~PepperInputHandler() {
 }
 
@@ skipping 31 matching lines @@
       key_event.set_usb_keycode(GetUsbKeyCode(pp_key_event));
       key_event.set_pressed(event.GetType() == PP_INPUTEVENT_TYPE_KEYDOWN);
       key_event.set_lock_states(lock_states);
 
       input_stub_->InjectKeyEvent(key_event);
       return true;
     }
 
     case PP_INPUTEVENT_TYPE_MOUSEDOWN:
     case PP_INPUTEVENT_TYPE_MOUSEUP: {
-      if (!has_focus_)
+      if (!has_focus_ && !send_mouse_input_when_unfocused_)

[Wez, 2014/05/22 01:14:23]

Should we be filtering these at all? Is there any way we can even receive a
mouse-down without having focus[1]?

[1] Focus is generally either follows-mouse or click-to-focus, so in either case
by the time we see mouse-down, we must have focus, I think.

[Jamie, 2014/05/22 01:32:09]

I wrote up a summary when I added this code:

https://codereview.chromium.org/136093013/diff/60001/remoting/client/plugin/p...

In short, suppressing these clicks is the right thing to do on Mac, and arguably
makes sense on other platforms as well.

         return false;
 
       pp::MouseInputEvent pp_mouse_event(event);
       protocol::MouseEvent mouse_event;
       switch (pp_mouse_event.GetButton()) {
         case PP_INPUTEVENT_MOUSEBUTTON_LEFT:
           mouse_event.set_button(protocol::MouseEvent::BUTTON_LEFT);
           break;
         case PP_INPUTEVENT_MOUSEBUTTON_MIDDLE:
           mouse_event.set_button(protocol::MouseEvent::BUTTON_MIDDLE);
@@ skipping 18 matching lines @@
         }
 
         input_stub_->InjectMouseEvent(mouse_event);
       }
       return true;
     }
 
     case PP_INPUTEVENT_TYPE_MOUSEMOVE:
     case PP_INPUTEVENT_TYPE_MOUSEENTER:
     case PP_INPUTEVENT_TYPE_MOUSELEAVE: {
-      if (!has_focus_)
+      if (!has_focus_ && !send_mouse_input_when_unfocused_)
         return false;
 
       pp::MouseInputEvent pp_mouse_event(event);
       protocol::MouseEvent mouse_event;
       mouse_event.set_x(pp_mouse_event.GetPosition().x());
       mouse_event.set_y(pp_mouse_event.GetPosition().y());
 
       // Add relative movement if the mouse is locked.
       if (mouse_lock_state_ == MouseLockOn) {
         pp::Point delta = pp_mouse_event.GetMovement();
         mouse_event.set_delta_x(delta.x());
         mouse_event.set_delta_y(delta.y());
       }
 
       input_stub_->InjectMouseEvent(mouse_event);
       return true;
     }
 
     case PP_INPUTEVENT_TYPE_WHEEL: {
-      if (!has_focus_)
+      if (!has_focus_ && !send_mouse_input_when_unfocused_)
         return false;
 
       pp::WheelInputEvent pp_wheel_event(event);
 
       // Don't handle scroll-by-page events, for now.
       if (pp_wheel_event.GetScrollByPage())
         return false;
 
       // Add this event to our accumulated sub-pixel deltas and clicks.
       pp::FloatPoint delta = pp_wheel_event.GetDelta();
@@ skipping 61 matching lines @@
   cursor_image_ = image.Pass();
   cursor_hotspot_ = hotspot;
 
   if (mouse_lock_state_ != MouseLockDisallowed && !cursor_image_) {
     RequestMouseLock();
   } else {
     CancelMouseLock();
   }
 }
 
+void PepperInputHandler::SendMouseInputWhenUnfocused() {
+  send_mouse_input_when_unfocused_ = true;
+}
+
 void PepperInputHandler::MouseLockLost() {
   DCHECK(mouse_lock_state_ == MouseLockOn ||
          mouse_lock_state_ == MouseLockCancelling);
 
   mouse_lock_state_ = MouseLockOff;
   UpdateMouseCursor();
 }
 
 void PepperInputHandler::RequestMouseLock() {
   // Request mouse lock only if the plugin is focused, the host-supplied cursor
@@ skipping 69 matching lines @@
     mouse_lock_state_ = MouseLockOff;
     UpdateMouseCursor();
   }
 
   // Cancel as needed.
   if (should_cancel)
     CancelMouseLock();
 }
 
 }  // namespace remoting