When receiving a key event on Linux, set host lock state to match client's

remoting/host/input_injector_x11.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/host/input_injector.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <X11/extensions/XInput.h>
 #include <X11/extensions/XTest.h>
 #include <X11/Xlib.h>
 #include <X11/XKBlib.h>
+#include <X11/keysym.h>
 #undef Status  // Xlib.h #defines this, which breaks protobuf headers.
 
 #include <set>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
@@ skipping 91 matching lines @@
 
     // Queries whether keyboard auto-repeat is globally enabled. This is used
     // to decide whether to temporarily disable then restore this setting. If
     // auto-repeat has already been disabled, this class should leave it
     // untouched.
     bool IsAutoRepeatEnabled();
 
     // Enables or disables keyboard auto-repeat globally.
     void SetAutoRepeatEnabled(bool enabled);
 
+    // Sets the keyboard lock states to those provided.
+    void SetLockStates(uint32_t states);
+
     void InjectScrollWheelClicks(int button, int count);
     // Compensates for global button mappings and resets the XTest device
     // mapping.
     void InitMouseButtonMap();
     int MouseButtonToX11ButtonNumber(MouseEvent::MouseButton button);
     int HorizontalScrollWheelToX11ButtonNumber(int dx);
     int VerticalScrollWheelToX11ButtonNumber(int dy);
 
     scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 
@@ skipping 135 matching lines @@
   if (event.pressed()) {
     if (pressed_keys_.find(keycode) != pressed_keys_.end()) {
       // Ignore repeats for modifier keys.
       if (IsModifierKey(static_cast<ui::DomCode>(event.usb_keycode())))
         return;
       // Key is already held down, so lift the key up to ensure this repeated
       // press takes effect.
       XTestFakeKeyEvent(display_, keycode, False, CurrentTime);
     }
 
+    if (event.has_lock_states()) {
+      SetLockStates(event.lock_states());
+    }
+
     if (pressed_keys_.empty()) {
       // Disable auto-repeat, if necessary, to avoid triggering auto-repeat
       // if network congestion delays the key-up event from the client.
       saved_auto_repeat_enabled_ = IsAutoRepeatEnabled();
       if (saved_auto_repeat_enabled_)
         SetAutoRepeatEnabled(false);
     }
     pressed_keys_.insert(keycode);
   } else {
     pressed_keys_.erase(keycode);
@@ skipping 51 matching lines @@
   }
   return state.global_auto_repeat == AutoRepeatModeOn;
 }
 
 void InputInjectorX11::Core::SetAutoRepeatEnabled(bool mode) {
   XKeyboardControl control;
   control.auto_repeat_mode = mode ? AutoRepeatModeOn : AutoRepeatModeOff;
   XChangeKeyboardControl(display_, KBAutoRepeatMode, &control);
 }
 
+void InputInjectorX11::Core::SetLockStates(uint32_t states) {
+  unsigned int caps_lock_mask = XkbKeysymToModifiers(display_, XK_Caps_Lock);
+  unsigned int num_lock_mask = XkbKeysymToModifiers(display_, XK_Num_Lock);
+  unsigned int lock_values = 0;
+  if (states & protocol::KeyEvent::LOCK_STATES_CAPSLOCK) {
+    lock_values |= caps_lock_mask;
+  }
+  if (states & protocol::KeyEvent::LOCK_STATES_NUMLOCK) {
+    lock_values |= num_lock_mask;
+  }
+  XkbLockModifiers(display_, XkbUseCoreKbd, caps_lock_mask | num_lock_mask,
+                   lock_values);

[rkjnsn, 2017/04/25 19:25:03]

We could check the existing states first instead of indiscriminately setting
them, but I'm not sure that would offer any advantages. Certainly, it would
result in an extra server round trip in the out-of-sync case.

XkbLockModifiers could fail, which would leave things no worse than today.
However, would it makes sense to log a warning in that case? It could
potentially be triggered every key press, so I currently just ignore any errors.

[Jamie, 2017/04/25 20:15:57]

I think this is fine. The documentation suggests that it can fail if the request
wasn't sent, but gives no indication as to why that might be.

+}
+
 void InputInjectorX11::Core::InjectScrollWheelClicks(int button, int count) {
   if (button < 0) {
     LOG(WARNING) << "Ignoring unmapped scroll wheel button";
     return;
   }
   for (int i = 0; i < count; i++) {
     // Generate a button-down and a button-up to simulate a wheel click.
     XTestFakeButtonEvent(display_, button, true, CurrentTime);
     XTestFakeButtonEvent(display_, button, false, CurrentTime);
   }
@@ skipping 243 matching lines @@
     return nullptr;
   return std::move(injector);
 }
 
 // static
 bool InputInjector::SupportsTouchEvents() {
   return false;
 }
 
 }  // namespace remoting