Don't send mouse events if the plugin doesn't have 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"
@@ skipping 34 matching lines @@
 }
 
 bool PepperInputHandler::HandleInputEvent(const pp::InputEvent& event) {
   switch (event.GetType()) {
     case PP_INPUTEVENT_TYPE_CONTEXTMENU: {
       // We need to return true here or else we'll get a local (plugin) context
       // menu instead of the mouseup event for the right click.
       return true;
     }
 
     case PP_INPUTEVENT_TYPE_KEYDOWN:

[weitao, 2014/02/07 23:54:23]

While at it, could you please also ignore key events when the webapp doesn't
have focus? That will fix crbug.com/236549.

[Jamie, 2014/02/08 00:12:54]

We don't get key events when we don't have focus.

     case PP_INPUTEVENT_TYPE_KEYUP: {
       pp::KeyboardInputEvent pp_key_event(event);
       uint32_t modifiers = event.GetModifiers();
       uint32_t lock_states = 0;
 
       if (modifiers & PP_INPUTEVENT_MODIFIER_CAPSLOCKKEY)
         lock_states |= protocol::KeyEvent::LOCK_STATES_CAPSLOCK;
 
       if (modifiers & PP_INPUTEVENT_MODIFIER_NUMLOCKKEY)
         lock_states |= protocol::KeyEvent::LOCK_STATES_NUMLOCK;
 
       protocol::KeyEvent key_event;
       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_)
+        return false;

[Jamie, 2014/02/07 22:34:39]

I'm in two minds about this one. Some platforms (such as Mac) do not typically
pass the first click on an unfocused window to that window for processing; on
those platforms, a second click is needed to interact with the window after it
has been focused. On other platforms (such as Windows), the click that activates
a window is also processed by that window; on these platforms, a single click on
a UI element of an unfocused window will activate it.

By suppressing clicks when unfocused, we get the first behaviour. I've chosen it
because otherwise a right-click on an inactive Chromoting window will be passed
to the host (dismissing any screensaver, for example) but, at least on Mac, will
not active the Chromoting window itself. This is far less confusing than a
window that may have been inactive for some time awakening on mouse move, but is
still potentially confusing.

[weitao, 2014/02/07 23:54:23]

I agree the first behavior is better.

On 2014/02/07 22:34:39, Jamie wrote:

+
       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);
           break;
         case PP_INPUTEVENT_MOUSEBUTTON_RIGHT:
@@ skipping 16 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_)
+        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_)
+        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();
       wheel_delta_x_ += delta.x();
       wheel_delta_y_ += delta.y();
@@ skipping 148 matching lines @@
     mouse_lock_state_ = MouseLockOff;
     UpdateMouseCursor();
   }
 
   // Cancel as needed.
   if (should_cancel)
     CancelMouseLock();
 }
 
 }  // namespace remoting