Remoes X11 dependency in InputMethodEngine.

ui/base/ime/chromeos/character_composer.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 "ui/base/ime/chromeos/character_composer.h"
 
-#include <X11/Xlib.h>
-#include <X11/Xutil.h>
-
 #include <algorithm>
 #include <iterator>
 
 #include "base/strings/utf_string_conversions.h"
 #include "base/third_party/icu/icu_utf.h"
 // Note for Gtk removal: gdkkeysyms.h only contains a set of
 // '#define GDK_KeyName 0xNNNN' macros and does not #include any Gtk headers.
 #include "third_party/gtk+/gdk/gdkkeysyms.h"
+
 #include "ui/base/glib/glib_integers.h"
 #include "ui/events/event.h"
-#include "ui/events/event_constants.h"
-#include "ui/gfx/x/x11_types.h"
+#include "ui/events/keycodes/keyboard_codes.h"
 
 // Note for Gtk removal: gtkimcontextsimpleseqs.h does not #include any Gtk
 // headers and only contains one big guint16 array |gtk_compose_seqs_compact|
 // which defines the main compose table. The table has internal linkage.
 // The order of header inclusion is out of order because
 // gtkimcontextsimpleseqs.h depends on guint16, which is defined in
 // "ui/base/glib/glib_integers.h".
 #include "third_party/gtk+/gtk/gtkimcontextsimpleseqs.h"
 
 namespace {
@@ skipping 332 matching lines @@
   if (!CBU_IS_UNICODE_CHAR(character))
     return false;
   if (character) {
     output->resize(CBU16_LENGTH(character));
     size_t i = 0;
     CBU16_APPEND_UNSAFE(&(*output)[0], i, character);
   }
   return true;
 }
 
-// Converts a X keycode to a X keysym with no modifiers.
-KeySym XKeyCodeToXKeySym(unsigned int keycode) {
-  XDisplay* display = gfx::GetXDisplay();
-  if (!display)
-    return NoSymbol;
-
-  XKeyEvent x_key_event = {0};
-  x_key_event.type = KeyPress;
-  x_key_event.display = display;
-  x_key_event.keycode = keycode;
-  return ::XLookupKeysym(&x_key_event, 0);
-}
-
 // Returns an hexadecimal digit integer (0 to 15) corresponding to |keyval|.
 // -1 is returned when |keyval| cannot be a hexadecimal digit.
 int KeyvalToHexDigit(unsigned int keyval) {
   if (GDK_KEY_0 <= keyval && keyval <= GDK_KEY_9)
     return keyval - GDK_KEY_0;
   if (GDK_KEY_a <= keyval && keyval <= GDK_KEY_f)
     return keyval - GDK_KEY_a + 10;
   if (GDK_KEY_A <= keyval && keyval <= GDK_KEY_F)
     return keyval - GDK_KEY_A + 10;
   return -1;  // |keyval| cannot be a hexadecimal digit.
 }
 
+// Returns an hexadecimal digit integer (0 to 15) corresponding to |keycode|.
+// -1 is returned when |keycode| cannot be a hexadecimal digit.
+int KeycodeToHexDigit(unsigned int keycode) {
+  if (ui::VKEY_0 <= keycode && keycode <= ui::VKEY_9)
+    return keycode - ui::VKEY_0;
+  if (ui::VKEY_A <= keycode && keycode <= ui::VKEY_F)
+    return keycode - ui::VKEY_A + 10;
+  return -1;  // |keycode| cannot be a hexadecimal digit.
+}
+
 }  // namespace
 
 namespace ui {
 
 CharacterComposer::CharacterComposer() : composition_mode_(KEY_SEQUENCE_MODE) {}
 
 CharacterComposer::~CharacterComposer() {}
 
 void CharacterComposer::Reset() {
   compose_buffer_.clear();
   composed_character_.clear();
   preedit_string_.clear();
   composition_mode_ = KEY_SEQUENCE_MODE;
 }
 
 bool CharacterComposer::FilterKeyPress(const ui::KeyEvent& event) {
-  if (!event.HasNativeEvent() ||
+  uint32 keyval = event.platform_keycode();
+  if (!keyval ||
       (event.type() != ET_KEY_PRESSED && event.type() != ET_KEY_RELEASED))
     return false;
 
-  XEvent* xevent = event.native_event();
-  DCHECK(xevent);
-  KeySym keysym = NoSymbol;
-  ::XLookupString(&xevent->xkey, NULL, 0, &keysym, NULL);
-
-  return FilterKeyPressInternal(keysym, xevent->xkey.keycode, event.flags());
+  return FilterKeyPressInternal(keyval, event.key_code(), event.flags());
 }
 
 
 bool CharacterComposer::FilterKeyPressInternal(unsigned int keyval,
                                                unsigned int keycode,
                                                int flags) {
   composed_character_.clear();
   preedit_string_.clear();
 
   // We don't care about modifier key presses.
@@ skipping 65 matching lines @@
                                               unsigned int keycode,
                                               int flags) {
   DCHECK(composition_mode_ == HEX_MODE);
   const size_t kMaxHexSequenceLength = 8;
   int hex_digit = KeyvalToHexDigit(keyval);
   if (hex_digit < 0) {
     // With 101 keyboard, control + shift + 3 produces '#', but a user may
     // have intended to type '3'.  So, if a hexadecimal character was not found,
     // suppose a user is holding shift key (and possibly control key, too) and
     // try a character with modifier keys removed.
-    hex_digit = KeyvalToHexDigit(XKeyCodeToXKeySym(keycode));
+    hex_digit = KeycodeToHexDigit(keycode);
   }
 
   if (keyval == GDK_KEY_Escape) {
     // Cancel composition when ESC is pressed.
     Reset();
   } else if (keyval == GDK_KEY_Return || keyval == GDK_KEY_KP_Enter ||
              keyval == GDK_KEY_ISO_Enter ||
              keyval == GDK_KEY_space || keyval == GDK_KEY_KP_Space) {
     // Commit the composed character when Enter or space is pressed.
     CommitHex();
@@ skipping 37 matching lines @@
   std::string preedit_string_ascii("u");
   for (size_t i = 0; i != compose_buffer_.size(); ++i) {
     const int digit = compose_buffer_[i];
     DCHECK(0 <= digit && digit < 16);
     preedit_string_ascii += digit <= 9 ? ('0' + digit) : ('a' + (digit - 10));
   }
   preedit_string_ = base::ASCIIToUTF16(preedit_string_ascii);
 }
 
 }  // namespace ui