Removing X11 native_event uses for key events.

ui/events/event.cc

Index: ui/events/event.cc
diff --git a/ui/events/event.cc b/ui/events/event.cc
index 4a8370bb16aebee181bd887a4fcf4664ccea18f9..7040c65c8ee67ca6cc0fffaa033d85ad798ab48b 100644
--- a/ui/events/event.cc
+++ b/ui/events/event.cc
@@ -7,6 +7,7 @@
 #if defined(USE_X11)
 #include <X11/extensions/XInput2.h>
 #include <X11/Xlib.h>
+#include <X11/keysym.h>
 #endif
 
 #include <cmath>
@@ -591,6 +592,11 @@ KeyEvent::KeyEvent(const base::NativeEvent& native_event)
 #if defined(USE_X11)
   NormalizeFlags();
 #endif
+#if defined(OS_WIN)
+  // Only Windows has native character events.
+  if (is_char_)
+    character_ = native_event.wParam;
+#endif
 }
 
 KeyEvent::KeyEvent(EventType type,
@@ -600,7 +606,7 @@ KeyEvent::KeyEvent(EventType type,
       key_code_(key_code),
       is_char_(false),
       platform_keycode_(0),
-      character_(GetCharacterFromKeyCode(key_code, flags)) {
+      character_() {
 }
 
 KeyEvent::KeyEvent(EventType type,
@@ -612,7 +618,7 @@ KeyEvent::KeyEvent(EventType type,
       code_(code),
       is_char_(false),
       platform_keycode_(0),
-      character_(GetCharacterFromKeyCode(key_code, flags)) {
+      character_(0) {
 }
 
 KeyEvent::KeyEvent(base::char16 character, KeyboardCode key_code, int flags)
@@ -624,15 +630,21 @@ KeyEvent::KeyEvent(base::char16 character, KeyboardCode key_code, int flags)
 }
 
 base::char16 KeyEvent::GetCharacter() const {
-  if (character_)
+  if (is_char_ || character_)
     return character_;
 
+  // TODO(kpschoedel): streamline these cases after settling Ozone
+  // positional coding.
 #if defined(OS_WIN)
-  return (native_event().message == WM_CHAR) ? key_code_ :
-      GetCharacterFromKeyCode(key_code_, flags());
+  // Native Windows character events always have is_char_ == true,
+  // so this is a synthetic or native keystroke event.
+  character_ = GetCharacterFromKeyCode(key_code_, flags());
+  return character_;
 #elif defined(USE_X11)
-  if (!native_event())
-    return GetCharacterFromKeyCode(key_code_, flags());
+  if (!native_event()) {
+    character_ = GetCharacterFromKeyCode(key_code_, flags());
+    return character_;
+  }
 
   DCHECK(native_event()->type == KeyPress ||
          native_event()->type == KeyRelease ||
@@ -730,6 +742,78 @@ void KeyEvent::SetTranslated(bool translated) {
   }
 }
 
+bool KeyEvent::IsRightSideKey() const {
+  switch (key_code_) {
+    case VKEY_CONTROL:
+    case VKEY_SHIFT:
+    case VKEY_MENU:
+    case VKEY_LWIN:
+#if defined(USE_X11)
+      // Under X11, setting code_ requires platform-dependent information, and
+      // currently assumes that X keycodes are based on Linux evdev keycodes.
+      // In certain test environments this is not the case, and code_ is not
+      // set accurately, so we need a different mechanism. Fortunately X11 key
+      // mapping preserves the left-right distinction, so testing keysyms works
+      // if the value is available (as it is for all X11 native-based events).
+      if (platform_keycode_) {
+        return (platform_keycode_ == XK_Shift_R) ||
+               (platform_keycode_ == XK_Control_R) ||
+               (platform_keycode_ == XK_Alt_R) ||
+               (platform_keycode_ == XK_Meta_R) ||
+               (platform_keycode_ == XK_Super_R) ||
+               (platform_keycode_ == XK_Hyper_R);
+      }
+      // Fall through to the generic code if we have no platform_keycode_.
+      // Under X11, this must be a synthetic event, so we can require that
+      // code_ be set correctly.
+#endif
+      return ((code_.size() > 5) &&
+              (code_.compare(code_.size() - 5, 5, "Right", 5)) == 0);
+    default:
+      return false;
+  }
+}
+
+KeyboardCode KeyEvent::GetLocatedWindowsKeyboardCode() const {
+  switch (key_code_) {
+    case VKEY_SHIFT:
+      return IsRightSideKey() ? VKEY_RSHIFT : VKEY_LSHIFT;
+    case VKEY_CONTROL:
+      return IsRightSideKey() ? VKEY_RCONTROL : VKEY_LCONTROL;
+    case VKEY_MENU:
+      return IsRightSideKey() ? VKEY_RMENU : VKEY_LMENU;
+    case VKEY_LWIN:
+      return IsRightSideKey() ? VKEY_RWIN : VKEY_LWIN;
+    case VKEY_0:
+      return (flags() & EF_NUMPAD_KEY) ? VKEY_NUMPAD0 : VKEY_0;

[sadrul, 2014/08/19 03:46:19]

EF_NUMPAD_KEY is set only on X11. Does that make a difference?

[kpschoedel, 2014/08/19 21:58:10]

It's only used for X11 / Ozone at present, and it's likely that the Ozone
revisions will make this cross-platform. I'll add a TODO here as well.

+    case VKEY_1:
+      return (flags() & EF_NUMPAD_KEY) ? VKEY_NUMPAD1 : VKEY_1;
+    case VKEY_2:
+      return (flags() & EF_NUMPAD_KEY) ? VKEY_NUMPAD2 : VKEY_2;
+    case VKEY_3:
+      return (flags() & EF_NUMPAD_KEY) ? VKEY_NUMPAD3 : VKEY_3;
+    case VKEY_4:
+      return (flags() & EF_NUMPAD_KEY) ? VKEY_NUMPAD4 : VKEY_4;
+    case VKEY_5:
+      return (flags() & EF_NUMPAD_KEY) ? VKEY_NUMPAD5 : VKEY_5;
+    case VKEY_6:
+      return (flags() & EF_NUMPAD_KEY) ? VKEY_NUMPAD6 : VKEY_6;
+    case VKEY_7:
+      return (flags() & EF_NUMPAD_KEY) ? VKEY_NUMPAD7 : VKEY_7;
+    case VKEY_8:
+      return (flags() & EF_NUMPAD_KEY) ? VKEY_NUMPAD8 : VKEY_8;
+    case VKEY_9:
+      return (flags() & EF_NUMPAD_KEY) ? VKEY_NUMPAD9 : VKEY_9;
+    // Locatable codes not currently distinguished:

[sadrul, 2014/08/19 03:46:19]

Should be a TODO (maybe with an accompanying crbug)

[kpschoedel, 2014/08/19 21:58:10]

I'll just delete this. There will probably never be distinct VKEY codes for
those keys, and they're definitely not needed for the
Windows-legacy-compatibility that this function is meant for.

+    // case VKEY_RETURN:
+    //   return (flags() & EF_NUMPAD_KEY) ? VKEY_RETURN : ** numpad enter **;
+    // case VKEY_OEM_PLUS:
+    //   return (flags() & EF_NUMPAD_KEY) ? VKEY_OEM_PLUS : ** numpad equal **;
+    default:
+      return key_code_;
+  }
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // ScrollEvent