Remoes X11 dependency in InputMethodEngine.

chrome/browser/chromeos/input_method/input_method_engine.cc

 // Copyright 2013 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 "chrome/browser/chromeos/input_method/input_method_engine.h"
 
-#define XK_MISCELLANY
-#include <X11/keysymdef.h>
-#include <X11/X.h>
-#include <X11/Xlib.h>
-#include <X11/Xutil.h>
 #undef FocusIn
 #undef FocusOut
 #undef RootWindow
 #include <map>
 
 #include "ash/ime/input_method_menu_item.h"
 #include "ash/ime/input_method_menu_manager.h"
 #include "ash/shell.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chromeos/ime/component_extension_ime_manager.h"
 #include "chromeos/ime/composition_text.h"
 #include "chromeos/ime/extension_ime_util.h"
 #include "chromeos/ime/input_method_manager.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/base/ime/candidate_window.h"
 #include "ui/base/ime/chromeos/ime_keymap.h"
 #include "ui/events/event.h"
 #include "ui/events/event_processor.h"
-#include "ui/events/keycodes/dom4/keycode_converter.h"
-#include "ui/events/keycodes/keyboard_code_conversion_x.h"
 #include "ui/keyboard/keyboard_controller.h"
 #include "ui/keyboard/keyboard_util.h"
 
 namespace chromeos {
 const char* kErrorNotActive = "IME is not active";
 const char* kErrorWrongContext = "Context is not active";
 const char* kCandidateNotFound = "Candidate not found";
 
 namespace {
 
@@ skipping 14 matching lines @@
 size_t GetUtf8StringLength(const char* s) {
   size_t ret = 0;
   while (*s) {
     if ((*s & 0xC0) != 0x80)
       ret++;
     ++s;
   }
   return ret;
 }
 
+std::string GetKeyFromEvent(const ui::KeyEvent& event) {
+  const std::string& code = event.code();
+  if (StartsWithASCII(code, "Control", true))
+    return "Ctrl";
+  if (StartsWithASCII(code, "Shift", true))
+    return "Shift";
+  if (StartsWithASCII(code, "Alt", true))
+    return "Alt";
+  if (StartsWithASCII(code, "Arrow", true))
+    return code.substr(5);
+  if (code == "Escape")
+    return "Esc";
+  if (code == "Backspace" || code == "Tab" ||
+      code == "Enter" || code == "CapsLock")
+    return code;
+  uint16 ch = 0;
+  // Ctrl+? cases, gets key value for Ctrl is not down.
+  if (event.flags() & ui::EF_CONTROL_DOWN) {
+    ui::KeyEvent event_no_ctrl(event.type(),
+                               event.key_code(),
+                               event.flags() ^ ui::EF_CONTROL_DOWN,
+                               false);
+    ch = event_no_ctrl.GetCharacter();
+  } else {
+    ch = event.GetCharacter();
+  }
+  return base::UTF16ToUTF8(base::string16(1, ch));
+}
+
 }  // namespace
 
 InputMethodEngine::InputMethodEngine()
     : current_input_type_(ui::TEXT_INPUT_TYPE_NONE),
       active_(false),
       context_id_(0),
       next_context_id_(1),
       composition_text_(new CompositionText()),
       composition_cursor_(0),
       candidate_window_(new ui::CandidateWindow()),
@@ skipping 176 matching lines @@
   }
 
   ui::EventProcessor* dispatcher =
       ash::Shell::GetPrimaryRootWindow()->GetHost()->event_processor();
 
   for (size_t i = 0; i < events.size(); ++i) {
     const KeyboardEvent& event = events[i];
     const ui::EventType type =
         (event.type == "keyup") ? ui::ET_KEY_RELEASED : ui::ET_KEY_PRESSED;
 
-    // KeyboardCodeFromXKyeSym assumes US keyboard layout.
-    ui::KeycodeConverter* conv = ui::KeycodeConverter::GetInstance();
-    DCHECK(conv);
-
-     // DOM code (KeyA) -> XKB -> XKeySym (XK_A) -> KeyboardCode (VKEY_A)
-    const uint16 native_keycode =
-        conv->CodeToNativeKeycode(event.code.c_str());
-    const uint xkeysym = ui::DefaultXKeysymFromHardwareKeycode(native_keycode);
-    const ui::KeyboardCode key_code = ui::KeyboardCodeFromXKeysym(xkeysym);
-
-    const std::string code = event.code;
     int flags = ui::EF_NONE;
     flags |= event.alt_key   ? ui::EF_ALT_DOWN       : ui::EF_NONE;
     flags |= event.ctrl_key  ? ui::EF_CONTROL_DOWN   : ui::EF_NONE;
     flags |= event.shift_key ? ui::EF_SHIFT_DOWN     : ui::EF_NONE;
     flags |= event.caps_lock ? ui::EF_CAPS_LOCK_DOWN : ui::EF_NONE;
 
-    ui::KeyEvent ui_event(type, key_code, code, flags, false /* is_char */);
+    ui::KeyEvent ui_event(type,
+                          ui::DomKeycodeToKeyboardCode(event.code),
+                          event.code,
+                          flags,
+                          false /* is_char */);
+    if (!event.key.empty())
+      ui_event.set_character(base::UTF8ToUTF16(event.key)[0]);
     base::AutoReset<const ui::KeyEvent*> reset_sent_key(&sent_key_event_,
                                                         &ui_event);
     ui::EventDispatchDetails details = dispatcher->OnEventFromSource(&ui_event);
     if (details.dispatcher_destroyed)
       break;
   }
   return true;
 }
 
 const InputMethodEngine::CandidateWindowProperty&
