Set ui::KeyEvent::key_ (DOM Level 3 key) under X11.

ui/events/ozone/layout/xkb/xkb_keyboard_layout_engine.cc

 // Copyright 2014 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/ozone/layout/xkb/xkb_keyboard_layout_engine.h"
 
 #include <xkbcommon/xkbcommon-names.h>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
 #include "base/task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/worker_pool.h"
 #include "ui/events/event_constants.h"
 #include "ui/events/keycodes/dom3/dom_code.h"
 #include "ui/events/keycodes/dom3/dom_key.h"
 #include "ui/events/keycodes/dom4/keycode_converter.h"
 #include "ui/events/keycodes/keyboard_code_conversion.h"
-#include "ui/events/ozone/layout/layout_util.h"
+#include "ui/events/keycodes/keyboard_code_conversion_xkb.h"
 #include "ui/events/ozone/layout/xkb/xkb_keyboard_code_conversion.h"
 
 namespace ui {
 
 namespace {
 
 typedef base::Callback<void(const std::string&,
                             scoped_ptr<char, base::FreeDeleter>)>
     LoadKeymapCallback;
 
-DomKey CharacterToDomKey(base::char16 character) {
-  switch (character) {
-    case 0x08:
-      return DomKey::BACKSPACE;
-    case 0x09:
-      return DomKey::TAB;
-    case 0x0A:
-    case 0x0D:
-      return DomKey::ENTER;
-    case 0x1B:
-      return DomKey::ESCAPE;
-    default:
-      return DomKey::CHARACTER;
-  }
-}
-
 KeyboardCode AlphanumericKeyboardCode(base::char16 character) {
   // Plain ASCII letters and digits map directly to VKEY values.
   if ((character >= '0') && (character <= '9'))
     return static_cast<KeyboardCode>(VKEY_0 + character - '0');
   if ((character >= 'a') && (character <= 'z'))
     return static_cast<KeyboardCode>(VKEY_A + character - 'a');
   if ((character >= 'A') && (character <= 'Z'))
     return static_cast<KeyboardCode>(VKEY_A + character - 'A');
   return VKEY_UNKNOWN;
 }
@@ skipping 700 matching lines @@
                << KeycodeConverter::DomCodeToCodeString(dom_code) << "'";
     return false;
   }
   xkb_mod_mask_t xkb_flags = EventFlagsToXkbFlags(flags);
   // Obtain keysym and character.
   xkb_keysym_t xkb_keysym;
   if (!XkbLookup(xkb_keycode, xkb_flags, &xkb_keysym, character))
     return false;
   *platform_keycode = xkb_keysym;
   // Classify the keysym and convert to DOM and VKEY representations.
-  *dom_key = NonPrintableXkbKeySymToDomKey(xkb_keysym);
+  *dom_key = NonPrintableXKeySymToDomKey(xkb_keysym);
   if (*dom_key == DomKey::NONE) {
     *dom_key = CharacterToDomKey(*character);
     *key_code = AlphanumericKeyboardCode(*character);
     if (*key_code == VKEY_UNKNOWN) {
       *key_code = DifficultKeyboardCode(dom_code, flags, xkb_keycode, xkb_flags,
                                         xkb_keysym, *dom_key, *character);
       if (*key_code == VKEY_UNKNOWN)
         *key_code = DomCodeToUsLayoutKeyboardCode(dom_code);
     }
     // If the Control key is down, only allow ASCII control characters to be
@@ skipping 84 matching lines @@
     DomKey dom_key,
     base::char16 character) const {
   // Get the layout interpretation without modifiers, so that
   // e.g. Ctrl+D correctly generates VKEY_D.
   xkb_keysym_t plain_keysym;
   base::char16 plain_character;
   if (!XkbLookup(xkb_keycode, 0, &plain_keysym, &plain_character))
     return VKEY_UNKNOWN;
 
   // If the plain key is non-printable, that determines the VKEY.
-  DomKey plain_key = NonPrintableXkbKeySymToDomKey(plain_keysym);
+  DomKey plain_key = NonPrintableXKeySymToDomKey(plain_keysym);
   if (plain_key != ui::DomKey::NONE)
     return NonPrintableDomKeyToKeyboardCode(dom_key);
 
   // Plain ASCII letters and digits map directly to VKEY values.
   KeyboardCode key_code = AlphanumericKeyboardCode(plain_character);
   if (key_code != VKEY_UNKNOWN)
     return key_code;
 
   // Check the multi-character tables.
   const PrintableMultiEntry* multi_end = kMultiMap + arraysize(kMultiMap);
@@ skipping 71 matching lines @@
       close_index = layout_name.size();
     *layout_variant = layout_name.substr(parentheses_index + 1,
                                          close_index - parentheses_index - 1);
   } else if (dash_index != std::string::npos) {
     *layout_id = layout_name.substr(0, dash_index);
     *layout_variant = layout_name.substr(dash_index + 1);
   }
 }
 
 }  // namespace ui