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

ui/events/ozone/layout/xkb/xkb_keyboard_layout_engine_unittest.cc

 // Copyright 2014 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 "testing/gtest/include/gtest/gtest.h"
 #include "ui/events/event_constants.h"
 #include "ui/events/keycodes/dom/dom_code.h"
 #include "ui/events/keycodes/dom/dom_key.h"
 #include "ui/events/keycodes/keyboard_code_conversion.h"
 #include "ui/events/ozone/layout/keyboard_layout_engine_manager.h"
@@ skipping 67 matching lines @@
 
   xkb_keysym_t CharacterToKeySym(base::char16 c) const {
     return 0x01000000u + c;
   }
 
   KeyboardCode GetKeyboardCode(DomCode dom_code,
                                int flags,
                                base::char16 character) const {
     KeyboardCode key_code = DifficultKeyboardCode(
         dom_code, flags, key_code_converter_.DomCodeToXkbKeyCode(dom_code),
-        flags, CharacterToKeySym(character), DomKey::CHARACTER, character);
+        flags, CharacterToKeySym(character), character);
     if (key_code == VKEY_UNKNOWN) {
       DomKey dummy_dom_key;
-      base::char16 dummy_character;
       // If this fails, key_code remains VKEY_UNKNOWN.
-      ignore_result(DomCodeToUsLayoutMeaning(dom_code, EF_NONE, &dummy_dom_key,
-                                             &dummy_character, &key_code));
+      ignore_result(DomCodeToUsLayoutDomKey(dom_code, EF_NONE, &dummy_dom_key,
+                                             &key_code));
     }
     return key_code;
   }
 
   // XkbKeyboardLayoutEngine overrides:
   bool XkbLookup(xkb_keycode_t xkb_keycode,
                  xkb_mod_mask_t xkb_flags,
                  xkb_keysym_t* xkb_keysym,
-                 base::char16* character) const override {
+                 uint32_t* character) const override {
     switch (entry_type_) {
       case EntryType::NONE:
         break;
       case EntryType::PRINTABLE:
         if (!printable_entry_ ||
             (xkb_keycode !=
              static_cast<xkb_keycode_t>(printable_entry_->dom_code))) {
           return false;
         }
         if (xkb_flags & EF_ALTGR_DOWN)
@@ skipping 696 matching lines @@
     {{DomCode::NUMPAD1, XKB_KEY_KP_1}, VKEY_1},
     {{DomCode::CAPS_LOCK, XKB_KEY_Caps_Lock}, VKEY_CAPITAL},
     {{DomCode::ENTER, XKB_KEY_Return}, VKEY_RETURN},
     {{DomCode::NUMPAD_ENTER, XKB_KEY_KP_Enter}, VKEY_RETURN},
     {{DomCode::SLEEP, XKB_KEY_XF86Sleep}, VKEY_SLEEP},
   };
   for (const auto& e : kVkeyTestCase) {
     SCOPED_TRACE(static_cast<int>(e.test.dom_code));
     layout_engine_->SetEntry(&e.test);
     DomKey dom_key = DomKey::NONE;
-    base::char16 character = 0;
     KeyboardCode key_code = VKEY_UNKNOWN;
     uint32_t keysym;
     EXPECT_TRUE(layout_engine_->Lookup(e.test.dom_code, EF_NONE, &dom_key,
-                                       &character, &key_code, &keysym));
+                                       &key_code, &keysym));
     EXPECT_EQ(e.test.keysym, keysym);
     EXPECT_EQ(e.key_code, key_code);
   }
 }
 
 
 TEST_F(XkbLayoutEngineVkTest, XkbRuleNamesForLayoutName) {
   static const VkTestXkbKeyboardLayoutEngine::RuleNames kVkeyTestCase[] = {
       /* 0 */ {"us", "us", ""},
       /* 1 */ {"jp", "jp", ""},
@@ skipping 54 matching lines @@
     std::string layout_id;
     std::string layout_variant;
     XkbKeyboardLayoutEngine::ParseLayoutName(e->layout_name, &layout_id,
                                              &layout_variant);
     EXPECT_EQ(layout_id, e->layout);
     EXPECT_EQ(layout_variant, e->variant);
   }
 }
 
 }  // namespace ui