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.IsDeadKey()) {
       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.ToDeadKeyCombiningCharacter();
+    } 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)) {
       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