[Remoting Host] Handle text event characters that are not presented on the keyboard

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>
 #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"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversion_utils.h"
 #include "build/build_config.h"
 #include "remoting/base/logging.h"
 #include "remoting/host/clipboard.h"
 #include "remoting/host/linux/unicode_to_keysym.h"
+#include "remoting/host/linux/x11_character_injector.h"
+#include "remoting/host/linux/x11_keyboard_impl.h"
 #include "remoting/host/linux/x11_util.h"
 #include "remoting/proto/internal.pb.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_geometry.h"
 #include "ui/events/keycodes/dom/dom_code.h"
 #include "ui/events/keycodes/dom/keycode_converter.h"
 
 #if defined(OS_CHROMEOS)
 #include "remoting/host/chromeos/point_transformer.h"
 #endif
 
 namespace remoting {
 
 namespace {
 
 using protocol::ClipboardEvent;
 using protocol::KeyEvent;
 using protocol::TextEvent;
 using protocol::MouseEvent;
 using protocol::TouchEvent;
 
-bool FindKeycodeForKeySym(Display* display,
-                          KeySym key_sym,
-                          uint32_t* keycode,
-                          uint32_t* modifiers) {
-  *keycode = XKeysymToKeycode(display, key_sym);
-
-  const uint32_t kModifiersToTry[] = {
-    0,
-    ShiftMask,
-    Mod2Mask,
-    Mod3Mask,
-    Mod4Mask,
-    ShiftMask | Mod2Mask,
-    ShiftMask | Mod3Mask,
-    ShiftMask | Mod4Mask,
-  };
-
-  // TODO(sergeyu): Is there a better way to find modifiers state?
-  for (size_t i = 0; i < arraysize(kModifiersToTry); ++i) {
-    unsigned long key_sym_with_mods;
-    if (XkbLookupKeySym(display, *keycode, kModifiersToTry[i], nullptr,
-                        &key_sym_with_mods) &&
-        key_sym_with_mods == key_sym) {
-      *modifiers = kModifiersToTry[i];
-      return true;
-    }
-  }
-
-  return false;
-}
-
-// Finds a keycode and set of modifiers that generate character with the
-// specified |code_point|.
-bool FindKeycodeForUnicode(Display* display,
-                          uint32_t code_point,
-                          uint32_t* keycode,
-                          uint32_t* modifiers) {
-  std::vector<uint32_t> keysyms;
-  GetKeySymsForUnicode(code_point, &keysyms);
-
-  for (std::vector<uint32_t>::iterator it = keysyms.begin();
-       it != keysyms.end(); ++it) {
-    if (FindKeycodeForKeySym(display, *it, keycode, modifiers)) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
 bool IsModifierKey(ui::DomCode dom_code) {
   return dom_code == ui::DomCode::CONTROL_LEFT ||
          dom_code == ui::DomCode::SHIFT_LEFT ||
          dom_code == ui::DomCode::ALT_LEFT ||
          dom_code == ui::DomCode::META_LEFT ||
          dom_code == ui::DomCode::CONTROL_RIGHT ||
          dom_code == ui::DomCode::SHIFT_RIGHT ||
          dom_code == ui::DomCode::ALT_RIGHT ||
          dom_code == ui::DomCode::META_RIGHT;
 }
@@ skipping 84 matching lines @@
     static const int kNumPointerButtons = 7;
 
     int pointer_button_map_[kNumPointerButtons];
 
 #if defined(OS_CHROMEOS)
     PointTransformer point_transformer_;
 #endif
 
     std::unique_ptr<Clipboard> clipboard_;
 
+    std::unique_ptr<X11CharacterInjector> character_injector_;
+
     bool saved_auto_repeat_enabled_;
 
     DISALLOW_COPY_AND_ASSIGN(Core);
   };
 
   scoped_refptr<Core> core_;
 
   DISALLOW_COPY_AND_ASSIGN(InputInjectorX11);
 };
 
@@ skipping 145 matching lines @@
   }
   pressed_keys_.clear();
 
   const std::string text = event.text();
   for (int32_t index = 0; index < static_cast<int32_t>(text.size()); ++index) {
     uint32_t code_point;
     if (!base::ReadUnicodeCharacter(
             text.c_str(), text.size(), &index, &code_point)) {
       continue;
     }
-
-    uint32_t keycode;
-    uint32_t modifiers;
-    if (!FindKeycodeForUnicode(display_, code_point, &keycode, &modifiers))
-      continue;
-
-    XkbLockModifiers(display_, XkbUseCoreKbd,  modifiers, modifiers);
-
-    XTestFakeKeyEvent(display_, keycode, True, CurrentTime);
-    XTestFakeKeyEvent(display_, keycode, False, CurrentTime);
-
-    XkbLockModifiers(display_, XkbUseCoreKbd, modifiers, 0);
+    character_injector_->Inject(code_point);
   }
-
-  XFlush(display_);
 }
 
 InputInjectorX11::Core::~Core() {
   CHECK(pressed_keys_.empty());
 }
 
 void InputInjectorX11::Core::InitClipboard() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   clipboard_ = Clipboard::Create();
 }
@@ skipping 235 matching lines @@
   if (!task_runner_->BelongsToCurrentThread()) {
     task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&Core::Start, this, base::Passed(&client_clipboard)));
     return;
   }
 
   InitMouseButtonMap();
 
   clipboard_->Start(std::move(client_clipboard));
+
+  character_injector_.reset(
+      new X11CharacterInjector(base::MakeUnique<X11KeyboardImpl>(display_)));
 }
 
 void InputInjectorX11::Core::Stop() {
   if (!task_runner_->BelongsToCurrentThread()) {
     task_runner_->PostTask(FROM_HERE, base::Bind(&Core::Stop, this));
     return;
   }
 
   clipboard_.reset();
+  character_injector_.reset();
 }
 
 }  // namespace
 
 // static
 std::unique_ptr<InputInjector> InputInjector::Create(
     scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner) {
   std::unique_ptr<InputInjectorX11> injector(
       new InputInjectorX11(main_task_runner));
   if (!injector->Init())
     return nullptr;
   return std::move(injector);
 }
 
 // static
 bool InputInjector::SupportsTouchEvents() {
   return false;
 }
 
 }  // namespace remoting