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

ui/base/ime/chromeos/character_composer.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/base/ime/chromeos/character_composer.h"
 
 #include <algorithm>
 #include <iterator>
 
 #include "base/strings/string_util.h"
@@ skipping 92 matching lines @@
     case HEX_MODE:
       return FilterKeyPressHexMode(event);
     default:
       NOTREACHED();
       return false;
   }
 }
 
 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;
   if (CheckCharacterComposeTable(compose_buffer_, &composed_character_utf32)) {
     // Key press is recognized as a part of composition.
     if (composed_character_utf32 != 0) {
       // We get a composed character.
       compose_buffer_.clear();
       UTF32CharacterToUTF16(composed_character_utf32, &composed_character_);
     }
@@ skipping 82 matching lines @@
     uint32_t* composed_character) const {
   *composed_character = 0;
   if (sequence.size() > data_.maximum_sequence_length)
     return CheckSequenceResult::NO_MATCH;
 
   uint16_t tree_index = 0;
   for (const auto& keystroke : sequence) {
     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) {
+      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;
     }
 
     // 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;
     }
     return CheckSequenceResult::NO_MATCH;
   }
   return CheckSequenceResult::PREFIX_MATCH;
 }
 
 bool TreeComposeChecker::Find(uint16_t index,
                               uint16_t size,
@@ skipping 11 matching lines @@
   const TableEntry target = {key, 0};
   const TableEntry* it = std::lower_bound(a, z, target);
   if ((it != z) && (it->key == key)) {
     *value = it->value;
     return true;
   }
   return false;
 }
 
 }  // namespace ui