If keysym is ASCII control or space keys, directly map to keycode.

ui/events/keycodes/keyboard_code_conversion_x.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 "ui/events/keycodes/keyboard_code_conversion_x.h"
 
 #include <algorithm>
 
 #define XK_3270  // for XK_3270_BackTab
 #include <X11/XF86keysym.h>
@@ skipping 441 matching lines @@
 
 template <class T_MAP>
 KeyboardCode FindVK(const T_MAP& key, const T_MAP* map, size_t size) {
   T_MAP comp = {0};
   const T_MAP* p = std::lower_bound(map, map + size, key, comp);
   if (p != map + size && !comp(*p, key) && !comp(key, *p))
     return static_cast<KeyboardCode>(p->vk);
   return VKEY_UNKNOWN;
 }
 
+bool IsAsciiControlKey(KeySym keysym) {
+  if ((keysym > 0xff00 && keysym < 0xff1f) || keysym == XK_Delete)

[Yuki, 2014/10/23 07:13:56]

keysym <= 0xff1f ?
I think we'd like to include 0xff1f, too.

We may want to comment that 0xff01 to 0xff1f represent ASCII control in keysym
world (it's not 0x01 to 0x1f).  It's not so trivial.  For example, XK_space is
0x20.  Not everyone knows Xkeysym details.

nit:
return (0xff01 <= keysym && keysym <= 0xff1f) || keysym == XK_Delete;
seems more natural to me, but it's up to you.

[Shu Chen, 2014/10/23 07:44:33]

Done.

+    return true;
+  return false;
+}
+
 }  // namespace
 
 // Get an ui::KeyboardCode from an X keyevent
 KeyboardCode KeyboardCodeFromXKeyEvent(const XEvent* xev) {
   // Gets correct VKEY code from XEvent is performed as the following steps:
   // 1. Gets the keysym without modifier states.
   // 2. For [a-z] & [0-9] cases, returns the VKEY code accordingly.
   // 3. Find keysym in map0.
   // 4. If not found, fallback to find keysym + hardware_code in map1.
   // 5. If not found, fallback to find keysym + keysym_shift + hardware_code
@@ skipping 13 matching lines @@
   } else {
     xkeyevent.xkey = xev->xkey;
   }
   KeyboardCode keycode = VKEY_UNKNOWN;
   XKeyEvent* xkey = &xkeyevent.xkey;
   // XLookupKeysym does not take into consideration the state of the lock/shift
   // etc. keys. So it is necessary to use XLookupString instead.
   XLookupString(xkey, NULL, 0, &keysym, NULL);
   if (IsKeypadKey(keysym) || IsPrivateKeypadKey(keysym) ||
       IsCursorKey(keysym) || IsPFKey(keysym) || IsFunctionKey(keysym) ||
-      IsModifierKey(keysym)) {
+      IsModifierKey(keysym) || IsAsciiControlKey(keysym) ||
+      keysym == XK_space) {
     return KeyboardCodeFromXKeysym(keysym);
   }
 
   // If |xkey| has modifiers set, other than NumLock, then determine the
   // un-modified KeySym and use that to map, so that e.g. Ctrl+D correctly
   // generates VKEY_D.
   if (xkey->state & 0xFF & ~Mod2Mask) {
     xkey->state &= (~0xFF | Mod2Mask);
     XLookupString(xkey, NULL, 0, &keysym, NULL);
   }
@@ skipping 852 matching lines @@
   // alone does not map to XK_less; XKeysymToKeycode() returns KEY_102ND
   // (the '<>' key between Shift and Z on 105-key keyboards) which does.
   //
   // crbug.com/386066 and crbug.com/390263 are examples of problems
   // associated with this.
   //
   return XKeysymToKeycode(display, XKeysymForWindowsKeyCode(key_code, false));
 }
 
 }  // namespace ui