Revert of Removing X11 native_event uses for key events.

ui/events/event.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/event.h"
 
 #if defined(USE_X11)
 #include <X11/extensions/XInput2.h>
 #include <X11/Xlib.h>
-#include <X11/keysym.h>
 #endif
 
 #include <cmath>
 #include <cstring>
 
 #include "base/metrics/histogram.h"
 #include "base/strings/stringprintf.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/keycodes/keyboard_code_conversion.h"
 #include "ui/gfx/point3_f.h"
@@ skipping 564 matching lines @@
       code_(CodeFromNative(native_event)),
       is_char_(IsCharFromNative(native_event)),
       platform_keycode_(PlatformKeycodeFromNative(native_event)),
       character_(0) {
   if (IsRepeated(*this))
     set_flags(flags() | ui::EF_IS_REPEAT);
 
 #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,
                    KeyboardCode key_code,
                    int flags)
     : Event(type, EventTimeForNow(), flags),
       key_code_(key_code),
       is_char_(false),
       platform_keycode_(0),
-      character_() {
+      character_(GetCharacterFromKeyCode(key_code, flags)) {
 }
 
 KeyEvent::KeyEvent(EventType type,
                    KeyboardCode key_code,
                    const std::string& code,
                    int flags)
     : Event(type, EventTimeForNow(), flags),
       key_code_(key_code),
       code_(code),
       is_char_(false),
       platform_keycode_(0),
-      character_(0) {
+      character_(GetCharacterFromKeyCode(key_code, flags)) {
 }
 
 KeyEvent::KeyEvent(base::char16 character, KeyboardCode key_code, int flags)
     : Event(ET_KEY_PRESSED, EventTimeForNow(), flags),
       key_code_(key_code),
       code_(""),
       is_char_(true),
       platform_keycode_(0),
       character_(character) {
 }
@@ skipping 24 matching lines @@
   return *this;
 }
 
 KeyEvent::~KeyEvent() {}
 
 void KeyEvent::SetExtendedKeyEventData(scoped_ptr<ExtendedKeyEventData> data) {
   extended_key_event_data_ = data.Pass();
 }
 
 base::char16 KeyEvent::GetCharacter() const {
-  if (is_char_ || character_)
+  if (character_)
     return character_;
 
-  // TODO(kpschoedel): streamline these cases after settling Ozone
-  // positional coding.
 #if defined(OS_WIN)
-  // 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_;
+  return (native_event().message == WM_CHAR) ? key_code_ :
+      GetCharacterFromKeyCode(key_code_, flags());
 #elif defined(USE_X11)
-  if (!native_event()) {
-    character_ = GetCharacterFromKeyCode(key_code_, flags());
-    return character_;
-  }
+  if (!native_event())
+    return GetCharacterFromKeyCode(key_code_, flags());
 
   DCHECK(native_event()->type == KeyPress ||
          native_event()->type == KeyRelease ||
          (native_event()->type == GenericEvent &&
           (native_event()->xgeneric.evtype == XI_KeyPress ||
            native_event()->xgeneric.evtype == XI_KeyRelease)));
 
   // When a control key is held, prefer ASCII characters to non ASCII
   // characters in order to use it for shortcut keys.  GetCharacterFromKeyCode
   // returns 'a' for VKEY_A even if the key is actually bound to 'à' in X11.
   // GetCharacterFromXEvent returns 'à' in that case.
   return IsControlDown() ?
       GetCharacterFromKeyCode(key_code_, flags()) :
       GetCharacterFromXEvent(native_event());
 #else
   if (native_event()) {
     DCHECK(EventTypeFromNative(native_event()) == ET_KEY_PRESSED ||
            EventTypeFromNative(native_event()) == ET_KEY_RELEASED);
   }
 
   return GetCharacterFromKeyCode(key_code_, flags());
 #endif
 }
 
-base::char16 KeyEvent::GetText() const {
-  if ((flags() & EF_CONTROL_DOWN) != 0) {
-    return GetControlCharacterForKeycode(key_code_,
-                                         (flags() & EF_SHIFT_DOWN) != 0);
-  }
-  return GetUnmodifiedText();
-}
-
-base::char16 KeyEvent::GetUnmodifiedText() const {
-  if (!is_char_ && (key_code_ == VKEY_RETURN))
-    return '\r';
-  return GetCharacter();
-}
-
 bool KeyEvent::IsUnicodeKeyCode() const {
 #if defined(OS_WIN)
   if (!IsAltDown())
     return false;
   const int key = key_code();
   if (key >= VKEY_NUMPAD0 && key <= VKEY_NUMPAD9)
     return true;
   // Check whether the user is using the numeric keypad with num-lock off.
   // In that case, EF_EXTENDED will not be set; if it is set, the key event
   // originated from the relevant non-numpad dedicated key, e.g. [Insert].
@@ skipping 53 matching lines @@
       break;
     case ET_KEY_RELEASED:
     case ET_TRANSLATED_KEY_RELEASE:
       SetType(translated ? ET_TRANSLATED_KEY_RELEASE : ET_KEY_RELEASED);
       break;
     default:
       NOTREACHED();
   }
 }
 
-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;
-    // TODO(kpschoedel): EF_NUMPAD_KEY is present only on X11. Currently this
-    // function is only called on X11. Likely the tests here will be replaced
-    // with a DOM-based code enumeration test in the course of Ozone
-    // platform-indpendent key event work.
-    case VKEY_0:
-      return (flags() & EF_NUMPAD_KEY) ? VKEY_NUMPAD0 : VKEY_0;
-    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;
-    default:
-      return key_code_;
-  }
-}
-
-uint16 KeyEvent::GetConflatedWindowsKeyCode() const {
-  if (is_char_)
-    return character_;
-  return key_code_;
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 // ScrollEvent
 
 ScrollEvent::ScrollEvent(const base::NativeEvent& native_event)
     : MouseEvent(native_event) {
   if (type() == ET_SCROLL) {
     GetScrollOffsets(native_event,
                      &x_offset_, &y_offset_,
                      &x_offset_ordinal_, &y_offset_ordinal_,
                      &finger_count_);
@@ skipping 48 matching lines @@
                    gfx::PointF(x, y),
                    time_stamp,
                    flags | EF_FROM_TOUCH),
       details_(details) {
 }
 
 GestureEvent::~GestureEvent() {
 }
 
 }  // namespace ui