Remove some |char*| functions from KeycodeConverter

Convert code to use enum DomCode rather than strings.

BUG=444048
R=wez@chromium.org,bbudge@chromium.org,bauerb@chromium.org,jcivelli@chromium.org,sadrul@chromium.org

Presubmit has failed to acknowledge the "LGTM" at https://codereview.chromium.org/1124963003/#msg29 so I'm adding this TBR as a workaround:

TBR=jcivelli

Review URL: https://codereview.chromium.org/1124963003

Cr-Commit-Position: refs/heads/master@{#330158}

chrome/browser/ui/blocked_content/popup_blocker_browsertest.cc

@@ -45,6 +45,7 @@
 #include "net/dns/mock_host_resolver.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "ui/events/keycodes/dom/dom_code.h"
 #include "ui/events/keycodes/dom/keycode_converter.h"
 
 using content::WebContents;
@@ -637,35 +638,38 @@ IN_PROC_BROWSER_TEST_F(PopupBlockerBrowserTest, CtrlEnterKey) {
 
 #if defined(OS_MACOSX)
   int modifiers = blink::WebInputEvent::MetaKey;
-  InjectRawKeyEvent(tab, blink::WebInputEvent::RawKeyDown, ui::VKEY_COMMAND,
-                    ui::KeycodeConverter::CodeToNativeKeycode("OSLeft"),
-                    modifiers);
+  InjectRawKeyEvent(
+      tab, blink::WebInputEvent::RawKeyDown, ui::VKEY_COMMAND,
+      ui::KeycodeConverter::DomCodeToNativeKeycode(ui::DomCode::OS_LEFT),
+      modifiers);
 #else
   int modifiers = blink::WebInputEvent::ControlKey;
-  InjectRawKeyEvent(tab, blink::WebInputEvent::RawKeyDown, ui::VKEY_CONTROL,
-                    ui::KeycodeConverter::CodeToNativeKeycode("ControlLeft"),
-                    modifiers);
+  InjectRawKeyEvent(
+      tab, blink::WebInputEvent::RawKeyDown, ui::VKEY_CONTROL,
+      ui::KeycodeConverter::DomCodeToNativeKeycode(ui::DomCode::CONTROL_LEFT),
+      modifiers);
 #endif
 
   InjectRawKeyEvent(tab, blink::WebInputEvent::RawKeyDown, ui::VKEY_RETURN,
-                    ui::KeycodeConverter::CodeToNativeKeycode(NULL), modifiers);
+                    ui::KeycodeConverter::InvalidNativeKeycode(), modifiers);
 
   InjectRawKeyEvent(tab, blink::WebInputEvent::Char, ui::VKEY_RETURN,
-                    ui::KeycodeConverter::CodeToNativeKeycode(NULL), modifiers);
+                    ui::KeycodeConverter::InvalidNativeKeycode(), modifiers);
 
   InjectRawKeyEvent(tab, blink::WebInputEvent::KeyUp, ui::VKEY_RETURN,
-                    ui::KeycodeConverter::CodeToNativeKeycode(NULL), modifiers);
+                    ui::KeycodeConverter::InvalidNativeKeycode(), modifiers);
 
 #if defined(OS_MACOSX)
-  InjectRawKeyEvent(tab, blink::WebInputEvent::KeyUp, ui::VKEY_COMMAND,
-                    ui::KeycodeConverter::CodeToNativeKeycode("OSLeft"),
-                    modifiers);
+  InjectRawKeyEvent(
+      tab, blink::WebInputEvent::KeyUp, ui::VKEY_COMMAND,
+      ui::KeycodeConverter::DomCodeToNativeKeycode(ui::DomCode::OS_LEFT),
+      modifiers);
 #else
-  InjectRawKeyEvent(tab, blink::WebInputEvent::KeyUp, ui::VKEY_CONTROL,
-                    ui::KeycodeConverter::CodeToNativeKeycode("ControlLeft"),
-                    modifiers);
+  InjectRawKeyEvent(
+      tab, blink::WebInputEvent::KeyUp, ui::VKEY_CONTROL,
+      ui::KeycodeConverter::DomCodeToNativeKeycode(ui::DomCode::CONTROL_LEFT),
+      modifiers);
 #endif
