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

ui/events/keycodes/dom/keycode_converter.cc

 // Copyright 2013 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/dom/keycode_converter.h"
 
 #include "base/logging.h"
+#include "base/strings/utf_string_conversion_utils.h"
 #include "ui/events/keycodes/dom/dom_code.h"
 #include "ui/events/keycodes/dom/dom_key.h"
 
 namespace ui {
 
 namespace {
 
 // Table of USB codes (equivalent to DomCode values), native scan codes,
 // and DOM Level 3 |code| strings.
 #if defined(OS_WIN)
@@ skipping 11 matching lines @@
 #undef USB_KEYMAP_DECLARATION
 
 const size_t kKeycodeMapEntries = arraysize(usb_keycode_map);
 
 // Table of DomKey enum values and DOM Level 3 |key| strings.
 struct DomKeyMapEntry {
   DomKey dom_key;
   const char* string;
 };
 
-#define DOM_KEY_MAP(key, id) {DomKey::id, key}
 #define DOM_KEY_MAP_DECLARATION const DomKeyMapEntry dom_key_map[] =
+#define DOM_KEY_UNI(key, id, value) {DomKey::id, key}
+#define DOM_KEY_MAP_BEGIN
+#define DOM_KEY_MAP(key, id)        {DomKey::id, key}
+#define DOM_KEY_MAP_END
 #include "ui/events/keycodes/dom/dom_key_data.inc"
+#undef DOM_KEY_MAP_DECLARATION
+#undef DOM_KEY_MAP_BEGIN
 #undef DOM_KEY_MAP
-#undef DOM_KEY_MAP_DECLARATION
+#undef DOM_KEY_MAP_END
+#undef DOM_KEY_UNI
 
 const size_t kDomKeyMapEntries = arraysize(dom_key_map);
 
 }  // namespace
 
 // static
 size_t KeycodeConverter::NumKeycodeMapEntriesForTest() {
   return kKeycodeMapEntries;
 }
 
@@ skipping 105 matching lines @@
     if (key.code == dom_code)
       return key.location;
   }
   return DomKeyLocation::STANDARD;
 }
 
 // static
 DomKey KeycodeConverter::KeyStringToDomKey(const char* key) {
   if (!key || !*key)
     return DomKey::NONE;
+  // Check for standard key names.
   for (size_t i = 0; i < kDomKeyMapEntries; ++i) {
-    if (dom_key_map[i].string &&
-        strcmp(dom_key_map[i].string, key) == 0) {
+    if (dom_key_map[i].string && strcmp(dom_key_map[i].string, key) == 0) {
       return dom_key_map[i].dom_key;
     }
   }
+  if (strcmp(key, "Dead") == 0) {
+    // The web KeyboardEvent string does not encode the combining character,
+    // so we just set it to the Unicode designated non-character 0xFFFF.
+    // This will round-trip convert back to 'Dead' but take no part in
+    // character composition.
+    return DomKey::DeadKeyFromCombiningCharacter(0xFFFF);
+  }
+  // Otherwise, if the string contains a single Unicode character,
+  // the key value is that character.
+  int32_t char_index = 0;
+  uint32_t character;
+  if (base::ReadUnicodeCharacter(key, static_cast<int32_t>(strlen(key)),
+                                 &char_index, &character) &&
+      key[++char_index] == 0) {
+    return DomKey::FromCharacter(character);
+  }
   return DomKey::NONE;
 }
 
 // static
-const char* KeycodeConverter::DomKeyToKeyString(DomKey dom_key) {
+std::string KeycodeConverter::DomKeyToKeyString(DomKey dom_key) {
+  if (dom_key.IsDeadKey()) {
+    // All dead-key combining codes collapse to 'Dead', as UI Events
+    // KeyboardEvent represents the combining character separately.
+    return "Dead";
+  }
   for (size_t i = 0; i < kDomKeyMapEntries; ++i) {
-    if (dom_key_map[i].dom_key == dom_key)
-      return dom_key_map[i].string;
+    if (dom_key_map[i].dom_key == dom_key) {
+      if (dom_key_map[i].string)
+        return dom_key_map[i].string;
+      break;
+    }
   }
-  return "";
+  if (dom_key.IsCharacter()) {
+    std::string s;
+    base::WriteUnicodeCharacter(dom_key.ToCharacter(), &s);
+    return s;
+  }
+  return std::string();
 }
 
 // static
 bool KeycodeConverter::IsDomKeyForModifier(DomKey dom_key) {
   switch (dom_key) {
     case DomKey::ACCEL:
     case DomKey::ALT:
     case DomKey::ALT_GRAPH:
     case DomKey::CAPS_LOCK:
     case DomKey::CONTROL:
@@ skipping 76 matching lines @@
   for (size_t i = 0; i < kKeycodeMapEntries; ++i) {
     if (usb_keycode_map[i].code &&
         strcmp(usb_keycode_map[i].code, code) == 0) {
       return usb_keycode_map[i].usb_keycode;
     }
   }
   return InvalidUsbKeycode();
 }
 
 }  // namespace ui