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

ui/base/ime/chromeos/character_composer.cc

Index: ui/base/ime/chromeos/character_composer.cc
diff --git a/ui/base/ime/chromeos/character_composer.cc b/ui/base/ime/chromeos/character_composer.cc
index 20b27ef9fb75e55b947fa0274ea04718de8da0fe..94bc1e48be257925d6414546e555c22953234341 100644
--- a/ui/base/ime/chromeos/character_composer.cc
+++ b/ui/base/ime/chromeos/character_composer.cc
@@ -110,8 +110,7 @@ bool CharacterComposer::FilterKeyPress(const ui::KeyEvent& event) {
 
 bool CharacterComposer::FilterKeyPressSequenceMode(const KeyEvent& event) {
   DCHECK(composition_mode_ == KEY_SEQUENCE_MODE);
-  compose_buffer_.push_back(
-      KeystrokeMeaning(event.GetDomKey(), event.GetCharacter()));
+  compose_buffer_.push_back(event.GetDomKey());
 
   // Check compose table.
   uint32 composed_character_utf32 = 0;
@@ -214,17 +213,22 @@ ComposeChecker::CheckSequenceResult TreeComposeChecker::CheckSequence(
     DCHECK(tree_index < data_.tree_entries);
 
     // If we are looking up a dead key, skip over the character tables.
-    if (keystroke.key == ui::DomKey::DEAD) {
+    int32_t character = -1;
+    if (keystroke.IsDead()) {
       tree_index += 2 * data_.tree[tree_index] + 1;  // internal unicode table
       tree_index += 2 * data_.tree[tree_index] + 1;  // leaf unicode table
-    } else if (keystroke.key != ui::DomKey::CHARACTER) {
-      return CheckSequenceResult::NO_MATCH;
+      character = keystroke.ToDeadKeyCharacter();
+    } else if (keystroke.IsCharacter()) {
+      character = keystroke.ToCharacter();
     }
+    if (character < 0 || character > 0xFFFF)
+      return CheckSequenceResult::NO_MATCH;
 
     // Check the internal subtree table.
     uint16_t result = 0;
     uint16_t entries = data_.tree[tree_index++];
-    if (entries && Find(tree_index, entries, keystroke.character, &result)) {
+    if (entries &&
+        Find(tree_index, entries, static_cast<uint16_t>(character), &result)) {

[Wez, 2015/08/26 23:38:33]

It's worrying to be pulling a 32-bit Unicode code-point and coercing it here;
does the ComposeChecker need fixing to handle 32-bit, or is there some reason it
can assume 16-bit? e.g. because ECMAScript dictates UTF-16? (raising the
question of how things are supposed to behave if a user manages to type a
GB13080 character... :P

[kpschoedel, 2015/08/27 15:47:53]

The short answer is that there are no existing compositions involving non-BMP
characters (and the table generator checks that), so they're rejected above
(line 224). I considered adding non-BMP support here when I converted this from
X11 to DomKey, but unused code is frowned upon. Maybe I can find a use case —
the X11 tables that were used in ChromeOS were pretty old — and add it.

The long answer is probably very very long. |ui::KeyEvent| has historically held
a |base::char16|, and similarly |KeyEvent::GetCharacter()| returns a
|base::char16|. X11 ships one key layout with non-BMP characters (Avestan) and
it works on Linux Chrome, but I don't currently understand *how*.

[kpschoedel, 2015/08/27 22:13:10]

Followups:

There are no current non-BMP candidates for character composition. The closest
is that current X11 has some Compose key sequences involving music notation, but
(a) there's no layout with the components of those sequences, and (b) the
Compose key is not commonly used on ChromeOS.

The Avestan keyboard layout, with non-BMP characters, currently works on Linux
because IME takes over the keystrokes; the result is a textInput event rather
than a keypress event. (This is not a supported ChromeOS layout, and unlikely to
become so, as according to Wikipedia it's not a living language.)

       tree_index = result;
       continue;
     }
@@ -232,7 +236,8 @@ ComposeChecker::CheckSequenceResult TreeComposeChecker::CheckSequence(
     // Skip over the internal subtree table and check the leaf table.
     tree_index += 2 * entries;
     entries = data_.tree[tree_index++];
-    if (entries && Find(tree_index, entries, keystroke.character, &result)) {
+    if (entries &&
+        Find(tree_index, entries, static_cast<uint16_t>(character), &result)) {
       *composed_character = result;
       return CheckSequenceResult::FULL_MATCH;
     }