-
   wait_for_new_tab.Wait();
 
   ASSERT_EQ(1u, chrome::GetBrowserCount(browser()->profile(),

content/content_renderer.gypi

@@ -561,11 +561,6 @@
       'renderer/pepper/url_request_info_util.h',
       'renderer/pepper/url_response_info_util.cc',
       'renderer/pepper/url_response_info_util.h',
-      'renderer/pepper/usb_key_code_conversion.cc',
-      'renderer/pepper/usb_key_code_conversion.h',
-      'renderer/pepper/usb_key_code_conversion_linux.cc',
-      'renderer/pepper/usb_key_code_conversion_mac.cc',
-      'renderer/pepper/usb_key_code_conversion_win.cc',
       'renderer/pepper/v8_var_converter.cc',
       'renderer/pepper/v8_var_converter.h',
       'renderer/pepper/v8object_var.cc',

content/public/test/browser_test_utils.cc

@@ -43,6 +43,7 @@
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/compositor/test/draw_waiter_for_test.h"
 #include "ui/events/gesture_detection/gesture_configuration.h"
+#include "ui/events/keycodes/dom/dom_code.h"
 #include "ui/events/keycodes/dom/keycode_converter.h"
 #include "ui/resources/grit/webui_resources.h"
 
@@ -445,7 +446,8 @@ void SimulateKeyPressWithCode(WebContents* web_contents,
                               bool shift,
                               bool alt,
                               bool command) {
-  int native_key_code = ui::KeycodeConverter::CodeToNativeKeycode(code);
+  int native_key_code = ui::KeycodeConverter::DomCodeToNativeKeycode(
+      ui::KeycodeConverter::CodeStringToDomCode(code));
 
   int modifiers = 0;
 
@@ -453,96 +455,75 @@ void SimulateKeyPressWithCode(WebContents* web_contents,
   // For our simulation we can use either the left keys or the right keys.
   if (control) {
     modifiers |= blink::WebInputEvent::ControlKey;
-    InjectRawKeyEvent(web_contents,
-                      blink::WebInputEvent::RawKeyDown,
-                      ui::VKEY_CONTROL,
-                      ui::KeycodeConverter::CodeToNativeKeycode("ControlLeft"),
-                      modifiers);
+    InjectRawKeyEvent(
+        web_contents, blink::WebInputEvent::RawKeyDown, ui::VKEY_CONTROL,
+        ui::KeycodeConverter::DomCodeToNativeKeycode(ui::DomCode::CONTROL_LEFT),
+        modifiers);
   }
 
   if (shift) {
     modifiers |= blink::WebInputEvent::ShiftKey;
-    InjectRawKeyEvent(web_contents,
-                      blink::WebInputEvent::RawKeyDown,
-                      ui::VKEY_SHIFT,
-                      ui::KeycodeConverter::CodeToNativeKeycode("ShiftLeft"),
-                      modifiers);
+    InjectRawKeyEvent(
+        web_contents, blink::WebInputEvent::RawKeyDown, ui::VKEY_SHIFT,
+        ui::KeycodeConverter::DomCodeToNativeKeycode(ui::DomCode::SHIFT_LEFT),
+        modifiers);
   }
 
   if (alt) {
     modifiers |= blink::WebInputEvent::AltKey;
-    InjectRawKeyEvent(web_contents,
-                      blink::WebInputEvent::RawKeyDown,
-                      ui::VKEY_MENU,
-                      ui::KeycodeConverter::CodeToNativeKeycode("AltLeft"),
-                      modifiers);
+    InjectRawKeyEvent(
+        web_contents, blink::WebInputEvent::RawKeyDown, ui::VKEY_MENU,
+        ui::KeycodeConverter::DomCodeToNativeKeycode(ui::DomCode::ALT_LEFT),
+        modifiers);
   }
 
   if (command) {
     modifiers |= blink::WebInputEvent::MetaKey;
-    InjectRawKeyEvent(web_contents,
-                      blink::WebInputEvent::RawKeyDown,
-                      ui::VKEY_COMMAND,
-                      ui::KeycodeConverter::CodeToNativeKeycode("OSLeft"),
-                      modifiers);
+    InjectRawKeyEvent(
+        web_contents, blink::WebInputEvent::RawKeyDown, ui::VKEY_COMMAND,
+        ui::KeycodeConverter::DomCodeToNativeKeycode(ui::DomCode::OS_LEFT),
+        modifiers);
   }
+  InjectRawKeyEvent(web_contents, blink::WebInputEvent::RawKeyDown, key_code,
+                    native_key_code, modifiers);
 
-  InjectRawKeyEvent(
-      web_contents,
-      blink::WebInputEvent::RawKeyDown,
-      key_code,
-      native_key_code,
-      modifiers);
-
-  InjectRawKeyEvent(
-      web_contents,
-      blink::WebInputEvent::Char,
-      key_code,
-      native_key_code,
-      modifiers);
-
-  InjectRawKeyEvent(
-      web_contents,
-      blink::WebInputEvent::KeyUp,
-      key_code,
-      native_key_code,
-      modifiers);
+  InjectRawKeyEvent(web_contents, blink::WebInputEvent::Char, key_code,
+                    native_key_code, modifiers);
+
+  InjectRawKeyEvent(web_contents, blink::WebInputEvent::KeyUp, key_code,
+                    native_key_code, modifiers);
 
   // The order of these key releases shouldn't matter for our simulation.
   if (control) {
     modifiers &= ~blink::WebInputEvent::ControlKey;
-    InjectRawKeyEvent(web_contents,
-                      blink::WebInputEvent::KeyUp,
-                      ui::VKEY_CONTROL,
-                      ui::KeycodeConverter::CodeToNativeKeycode("ControlLeft"),
-                      modifiers);
+    InjectRawKeyEvent(
+        web_contents, blink::WebInputEvent::KeyUp, ui::VKEY_CONTROL,
+        ui::KeycodeConverter::DomCodeToNativeKeycode(ui::DomCode::CONTROL_LEFT),
+        modifiers);
   }
 
   if (shift) {
     modifiers &= ~blink::WebInputEvent::ShiftKey;
-    InjectRawKeyEvent(web_contents,
-                      blink::WebInputEvent::KeyUp,
-                      ui::VKEY_SHIFT,
-                      ui::KeycodeConverter::CodeToNativeKeycode("ShiftLeft"),
-                      modifiers);
+    InjectRawKeyEvent(
+        web_contents, blink::WebInputEvent::KeyUp, ui::VKEY_SHIFT,
+        ui::KeycodeConverter::DomCodeToNativeKeycode(ui::DomCode::SHIFT_LEFT),
+        modifiers);
   }
 
   if (alt) {
     modifiers &= ~blink::WebInputEvent::AltKey;
-    InjectRawKeyEvent(web_contents,
-                      blink::WebInputEvent::KeyUp,
-                      ui::VKEY_MENU,
-                      ui::KeycodeConverter::CodeToNativeKeycode("AltLeft"),
-                      modifiers);
+    InjectRawKeyEvent(
+        web_contents, blink::WebInputEvent::KeyUp, ui::VKEY_MENU,
+        ui::KeycodeConverter::DomCodeToNativeKeycode(ui::DomCode::ALT_LEFT),
+        modifiers);
   }
 
   if (command) {
     modifiers &= ~blink::WebInputEvent::MetaKey;
-    InjectRawKeyEvent(web_contents,
-                      blink::WebInputEvent::KeyUp,
-                      ui::VKEY_COMMAND,
-                      ui::KeycodeConverter::CodeToNativeKeycode("OSLeft"),
-                      modifiers);
+    InjectRawKeyEvent(
+        web_contents, blink::WebInputEvent::KeyUp, ui::VKEY_COMMAND,
+        ui::KeycodeConverter::DomCodeToNativeKeycode(ui::DomCode::OS_LEFT),
+        modifiers);
   }
 
   ASSERT_EQ(modifiers, 0);

content/renderer/pepper/event_conversion.cc

@@ -13,13 +13,13 @@
 #include "base/strings/utf_string_conversion_utils.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/common/input/web_touch_event_traits.h"
-#include "content/renderer/pepper/usb_key_code_conversion.h"
 #include "ppapi/c/pp_input_event.h"
 #include "ppapi/shared_impl/ppb_input_event_shared.h"
 #include "ppapi/shared_impl/time_conversion.h"
 #include "third_party/WebKit/public/platform/WebGamepads.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
+#include "ui/events/keycodes/dom/keycode_converter.h"
 
 using ppapi::EventTimeToPPTimeTicks;
 using ppapi::InputEventData;
@@ -135,7 +135,8 @@ void AppendKeyEvent(const WebInputEvent& event,
   InputEventData result = GetEventWithCommonFieldsAndType(event);
   result.event_modifiers = key_event.modifiers;
   result.key_code = key_event.windowsKeyCode;
-  result.code = CodeForKeyboardEvent(key_event);
+  result.code = ui::KeycodeConverter::DomCodeToCodeString(
+      static_cast<ui::DomCode>(key_event.domCode));
   result_events->push_back(result);
 }
 

content/renderer/pepper/usb_key_code_conversion.cc

-// Copyright (c) 2012 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 "content/renderer/pepper/usb_key_code_conversion.h"
-
-#include "build/build_config.h"
-
-using blink::WebKeyboardEvent;
-
-namespace content {
-
-#if !defined(OS_LINUX) && !defined(OS_MACOSX) && !defined(OS_WIN)
-
-uint32_t UsbKeyCodeForKeyboardEvent(const WebKeyboardEvent& key_event) {
-  return 0;
-}
-
-const char* CodeForKeyboardEvent(const WebKeyboardEvent& key_event) {
-  return NULL;
-}
-
-#endif
-
-}  // namespace content

content/renderer/pepper/usb_key_code_conversion.h

-// Copyright (c) 2012 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.
-
-#ifndef CONTENT_RENDERER_PEPPER_USB_KEY_CODE_CONVERSION_H_
-#define CONTENT_RENDERER_PEPPER_USB_KEY_CODE_CONVERSION_H_
-
-#include "ppapi/c/pp_stdint.h"
-
-namespace blink {
-class WebKeyboardEvent;
-}  // namespace blink
-
-namespace content {
-
-// Returns a 32-bit "USB Key Code" for the key identifier by the supplied
-// WebKeyboardEvent. The supplied event must be a KeyDown or KeyUp.
-// The code consists of the USB Page (in the high-order 16-bit word) and
-// USB Usage Id of the key.  If no translation can be performed then zero
-// is returned.
-uint32_t UsbKeyCodeForKeyboardEvent(const blink::WebKeyboardEvent& key_event);
-
-// Returns a string that represents the UI Event |code| parameter as specified
-// in http://www.w3.org/TR/uievents/
-const char* CodeForKeyboardEvent(const blink::WebKeyboardEvent& key_event);
-
-}  // namespace content
-
-#endif  // CONTENT_RENDERER_PEPPER_USB_KEY_CODE_CONVERSION_H_

content/renderer/pepper/usb_key_code_conversion_linux.cc

@@ -22,7 +22,8 @@ uint32_t UsbKeyCodeForKeyboardEvent(const WebKeyboardEvent& key_event) {
 }
 
 const char* CodeForKeyboardEvent(const WebKeyboardEvent& key_event) {
-  return ui::KeycodeConverter::NativeKeycodeToCode(key_event.nativeKeyCode);
+  return ui::KeycodeConverter::DomCodeToCodeString(
+      ui::KeycodeConverter::NativeKeycodeToDomCode(key_event.nativeKeyCode));
 }
 
 }  // namespace content

content/renderer/pepper/usb_key_code_conversion_mac.cc

@@ -18,7 +18,8 @@ uint32_t UsbKeyCodeForKeyboardEvent(const WebKeyboardEvent& key_event) {
 }
 
 const char* CodeForKeyboardEvent(const WebKeyboardEvent& key_event) {
-  return ui::KeycodeConverter::NativeKeycodeToCode(key_event.nativeKeyCode);
+  return ui::KeycodeConverter::DomCodeToCodeString(
+      ui::KeycodeConverter::NativeKeycodeToDomCode(key_event.nativeKeyCode));
 }
 
 }  // namespace content

content/renderer/pepper/usb_key_code_conversion_win.cc

@@ -27,7 +27,8 @@ const char* CodeForKeyboardEvent(const WebKeyboardEvent& key_event) {
   if ((key_event.nativeKeyCode & (1 << 24)) != 0)
     scancode |= 0xe000;
 
-  return ui::KeycodeConverter::NativeKeycodeToCode(scancode);
+  return ui::KeycodeConverter::DomCodeToCodeString(
+      ui::KeycodeConverter::NativeKeycodeToDomCode(scancode));
 }
 
 }  // namespace content

ui/events/event_unittest.cc

@@ -351,7 +351,7 @@ TEST(EventTest, KeyEventCode) {
   ASSERT_EQ(kDomCodeForSpace,
             ui::KeycodeConverter::CodeStringToDomCode(kCodeForSpace));
   const uint16 kNativeCodeSpace =
-      ui::KeycodeConverter::CodeToNativeKeycode(kCodeForSpace);
+      ui::KeycodeConverter::DomCodeToNativeKeycode(kDomCodeForSpace);
   ASSERT_NE(ui::KeycodeConverter::InvalidNativeKeycode(), kNativeCodeSpace);
   ASSERT_EQ(kNativeCodeSpace,
             ui::KeycodeConverter::DomCodeToNativeKeycode(kDomCodeForSpace));
@@ -433,8 +433,10 @@ void AdvanceKeyEventTimestamp(MSG& msg) {
 
 #if defined(USE_X11) || defined(OS_WIN)
 TEST(EventTest, AutoRepeat) {
-  const uint16 kNativeCodeA = ui::KeycodeConverter::CodeToNativeKeycode("KeyA");
-  const uint16 kNativeCodeB = ui::KeycodeConverter::CodeToNativeKeycode("KeyB");
+  const uint16 kNativeCodeA =
+      ui::KeycodeConverter::DomCodeToNativeKeycode(DomCode::KEY_A);
+  const uint16 kNativeCodeB =
+      ui::KeycodeConverter::DomCodeToNativeKeycode(DomCode::KEY_B);
 #if defined(USE_X11)
   ScopedXI2Event native_event_a_pressed;
   native_event_a_pressed.InitKeyEvent(ET_KEY_PRESSED, VKEY_A, kNativeCodeA);

ui/events/keycodes/dom/keycode_converter.cc

@@ -68,18 +68,6 @@ int KeycodeConverter::InvalidNativeKeycode() {
   return usb_keycode_map[0].native_keycode;
 }
 
-// static
-const char* KeycodeConverter::NativeKeycodeToCode(int native_keycode) {
-  for (size_t i = 0; i < kKeycodeMapEntries; ++i) {
-    if (usb_keycode_map[i].native_keycode == native_keycode) {
-      if (usb_keycode_map[i].code != NULL)
-        return usb_keycode_map[i].code;
-      break;
-    }
-  }
-  return "";
-}
-
 // static
 DomCode KeycodeConverter::NativeKeycodeToDomCode(int native_keycode) {
   for (size_t i = 0; i < kKeycodeMapEntries; ++i) {
@@ -92,20 +80,6 @@ DomCode KeycodeConverter::NativeKeycodeToDomCode(int native_keycode) {
   return DomCode::NONE;
 }
 
-// static
-int KeycodeConverter::CodeToNativeKeycode(const char* code) {
-  if (!code || !*code)
-    return InvalidNativeKeycode();
-
-  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].native_keycode;
-    }
-  }
-  return InvalidNativeKeycode();
-}
-
 // static
 int KeycodeConverter::DomCodeToNativeKeycode(DomCode code) {
   return UsbKeycodeToNativeKeycode(static_cast<uint32_t>(code));
@@ -129,7 +103,14 @@ DomCode KeycodeConverter::CodeStringToDomCode(const char* code) {
 
 // static
 const char* KeycodeConverter::DomCodeToCodeString(DomCode dom_code) {
-  return UsbKeycodeToCode(static_cast<uint32_t>(dom_code));
+  for (size_t i = 0; i < kKeycodeMapEntries; ++i) {
+    if (usb_keycode_map[i].usb_keycode == static_cast<uint32_t>(dom_code)) {
+      if (usb_keycode_map[i].code)
+        return usb_keycode_map[i].code;
+      break;
+    }
+  }
+  return "";
 }
 
 // static
@@ -239,24 +220,21 @@ uint32_t KeycodeConverter::NativeKeycodeToUsbKeycode(int native_keycode) {
 }
 
 // static
-const char* KeycodeConverter::UsbKeycodeToCode(uint32_t usb_keycode) {
+DomCode KeycodeConverter::UsbKeycodeToDomCode(uint32_t usb_keycode) {
   for (size_t i = 0; i < kKeycodeMapEntries; ++i) {
-    if (usb_keycode_map[i].usb_keycode == usb_keycode) {
-      if (usb_keycode_map[i].code)
-        return usb_keycode_map[i].code;
-      break;
-    }
+    if (usb_keycode_map[i].usb_keycode == usb_keycode)
+      return static_cast<DomCode>(usb_keycode);
   }
-  return "";
+  return DomCode::NONE;
 }
 
 // static
-DomCode KeycodeConverter::UsbKeycodeToDomCode(uint32_t usb_keycode) {
+uint32_t KeycodeConverter::DomCodeToUsbKeycode(DomCode dom_code) {
   for (size_t i = 0; i < kKeycodeMapEntries; ++i) {
-    if (usb_keycode_map[i].usb_keycode == usb_keycode)
-      return static_cast<DomCode>(usb_keycode);
+    if (usb_keycode_map[i].usb_keycode == static_cast<uint32_t>(dom_code))
+      return usb_keycode_map[i].usb_keycode;
   }
-  return DomCode::NONE;
+  return InvalidUsbKeycode();
 }
 
 // static

ui/events/keycodes/dom/keycode_converter.h

@@ -45,16 +45,9 @@ class KeycodeConverter {
   // Return the value that identifies an invalid native keycode.
   static int InvalidNativeKeycode();
 
-  // Convert a native (Mac/Win/Linux) keycode into the |code| string.
-  // The returned pointer references a static global string.
-  static const char* NativeKeycodeToCode(int native_keycode);
-
   // Convert a native (Mac/Win/Linux) keycode into a DomCode.
   static DomCode NativeKeycodeToDomCode(int native_keycode);
 
-  // Convert a UI Events |code| string value into a native keycode.
-  static int CodeToNativeKeycode(const char* code);
-
   // Convert a DomCode into a native keycode.
   static int DomCodeToNativeKeycode(DomCode code);
 
@@ -88,13 +81,12 @@ class KeycodeConverter {
   // Convert a platform native keycode into an equivalent USB keycode.
   static uint32_t NativeKeycodeToUsbKeycode(int native_keycode);
 
-  // Convert a USB keycode into the string with the DOM3 |code| value.
-  // The returned pointer references a static global string.
-  static const char* UsbKeycodeToCode(uint32_t usb_keycode);
-
   // Convert a USB keycode into a DomCode.
   static DomCode UsbKeycodeToDomCode(uint32_t usb_keycode);
 
+  // Convert a DomCode into a USB keycode.
+  static uint32_t DomCodeToUsbKeycode(DomCode dom_code);
+
   // Convert a DOM3 Event |code| string into a USB keycode value.
   static uint32_t CodeToUsbKeycode(const char* code);
 

ui/events/keycodes/dom/keycode_converter_unittest.cc

@@ -38,7 +38,7 @@ TEST(UsbKeycodeMap, Basic) {
   EXPECT_EQ(ui::KeycodeConverter::InvalidNativeKeycode(),
             keycode_map[0].native_keycode);
   EXPECT_EQ(ui::KeycodeConverter::InvalidNativeKeycode(),
-            ui::KeycodeConverter::CodeToNativeKeycode("Unidentified"));
+            ui::KeycodeConverter::DomCodeToNativeKeycode(ui::DomCode::NONE));
 
   // Verify that there are no duplicate entries in the mapping.
   std::map<uint32_t, uint16_t> usb_to_native;
@@ -55,17 +55,14 @@ TEST(UsbKeycodeMap, Basic) {
         entry->native_keycode,
         ui::KeycodeConverter::UsbKeycodeToNativeKeycode(entry->usb_keycode));
 
-    // Verify CodeToNativeKeycode and NativeKeycodeToCode work correctly.
+    // Verify DomCodeToNativeKeycode works correctly.
+    ui::DomCode dom_code =
+        ui::KeycodeConverter::CodeStringToDomCode(entry->code);
     if (entry->code) {
       EXPECT_EQ(entry->native_keycode,
-                ui::KeycodeConverter::CodeToNativeKeycode(entry->code));
-      EXPECT_STREQ(
-          entry->code,
-          ui::KeycodeConverter::NativeKeycodeToCode(entry->native_keycode));
-    }
-    else {
-      EXPECT_EQ(ui::KeycodeConverter::InvalidNativeKeycode(),
-                ui::KeycodeConverter::CodeToNativeKeycode(entry->code));
+                ui::KeycodeConverter::DomCodeToNativeKeycode(dom_code));
+    } else {
+      EXPECT_EQ(ui::DomCode::NONE, dom_code);
     }
 
     // Verify that the USB or native codes aren't duplicated.