Revise ui::DomKey to unify character and non-character codes.

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/dom/dom_code.h"
 #include "ui/events/keycodes/dom/dom_key.h"
 #include "ui/events/keycodes/dom/keycode_converter.h"
 #include "ui/events/keycodes/keyboard_code_conversion.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;
 
 KeyboardCode AlphanumericKeyboardCode(base::char16 character) {
@@ skipping 676 matching lines @@
 }
 
 bool XkbKeyboardLayoutEngine::UsesAltGr() const {
   // NOTIMPLEMENTED();
   return false;
 }
 
 bool XkbKeyboardLayoutEngine::Lookup(DomCode dom_code,
                                      int flags,
                                      DomKey* dom_key,
-                                     base::char16* character,
                                      KeyboardCode* key_code,
-                                     uint32* platform_keycode) const {
+                                     uint32_t* platform_keycode) const {
   if (dom_code == DomCode::NONE)
     return false;
   // Convert DOM physical key to XKB representation.
   xkb_keycode_t xkb_keycode = key_code_converter_.DomCodeToXkbKeyCode(dom_code);
   if (xkb_keycode == key_code_converter_.InvalidXkbKeyCode()) {
     LOG(ERROR) << "No XKB keycode for DomCode 0x" << std::hex
                << static_cast<int>(dom_code) << " '"
                << 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))
+  uint32_t character = 0;
+  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 = NonPrintableXKeySymToDomKey(xkb_keysym);
   if (*dom_key == DomKey::NONE) {
-    *dom_key = CharacterToDomKey(*character);
-    *key_code = AlphanumericKeyboardCode(*character);
+    *dom_key = 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) {
+                                        xkb_keysym, character);
+      if (*key_code == VKEY_UNKNOWN)
         *key_code = LocatedToNonLocatedKeyboardCode(
             DomCodeToUsLayoutKeyboardCode(dom_code));
-      }
     }
     // If the Control key is down, only allow ASCII control characters to be
     // returned, regardless of the key layout. crbug.com/450849
-    if ((flags & EF_CONTROL_DOWN) && (*character >= 0x20))
-      *character = 0;
-  } else if (*dom_key == DomKey::DEAD) {

[kpschoedel, 2015/08/07 20:42:12]

Dead keys now have distinct codes, handled by NonPrintableXKeySymToDomKey().

-    *character = DeadXkbKeySymToCombiningCharacter(xkb_keysym);
-    *key_code = LocatedToNonLocatedKeyboardCode(
-        DomCodeToUsLayoutKeyboardCode(dom_code));
+    if ((flags & EF_CONTROL_DOWN) && (character >= 0x20))
+      *dom_key = DomKey::UNIDENTIFIED;
   } else {
     *key_code = NonPrintableDomKeyToKeyboardCode(*dom_key);
     if (*key_code == VKEY_UNKNOWN) {
       *key_code = LocatedToNonLocatedKeyboardCode(
           DomCodeToUsLayoutKeyboardCode(dom_code));
     }
   }
   return true;
 }
 
@@ skipping 39 matching lines @@
       xkb_flags |= entry.xkb_flag;
   }
   // NumLock is always on.
   xkb_flags |= num_lock_mod_mask_;
   return xkb_flags;
 }
 
 bool XkbKeyboardLayoutEngine::XkbLookup(xkb_keycode_t xkb_keycode,
                                         xkb_mod_mask_t xkb_flags,
                                         xkb_keysym_t* xkb_keysym,
-                                        base::char16* character) const {
+                                        uint32_t* character) const {
   if (!xkb_state_) {
     LOG(ERROR) << "No current XKB state";
     return false;
   }
   xkb_state_update_mask(xkb_state_.get(), xkb_flags, 0, 0, 0, 0, 0);
   *xkb_keysym = xkb_state_key_get_one_sym(xkb_state_.get(), xkb_keycode);
   if (*xkb_keysym == XKB_KEY_NoSymbol)
     return false;
-  uint32_t c = xkb_state_key_get_utf32(xkb_state_.get(), xkb_keycode);
-  DLOG_IF(ERROR, c != (c & 0xFFFF)) << "Non-BMP character:" << c;
-  *character = static_cast<base::char16>(c);
+  *character = xkb_state_key_get_utf32(xkb_state_.get(), xkb_keycode);
+  DLOG_IF(ERROR, *character != (*character & 0xFFFF))
+      << "Non-BMP character:" << *character;
   return true;
 }
 
 KeyboardCode XkbKeyboardLayoutEngine::DifficultKeyboardCode(
     DomCode dom_code,
     int ui_flags,
     xkb_keycode_t xkb_keycode,
     xkb_mod_mask_t xkb_flags,
     xkb_keysym_t xkb_keysym,
-    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;
+  uint32_t 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 = NonPrintableXKeySymToDomKey(plain_keysym);
   if (plain_key != ui::DomKey::NONE)
-    return NonPrintableDomKeyToKeyboardCode(dom_key);
+    return NonPrintableDomKeyToKeyboardCode(plain_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);
   const PrintableMultiEntry* multi =
       std::lower_bound(kMultiMap, multi_end, plain_character,
@@ skipping 42 matching lines @@
 
 base::char16 XkbKeyboardLayoutEngine::XkbSubCharacter(
     xkb_keycode_t xkb_keycode,
     xkb_mod_mask_t base_flags,
     base::char16 base_character,
     int ui_flags) const {
   xkb_mod_mask_t flags = EventFlagsToXkbFlags(ui_flags);
   if (flags == base_flags)
     return base_character;
   xkb_keysym_t keysym;
-  base::char16 character = 0;
+  uint32_t character = 0;
   if (!XkbLookup(xkb_keycode, flags, &keysym, &character))
     character = kNone;
   return character;
 }
 
 void XkbKeyboardLayoutEngine::ParseLayoutName(const std::string& layout_name,
                                               std::string* layout_id,
                                               std::string* layout_variant) {
   size_t dash_index = layout_name.find('-');
   size_t parentheses_index = layout_name.find('(');
   *layout_id = layout_name;
   *layout_variant = "";
   if (parentheses_index != std::string::npos) {
     *layout_id = layout_name.substr(0, parentheses_index);
     size_t close_index = layout_name.find(')', parentheses_index);
     if (close_index == std::string::npos)
       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