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::Dead(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 character;
+  }
   return DomKey::NONE;
 }
 
 // static

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

This now returns a std::string; there are no current users of this function that
are interested in *only* the static case.

-const char* KeycodeConverter::DomKeyToKeyString(DomKey dom_key) {
+std::string KeycodeConverter::DomKeyToKeyString(DomKey dom_key) {
+  if (dom_key.IsDead()) {
+    // 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) {

[dtapuska, 2015/08/13 14:47:26]

Can this not use bsearch?

The DomKeyMap is an ordered array is it not?

It really depends on which one is used more frequently; the DomKeyToKeyString or
KeyStringToDomKey... but if the structure was made in an ordered fashion one
could be binary searched.

[kpschoedel, 2015/08/13 15:46:06]

I've generally been leaving these things alone, as with ui::DomCode (which
originates from USB-scancode tables) and would put such changes in a separate
CL. 
Not currently, though it could be made so without much difficulty.
Both are rare. Outside of tests and errors, I think DomKeyToKeyString would only
be used to generate web events (I don't know, but I'd hope that only happens
when there's something defined to consume them), and KeysStringToDomKey only by
IME extensions. Likewise for ui::DomCode.

dom_key_map[] is *almost* directly indexable, and could be split up to make it
so for the non-Unicode values. The corresponding DomCode map could similarly be
split up by USB page into fairly dense subtables. (My original preference was
for scripts to generate appropriate tables, including the various mappings
elsewhere for other codes like X keysyms and Windows VKEYs.)

-    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;
+      return "";

[dtapuska, 2015/08/13 14:47:26]

I believe its preferred to return std::string(); same for below too..

[kpschoedel, 2015/08/13 15:46:06]

Will do.

+    }
+  }
+  if (dom_key.IsUnicode()) {
+    std::string s;
+    base::WriteUnicodeCharacter(dom_key, &s);
+    return s;
   }
   return "";
 }
 
 // static
 bool KeycodeConverter::IsDomKeyForModifier(DomKey dom_key) {
   switch (dom_key) {
     case DomKey::ACCEL:
     case DomKey::ALT:
     case DomKey::ALT_GRAPH:
@@ skipping 78 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