linux: Do not fallback to the hardware keycodes for modifers.

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>
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
 #include <X11/extensions/XInput2.h>
 #include <X11/keysym.h>
+#if !defined(XK_dead_greek)
+// Old versions of <X11/keysymdef.h> don't define XK_dead_greek.  If it's not

[Wez, 2014/10/03 17:57:00]

Do we ever build on platforms that don't have this, though? Isn't Ubuntu Precise
the oldest platform we support building on?

[Yuki, 2014/10/06 07:50:18]

I found that trybots(Precise?) don't define this macro.
My local machine (Trusty) has the definition.

+// defined, define it for ourselves.  (It's not sure that exactly which version
+// of X11 first defined XK_dead_greek.)
+#define XK_dead_greek 0xfe8c
+#endif
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "ui/events/keycodes/dom4/keycode_converter.h"
 #include "ui/events/x/keysym_to_unicode.h"
 
 #define VKEY_UNSUPPORTED VKEY_UNKNOWN
@@ skipping 427 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 IsHardwareKeycodeFallbackAllowed(unsigned int keysym) {
+  // The following modifier keys and dead keys should not fall back to
+  // the hardware-keycode-based US layout.
+  //
+  // For example, suppose that keycode 108 (Right Alt key) is bound to
+  // XK_ISO_Level3_Latch in order to produce "à" by the latch key + a.
+  // If the latch key falls back to VKEY_RMENU, VKEY_RMENU is treated
+  // as accelerator key and it focuses the hamburger menu and the
+  // following 'a' key cannot produce "à".  So these modifier keys and
+  // dead keys shouldn't fall back to the hardware-key-based US layout.

[Wez, 2014/10/03 17:57:01]

nit: Suggest just "See crbug.com/<bug #>" here.

[Yuki, 2014/10/06 07:50:18]

Done.

+  switch (keysym) {
+    case XK_Shift_L:
+    case XK_Shift_R:

[Wez, 2014/10/03 17:57:01]

Why are these (and Control, etc) in here? We have explicit X KeySym -> VKEY
mappings for them, below, surely, so we'll never ever try to fall-back to h/w
for them?

Thinking about the Cyrillic case vs ISO_Level3_Shift, is it the case that we
want to fall-back only for _printable_ characters? For non-printable characters
we have to have an explicit mapping anyway.

Is there an X call we can use to check whether the KeySym is printable (whether
or not it would actually generate a character in the current context)?

[Yuki, 2014/10/06 07:50:18]

You're right.  I wanted to define this function independent from other functions
as much as possible.
Yes, I think we can use IsModifierKey.

+    case XK_Control_L:
+    case XK_Control_R:
+    case XK_Caps_Lock:
+    case XK_Shift_Lock:
+    case XK_Meta_L:
+    case XK_Meta_R:
+    case XK_Alt_L:
+    case XK_Alt_R:
+    case XK_Super_L:
+    case XK_Super_R:
+    case XK_Hyper_L:
+    case XK_Hyper_R:
+    case XK_ISO_Lock:
+    case XK_ISO_Level2_Latch:
+    case XK_ISO_Level3_Shift:
+    case XK_ISO_Level3_Latch:
+    case XK_ISO_Level3_Lock:
+    case XK_ISO_Level5_Shift:
+    case XK_ISO_Level5_Latch:
+    case XK_ISO_Level5_Lock:
+    case XK_ISO_Group_Latch:
+    case XK_ISO_Group_Lock:
+    case XK_ISO_Next_Group:
+    case XK_ISO_Next_Group_Lock:
+    case XK_ISO_Prev_Group:
+    case XK_ISO_Prev_Group_Lock:
+    case XK_ISO_First_Group:
+    case XK_ISO_First_Group_Lock:
+    case XK_ISO_Last_Group:
+    case XK_ISO_Last_Group_Lock:
+    case XK_dead_grave:
+    case XK_dead_acute:
+    case XK_dead_circumflex:
+    case XK_dead_tilde:
+    case XK_dead_macron:
+    case XK_dead_breve:
+    case XK_dead_abovedot:
+    case XK_dead_diaeresis:
+    case XK_dead_abovering:
+    case XK_dead_doubleacute:
+    case XK_dead_caron:
+    case XK_dead_cedilla:
+    case XK_dead_ogonek:
+    case XK_dead_iota:
+    case XK_dead_voiced_sound:
+    case XK_dead_semivoiced_sound:
+    case XK_dead_belowdot:
+    case XK_dead_hook:
+    case XK_dead_horn:
+    case XK_dead_stroke:
+    case XK_dead_abovecomma:
+    case XK_dead_abovereversedcomma:
+    case XK_dead_doublegrave:
+    case XK_dead_belowring:
+    case XK_dead_belowmacron:
+    case XK_dead_belowcircumflex:
+    case XK_dead_belowtilde:
+    case XK_dead_belowbreve:
+    case XK_dead_belowdiaeresis:
+    case XK_dead_invertedbreve:
+    case XK_dead_belowcomma:
+    case XK_dead_currency:
+    case XK_dead_a:
+    case XK_dead_A:
+    case XK_dead_e:
+    case XK_dead_E:
+    case XK_dead_i:
+    case XK_dead_I:
+    case XK_dead_o:
+    case XK_dead_O:
+    case XK_dead_u:
+    case XK_dead_U:
+    case XK_dead_small_schwa:
+    case XK_dead_capital_schwa:
+    case XK_dead_greek:
+    case XK_First_Virtual_Screen:
+    case XK_Prev_Virtual_Screen:
+    case XK_Next_Virtual_Screen:
+    case XK_Last_Virtual_Screen:
+    case XK_Terminate_Server:
+    case XK_AccessX_Enable:
+    case XK_AccessX_Feedback_Enable:
+    case XK_RepeatKeys_Enable:
+    case XK_SlowKeys_Enable:
+    case XK_BounceKeys_Enable:
+    case XK_StickyKeys_Enable:
+    case XK_MouseKeys_Enable:
+    case XK_MouseKeys_Accel_Enable:
+    case XK_Overlay1_Enable:
+    case XK_Overlay2_Enable:
+    case XK_AudibleBell_Enable:
+    case XK_Pointer_Left:
+    case XK_Pointer_Right:
+    case XK_Pointer_Up:
+    case XK_Pointer_Down:
+    case XK_Pointer_UpLeft:
+    case XK_Pointer_UpRight:
+    case XK_Pointer_DownLeft:
+    case XK_Pointer_DownRight:
+    case XK_Pointer_Button_Dflt:
+    case XK_Pointer_Button1:
+    case XK_Pointer_Button2:
+    case XK_Pointer_Button3:
+    case XK_Pointer_Button4:
+    case XK_Pointer_Button5:
+    case XK_Pointer_DblClick_Dflt:
+    case XK_Pointer_DblClick1:
+    case XK_Pointer_DblClick2:
+    case XK_Pointer_DblClick3:
+    case XK_Pointer_DblClick4:
+    case XK_Pointer_DblClick5:
+    case XK_Pointer_Drag_Dflt:
+    case XK_Pointer_Drag1:
+    case XK_Pointer_Drag2:
+    case XK_Pointer_Drag3:
+    case XK_Pointer_Drag4:
+    case XK_Pointer_Drag5:
+    case XK_Pointer_EnableKeys:
+    case XK_Pointer_Accelerate:
+    case XK_Pointer_DfltBtnNext:
+    case XK_Pointer_DfltBtnPrev:
+      return false;
+    default:
+      return true;
+  }
+}
+
 }  // 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 66 matching lines @@
     MAP3 key4 = {keysym & 0xFFFF, xkey->keycode, keysym_shift & 0xFFFF, 0xFFFF,
                  0};
     const MAP3* p =
         std::lower_bound(map3, map3 + arraysize(map3), key4, MAP3());
     if (p != map3 + arraysize(map3) && p->ch0 == key4.ch0 && p->sc == key4.sc &&
         p->ch1 == key4.ch1)
       return static_cast<KeyboardCode>(p->vk);
   }
 
   keycode = KeyboardCodeFromXKeysym(keysym);
-  if (keycode == VKEY_UNKNOWN)
+  if (keycode == VKEY_UNKNOWN && IsHardwareKeycodeFallbackAllowed(keysym))
     keycode = DefaultKeyboardCodeFromHardwareKeycode(xkey->keycode);
 
   return keycode;
 }
 
 KeyboardCode KeyboardCodeFromXKeysym(unsigned int keysym) {
   // TODO(sad): Have |keysym| go through the X map list?
 
   switch (keysym) {
     case XK_BackSpace:
@@ skipping 788 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