@@ skipping 280 matching lines @@
 
 void InputMethodEngine::PropertyActivate(const std::string& property_name) {
   observer_->OnMenuItemActivated(engine_id_, property_name);
 }
 
 void InputMethodEngine::Reset() {
   observer_->OnReset(engine_id_);
 }
 
 namespace {
+
 void GetExtensionKeyboardEventFromKeyEvent(
     const ui::KeyEvent& event,
     InputMethodEngine::KeyboardEvent* ext_event) {
   DCHECK(event.type() == ui::ET_KEY_RELEASED ||
          event.type() == ui::ET_KEY_PRESSED);
   DCHECK(ext_event);
   ext_event->type = (event.type() == ui::ET_KEY_RELEASED) ? "keyup" : "keydown";
 
   ext_event->code = event.code();
   ext_event->alt_key = event.IsAltDown();
   ext_event->ctrl_key = event.IsControlDown();
   ext_event->shift_key = event.IsShiftDown();
   ext_event->caps_lock = event.IsCapsLockDown();
+  ext_event->key = GetKeyFromEvent(event);
+}
 
-  uint32 x11_keysym = 0;
-  if (event.HasNativeEvent()) {
-    const base::NativeEvent& native_event = event.native_event();
-    DCHECK(native_event);
-
-    XKeyEvent* x_key = &(static_cast<XEvent*>(native_event)->xkey);
-    KeySym keysym = NoSymbol;
-    ::XLookupString(x_key, NULL, 0, &keysym, NULL);
-    x11_keysym = keysym;
-  } else {
-    // Convert ui::KeyEvent.key_code to DOM UIEvent key.
-    // XKeysymForWindowsKeyCode converts key_code to XKeySym, but it
-    // assumes US layout and does not care about CapLock state.
-    //
-    // TODO(komatsu): Support CapsLock states.
-    // TODO(komatsu): Support non-us keyboard layouts.
-    x11_keysym = ui::XKeysymForWindowsKeyCode(event.key_code(),
-                                              event.IsShiftDown());
-  }
-  ext_event->key = ui::FromXKeycodeToKeyValue(x11_keysym);
-}
 }  // namespace
 
 void InputMethodEngine::ProcessKeyEvent(
     const ui::KeyEvent& key_event,
     const KeyEventDoneCallback& callback) {
 
   KeyEventDoneCallback *handler = new KeyEventDoneCallback();
   *handler = callback;
 
   KeyboardEvent ext_event;
@@ skipping 67 matching lines @@
           // TODO(nona): Implement it.
           break;
       }
     }
   }
 
   // TODO(nona): Support item.children.
 }
 
 }  // namespace chromeos