ui/events/keycodes/keyboard_code_conversion.cc

   1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ui/events/keycodes/keyboard_code_conversion.h"
   6
   7 #include <algorithm>
   8
   9 #include "ui/events/event_constants.h"
  10 #include "ui/events/keycodes/dom/dom_code.h"
  11 #include "ui/events/keycodes/dom/dom_key.h"
  12 #include "ui/events/keycodes/dom_us_layout_data.h"
  13
  14 namespace ui {
  15
  16 namespace {
  17
  18 // This table maps a subset of |KeyboardCode| (VKEYs) to DomKey and character.
  19 // Only values not otherwise handled by GetMeaningFromKeyCode() are here.
  20 const struct KeyboardCodeToMeaning {
  21   KeyboardCode key_code;
  22   DomKey key;
  23   base::char16 plain_character;
  24   base::char16 shift_character;
  25 } kKeyboardCodeToMeaning[] = {
  26     {VKEY_BACK, DomKey::BACKSPACE, '\b', 0},
  27     {VKEY_TAB, DomKey::TAB, '\t', 0},
  28     {VKEY_RETURN, DomKey::ENTER, '\r', 0},
  29     {VKEY_ESCAPE, DomKey::ESCAPE, 0x1B, 0},
  30     {VKEY_SPACE, DomKey::CHARACTER, ' ', 0},
  31     {VKEY_MULTIPLY, DomKey::CHARACTER, '*', 0},
  32     {VKEY_ADD, DomKey::CHARACTER, '+', 0},
  33     {VKEY_SEPARATOR, DomKey::CHARACTER, ',', 0},
  34     {VKEY_SUBTRACT, DomKey::CHARACTER, '-', 0},
  35     {VKEY_DECIMAL, DomKey::CHARACTER, '.', 0},
  36     {VKEY_DIVIDE, DomKey::CHARACTER, '/', 0},
  37     {VKEY_OEM_1, DomKey::CHARACTER, ';', ':'},
  38     {VKEY_OEM_PLUS, DomKey::CHARACTER, '=', '+'},
  39     {VKEY_OEM_COMMA, DomKey::CHARACTER, ',', '<'},
  40     {VKEY_OEM_MINUS, DomKey::CHARACTER, '-', '_'},
  41     {VKEY_OEM_PERIOD, DomKey::CHARACTER, '.', '>'},
  42     {VKEY_OEM_2, DomKey::CHARACTER, '/', '?'},
  43     {VKEY_OEM_3, DomKey::CHARACTER, '`', '~'},
  44     {VKEY_OEM_4, DomKey::CHARACTER, '[', '{'},
  45     {VKEY_OEM_5, DomKey::CHARACTER, '\\', '|'},
  46     {VKEY_OEM_6, DomKey::CHARACTER, ']', '}'},
  47     {VKEY_OEM_7, DomKey::CHARACTER, '\'', '"'},
  48     {VKEY_OEM_102, DomKey::CHARACTER, '<', '>'},
  49     {VKEY_CLEAR, DomKey::CLEAR, 0, 0},
  50     {VKEY_SHIFT, DomKey::SHIFT, 0, 0},
  51     {VKEY_CONTROL, DomKey::CONTROL, 0, 0},
  52     {VKEY_MENU, DomKey::ALT, 0, 0},
  53     {VKEY_PAUSE, DomKey::PAUSE, 0, 0},
  54     {VKEY_CAPITAL, DomKey::CAPS_LOCK, 0, 0},
  55     // Windows conflates 'KanaMode' and 'HangulMode'.
  56     {VKEY_KANA, DomKey::KANA_MODE, 0, 0},
  57     {VKEY_JUNJA, DomKey::JUNJA_MODE, 0, 0},
  58     {VKEY_FINAL, DomKey::FINAL_MODE, 0, 0},
  59     // Windows conflates 'HanjaMode' and 'KanjiMode'.
  60     {VKEY_HANJA, DomKey::HANJA_MODE, 0, 0},
  61     {VKEY_CONVERT, DomKey::CONVERT, 0, 0},
  62     {VKEY_NONCONVERT, DomKey::NON_CONVERT, 0, 0},
  63     {VKEY_ACCEPT, DomKey::ACCEPT, 0, 0},
  64     {VKEY_MODECHANGE, DomKey::MODE_CHANGE, 0, 0},
  65     {VKEY_PRIOR, DomKey::PAGE_UP, 0, 0},
  66     {VKEY_NEXT, DomKey::PAGE_DOWN, 0, 0},
  67     {VKEY_END, DomKey::END, 0, 0},
  68     {VKEY_HOME, DomKey::HOME, 0, 0},
  69     {VKEY_LEFT, DomKey::ARROW_LEFT, 0, 0},
  70     {VKEY_UP, DomKey::ARROW_UP, 0, 0},
  71     {VKEY_RIGHT, DomKey::ARROW_RIGHT, 0, 0},
  72     {VKEY_DOWN, DomKey::ARROW_DOWN, 0, 0},
  73     {VKEY_SELECT, DomKey::SELECT, 0, 0},
  74     {VKEY_PRINT, DomKey::PRINT, 0, 0},
  75     {VKEY_EXECUTE, DomKey::EXECUTE, 0, 0},
  76     {VKEY_SNAPSHOT, DomKey::PRINT_SCREEN, 0, 0},
  77     {VKEY_INSERT, DomKey::INSERT, 0, 0},
  78     {VKEY_DELETE, DomKey::DEL, 0, 0},
  79     {VKEY_HELP, DomKey::HELP, 0, 0},
  80     {VKEY_LWIN, DomKey::OS, 0, 0},
  81     {VKEY_RWIN, DomKey::OS, 0, 0},
  82     {VKEY_APPS, DomKey::MEDIA_APPS, 0, 0},
  83     {VKEY_NUMLOCK, DomKey::NUM_LOCK, 0, 0},
  84     {VKEY_SCROLL, DomKey::SCROLL_LOCK, 0, 0},
  85     {VKEY_LSHIFT, DomKey::SHIFT, 0, 0},
  86     {VKEY_RSHIFT, DomKey::SHIFT, 0, 0},
  87     {VKEY_LCONTROL, DomKey::CONTROL, 0, 0},
  88     {VKEY_RCONTROL, DomKey::CONTROL, 0, 0},
  89     {VKEY_LMENU, DomKey::ALT, 0, 0},
  90     {VKEY_RMENU, DomKey::ALT, 0, 0},
  91     {VKEY_BROWSER_BACK, DomKey::BROWSER_BACK, 0, 0},
  92     {VKEY_BROWSER_FORWARD, DomKey::BROWSER_FORWARD, 0, 0},
  93     {VKEY_BROWSER_REFRESH, DomKey::BROWSER_REFRESH, 0, 0},
  94     {VKEY_BROWSER_STOP, DomKey::BROWSER_STOP, 0, 0},
  95     {VKEY_BROWSER_SEARCH, DomKey::BROWSER_SEARCH, 0, 0},
  96     {VKEY_BROWSER_FAVORITES, DomKey::BROWSER_FAVORITES, 0, 0},
  97     {VKEY_BROWSER_HOME, DomKey::BROWSER_HOME, 0, 0},
  98     {VKEY_VOLUME_MUTE, DomKey::VOLUME_MUTE, 0, 0},
  99     {VKEY_VOLUME_DOWN, DomKey::VOLUME_DOWN, 0, 0},
 100     {VKEY_VOLUME_UP, DomKey::VOLUME_UP, 0, 0},
 101     {VKEY_MEDIA_NEXT_TRACK, DomKey::MEDIA_TRACK_NEXT, 0, 0},
 102     {VKEY_MEDIA_PREV_TRACK, DomKey::MEDIA_TRACK_PREVIOUS, 0, 0},
 103     {VKEY_MEDIA_STOP, DomKey::MEDIA_STOP, 0, 0},
 104     {VKEY_MEDIA_PLAY_PAUSE, DomKey::MEDIA_PLAY_PAUSE, 0, 0},
 105     {VKEY_MEDIA_LAUNCH_MAIL, DomKey::LAUNCH_MAIL, 0, 0},
 106     {VKEY_MEDIA_LAUNCH_MEDIA_SELECT, DomKey::LAUNCH_MEDIA_PLAYER, 0, 0},
 107     {VKEY_MEDIA_LAUNCH_APP1, DomKey::LAUNCH_MY_COMPUTER, 0, 0},
 108     {VKEY_MEDIA_LAUNCH_APP2, DomKey::LAUNCH_CALCULATOR, 0, 0},
 109     {VKEY_OEM_8, DomKey::SUPER, 0, 0},  // ISO Level 5 Shift in ChromeOS
 110     {VKEY_PROCESSKEY, DomKey::PROCESS, 0, 0},
 111     {VKEY_DBE_SBCSCHAR, DomKey::HANKAKU, 0, 0},
 112     {VKEY_DBE_DBCSCHAR, DomKey::ZENKAKU, 0, 0},
 113     {VKEY_ATTN, DomKey::ATTN, 0, 0},
 114     {VKEY_CRSEL, DomKey::CR_SEL, 0, 0},
 115     {VKEY_EXSEL, DomKey::EX_SEL, 0, 0},
 116     {VKEY_EREOF, DomKey::ERASE_EOF, 0, 0},
 117     {VKEY_PLAY, DomKey::MEDIA_PLAY, 0, 0},
 118     {VKEY_ZOOM, DomKey::ZOOM_TOGGLE, 0, 0},
 119     {VKEY_OEM_CLEAR, DomKey::CLEAR, 0, 0},
 120     {VKEY_ALTGR, DomKey::ALT_GRAPH, 0, 0},
 121 #if defined(OS_POSIX)
 122     {VKEY_POWER, DomKey::POWER, 0, 0},
 123     {VKEY_BRIGHTNESS_DOWN, DomKey::BRIGHTNESS_DOWN, 0, 0},
 124     {VKEY_BRIGHTNESS_UP, DomKey::BRIGHTNESS_UP, 0, 0},
 125     {VKEY_COMPOSE, DomKey::COMPOSE, 0, 0},
 126     {VKEY_OEM_103, DomKey::MEDIA_REWIND, 0, 0},
 127     {VKEY_OEM_104, DomKey::MEDIA_FAST_FORWARD, 0, 0},
 128 #endif
 129 };
 130
 131 bool IsRightSideDomCode(DomCode code) {
 132   return (code == DomCode::SHIFT_RIGHT) || (code == DomCode::CONTROL_RIGHT) ||
 133          (code == DomCode::ALT_RIGHT) || (code == DomCode::OS_RIGHT);
 134 }
 135
 136 bool IsModifierDomCode(DomCode code) {
 137   return (code == DomCode::CONTROL_LEFT) || (code == DomCode::CONTROL_RIGHT) ||
 138          (code == DomCode::SHIFT_LEFT) || (code == DomCode::SHIFT_RIGHT) ||
 139          (code == DomCode::ALT_LEFT) || (code == DomCode::ALT_RIGHT) ||
 140          (code == DomCode::OS_LEFT) || (code == DomCode::OS_RIGHT);
 141 }
 142
 143 }  // anonymous namespace
 144
 145 base::char16 GetCharacterFromKeyCode(KeyboardCode key_code, int flags) {
 146   ui::DomKey dom_key;
 147   base::char16 character;
 148   if (GetMeaningFromKeyCode(key_code, flags, &dom_key, &character))
 149     return character;
 150   return 0;
 151 }
 152
 153 bool GetMeaningFromKeyCode(KeyboardCode key_code,
 154                            int flags,
 155                            DomKey* dom_key,
 156                            base::char16* character) {
 157   const bool ctrl = (flags & EF_CONTROL_DOWN) != 0;
 158   const bool shift = (flags & EF_SHIFT_DOWN) != 0;
 159   const bool upper = shift ^ ((flags & EF_CAPS_LOCK_DOWN) != 0);
 160
 161   // Control characters.
 162   if (ctrl) {
 163     // Following Windows behavior to map ctrl-a ~ ctrl-z to \x01 ~ \x1A.
 164     if (key_code >= VKEY_A && key_code <= VKEY_Z) {
 165       *character = static_cast<uint16>(key_code - VKEY_A + 1);
 166       switch (key_code) {
 167         case VKEY_H:
 168           *dom_key = DomKey::BACKSPACE;
 169           break;
 170         case VKEY_I:
 171           *dom_key = DomKey::TAB;
 172           break;
 173         case VKEY_J:
 174         case VKEY_M:
 175           *dom_key = DomKey::ENTER;
 176           break;
 177         default:
 178           *dom_key = DomKey::CHARACTER;
 179           break;
 180       }
 181       return true;
 182     }
 183     // Other control characters.
 184     if (shift) {
 185       // The following graphics characters require the shift key to input.
 186       switch (key_code) {
 187         // ctrl-@ maps to \x00 (Null byte)
 188         case VKEY_2:
 189           *dom_key = DomKey::CHARACTER;
 190           *character = 0;
 191           return true;
 192         // ctrl-^ maps to \x1E (Record separator, Information separator two)
 193         case VKEY_6:
 194           *dom_key = DomKey::CHARACTER;
 195           *character = 0x1E;
 196           return true;
 197         // ctrl-_ maps to \x1F (Unit separator, Information separator one)
 198         case VKEY_OEM_MINUS:
 199           *dom_key = DomKey::CHARACTER;
 200           *character = 0x1F;
 201           return true;
 202         // Returns 0 for all other keys to avoid inputting unexpected chars.
 203         default:
 204           *dom_key = DomKey::UNIDENTIFIED;
 205           *character = 0;
 206           return false;
 207       }
 208     } else {
 209       switch (key_code) {
 210         // ctrl-[ maps to \x1B (Escape)
 211         case VKEY_OEM_4:
 212           *dom_key = DomKey::ESCAPE;
 213           *character = 0x1B;
 214           return true;
 215         // ctrl-\ maps to \x1C (File separator, Information separator four)
 216         case VKEY_OEM_5:
 217           *dom_key = DomKey::CHARACTER;
 218           *character = 0x1C;
 219           return true;
 220         // ctrl-] maps to \x1D (Group separator, Information separator three)
 221         case VKEY_OEM_6:
 222           *dom_key = DomKey::CHARACTER;
 223           *character = 0x1D;
 224           return true;
 225         // ctrl-Enter maps to \x0A (Line feed)
 226         case VKEY_RETURN:
 227           *dom_key = DomKey::CHARACTER;
 228           *character = 0x0A;
 229           return true;
 230         // Returns 0 for all other keys to avoid inputting unexpected chars.
 231         default:
 232           *dom_key = DomKey::UNIDENTIFIED;
 233           *character = 0;
 234           return false;
 235       }
 236     }
 237   }
 238
 239   // ASCII alphanumeric characters.
 240   if (key_code >= VKEY_A && key_code <= VKEY_Z) {
 241     *dom_key = DomKey::CHARACTER;
 242     *character = static_cast<uint16>(key_code - VKEY_A + (upper ? 'A' : 'a'));
 243     return true;
 244   }
 245   if (key_code >= VKEY_0 && key_code <= VKEY_9) {
 246     *dom_key = DomKey::CHARACTER;
 247     *character =
 248         shift ? ")!@#$%^&*("[key_code - VKEY_0] : static_cast<uint16>(key_code);
 249     return true;
 250   }
 251   if (key_code >= VKEY_NUMPAD0 && key_code <= VKEY_NUMPAD9) {
 252     *dom_key = DomKey::CHARACTER;
 253     *character = static_cast<uint16>(key_code - VKEY_NUMPAD0 + '0');
 254     return true;
 255   }
 256
 257   // Function keys.
 258   if (key_code >= VKEY_F1 && key_code <= VKEY_F24) {
 259     *dom_key =
 260         static_cast<DomKey>(key_code - VKEY_F1 + static_cast<int>(DomKey::F1));
 261     *character = 0;
 262     return true;
 263   }
 264
 265   // Other keys.
 266   for (size_t i = 0; i < arraysize(kKeyboardCodeToMeaning); ++i) {
 267     if (kKeyboardCodeToMeaning[i].key_code == key_code) {
 268       const KeyboardCodeToMeaning* p = &kKeyboardCodeToMeaning[i];
 269       *dom_key = p->key;
 270       *character = (shift && p->shift_character) ? p->shift_character
 271                                                  : p->plain_character;
 272       return true;
 273     }
 274   }
 275   *dom_key = DomKey::UNIDENTIFIED;
 276   *character = 0;
 277   return false;
 278 }
 279
 280 bool DomCodeToUsLayoutMeaning(DomCode dom_code,
 281                               int flags,
 282                               DomKey* out_dom_key,
 283                               base::char16* out_character,
 284                               KeyboardCode* out_key_code) {
 285   if ((flags & EF_CONTROL_DOWN) == EF_CONTROL_DOWN) {
 286     if (DomCodeToControlCharacter(dom_code, flags, out_dom_key, out_character,
 287                                   out_key_code)) {
 288       return true;
 289     }
 290     if (!IsModifierDomCode(dom_code)) {
 291       *out_dom_key = DomKey::UNIDENTIFIED;
 292       *out_character = 0;
 293       *out_key_code = LocatedToNonLocatedKeyboardCode(
 294           DomCodeToUsLayoutKeyboardCode(dom_code));
 295       return true;
 296     }
 297   } else {
 298     for (const auto& it : kPrintableCodeMap) {
 299       if (it.dom_code == dom_code) {
 300         int state = ((flags & EF_SHIFT_DOWN) == EF_SHIFT_DOWN);
 301         base::char16 ch = it.character[state];
 302         *out_dom_key = DomKey::CHARACTER;
 303         *out_character = ch;
 304         if ((flags & EF_CAPS_LOCK_DOWN) == EF_CAPS_LOCK_DOWN) {
 305           ch |= 0x20;
 306           if ((ch >= 'a') && (ch <= 'z'))
 307             *out_character = it.character[state ^ 1];
 308         }
 309         *out_key_code = LocatedToNonLocatedKeyboardCode(
 310             DomCodeToUsLayoutKeyboardCode(dom_code));
 311         return true;
 312       }
 313     }
 314   }
 315   for (const auto& it : kNonPrintableCodeMap) {
 316     if (it.dom_code == dom_code) {
 317       *out_dom_key = it.dom_key;
 318       *out_character = it.character;
 319       *out_key_code = NonPrintableDomKeyToKeyboardCode(it.dom_key);
 320       return true;
 321     }
 322   }
 323   if ((flags & EF_CONTROL_DOWN) == EF_CONTROL_DOWN) {
 324     *out_dom_key = DomKey::UNIDENTIFIED;
 325     *out_character = 0;
 326     *out_key_code = LocatedToNonLocatedKeyboardCode(
 327         DomCodeToUsLayoutKeyboardCode(dom_code));
 328     return true;
 329   }
 330   return false;
 331 }
 332
 333 bool DomCodeToControlCharacter(DomCode dom_code,
 334                                int flags,
 335                                DomKey* dom_key,
 336                                base::char16* character,
 337                                KeyboardCode* key_code) {
 338   if ((flags & EF_CONTROL_DOWN) == 0)
 339     return false;
 340
 341   int code = static_cast<int>(dom_code);
 342   const int kKeyA = static_cast<int>(DomCode::KEY_A);
 343   // Control-A - Control-Z map to 0x01 - 0x1A.
 344   if (code >= kKeyA && code <= static_cast<int>(DomCode::KEY_Z)) {
 345     *character = static_cast<base::char16>(code - kKeyA + 1);
 346     switch (dom_code) {
 347       case DomCode::KEY_H:
 348         *dom_key = DomKey::BACKSPACE;
 349         *key_code = VKEY_BACK;
 350         break;
 351       case DomCode::KEY_I:
 352         *dom_key = DomKey::TAB;
 353         *key_code = VKEY_TAB;
 354         break;
 355       case DomCode::KEY_M:
 356         *dom_key = DomKey::ENTER;
 357         *key_code = VKEY_RETURN;
 358         break;
 359       default:
 360         *dom_key = DomKey::CHARACTER;
 361         *key_code = static_cast<KeyboardCode>(code - kKeyA + VKEY_A);
 362         break;
 363     }
 364     return true;
 365   }
 366
 367   if (flags & EF_SHIFT_DOWN) {
 368     switch (dom_code) {
 369       case DomCode::DIGIT2:
 370         // NUL
 371         *character = 0;
 372         *dom_key = DomKey::CHARACTER;
 373         *key_code = VKEY_2;
 374         return true;
 375       case DomCode::DIGIT6:
 376         // RS
 377         *character = 0x1E;
 378         *dom_key = DomKey::CHARACTER;
 379         *key_code = VKEY_6;
 380         return true;
 381       case DomCode::MINUS:
 382         // US
 383         *character = 0x1F;
 384         *dom_key = DomKey::CHARACTER;
 385         *key_code = VKEY_OEM_MINUS;
 386         return true;
 387       default:
 388         return false;
 389     }
 390   }
 391
 392   switch (dom_code) {
 393     case DomCode::ENTER:
 394       // NL
 395       *character = 0x0A;
 396       *dom_key = DomKey::CHARACTER;
 397       *key_code = VKEY_RETURN;
 398       return true;
 399     case DomCode::BRACKET_LEFT:
 400       // ESC
 401       *character = 0x1B;
 402       *dom_key = DomKey::ESCAPE;
 403       *key_code = VKEY_OEM_4;
 404       return true;
 405     case DomCode::BACKSLASH:
 406       // FS
 407       *character = 0x1C;
 408       *dom_key = DomKey::CHARACTER;
 409       *key_code = VKEY_OEM_5;
 410       return true;
 411     case DomCode::BRACKET_RIGHT:
 412       // GS
 413       *character = 0x1D;
 414       *dom_key = DomKey::CHARACTER;
 415       *key_code = VKEY_OEM_6;
 416       return true;
 417     default:
 418       return false;
 419   }
 420 }
 421
 422 DomKey CharacterToDomKey(uint32 character) {
 423   switch (character) {
 424     case 0x08:
 425       return DomKey::BACKSPACE;
 426     case 0x09:
 427       return DomKey::TAB;
 428     case 0x0D:
 429       return DomKey::ENTER;
 430     case 0x1B:
 431       return DomKey::ESCAPE;
 432     case 0x7F:
 433       return DomKey::DEL;
 434     default:
 435       return DomKey::CHARACTER;
 436   }
 437 }
 438
 439 // Returns a Windows-based VKEY for a non-printable DOM Level 3 |key|.
 440 // The returned VKEY is non-positional (e.g. VKEY_SHIFT).
 441 KeyboardCode NonPrintableDomKeyToKeyboardCode(DomKey dom_key) {
 442   for (const auto& it : kDomKeyToKeyboardCodeMap) {
 443     if (it.dom_key == dom_key)
 444       return it.key_code;
 445   }
 446   return VKEY_UNKNOWN;
 447 }
 448
 449 // Determine the non-located VKEY corresponding to a located VKEY.
 450 KeyboardCode LocatedToNonLocatedKeyboardCode(KeyboardCode key_code) {
 451   switch (key_code) {
 452     case VKEY_RWIN:
 453       return VKEY_LWIN;
 454     case VKEY_LSHIFT:
 455     case VKEY_RSHIFT:
 456       return VKEY_SHIFT;
 457     case VKEY_LCONTROL:
 458     case VKEY_RCONTROL:
 459       return VKEY_CONTROL;
 460     case VKEY_LMENU:
 461     case VKEY_RMENU:
 462       return VKEY_MENU;
 463     case VKEY_NUMPAD0:
 464       return VKEY_0;
 465     case VKEY_NUMPAD1:
 466       return VKEY_1;
 467     case VKEY_NUMPAD2:
 468       return VKEY_2;
 469     case VKEY_NUMPAD3:
 470       return VKEY_3;
 471     case VKEY_NUMPAD4:
 472       return VKEY_4;
 473     case VKEY_NUMPAD5:
 474       return VKEY_5;
 475     case VKEY_NUMPAD6:
 476       return VKEY_6;
 477     case VKEY_NUMPAD7:
 478       return VKEY_7;
 479     case VKEY_NUMPAD8:
 480       return VKEY_8;
 481     case VKEY_NUMPAD9:
 482       return VKEY_9;
 483     default:
 484       return key_code;
 485   }
 486 }
 487
 488 // Determine the located VKEY corresponding to a non-located VKEY.
 489 KeyboardCode NonLocatedToLocatedKeyboardCode(KeyboardCode key_code,
 490                                              DomCode dom_code) {
 491   switch (key_code) {
 492     case VKEY_SHIFT:
 493       return IsRightSideDomCode(dom_code) ? VKEY_RSHIFT : VKEY_LSHIFT;
 494     case VKEY_CONTROL:
 495       return IsRightSideDomCode(dom_code) ? VKEY_RCONTROL : VKEY_LCONTROL;
 496     case VKEY_MENU:
 497       return IsRightSideDomCode(dom_code) ? VKEY_RMENU : VKEY_LMENU;
 498     case VKEY_LWIN:
 499       return IsRightSideDomCode(dom_code) ? VKEY_RWIN : VKEY_LWIN;
 500     case VKEY_0:
 501       return (dom_code == DomCode::NUMPAD0) ? VKEY_NUMPAD0 : VKEY_0;
 502     case VKEY_1:
 503       return (dom_code == DomCode::NUMPAD1) ? VKEY_NUMPAD1 : VKEY_1;
 504     case VKEY_2:
 505       return (dom_code == DomCode::NUMPAD2) ? VKEY_NUMPAD2 : VKEY_2;
 506     case VKEY_3:
 507       return (dom_code == DomCode::NUMPAD3) ? VKEY_NUMPAD3 : VKEY_3;
 508     case VKEY_4:
 509       return (dom_code == DomCode::NUMPAD4) ? VKEY_NUMPAD4 : VKEY_4;
 510     case VKEY_5:
 511       return (dom_code == DomCode::NUMPAD5) ? VKEY_NUMPAD5 : VKEY_5;
 512     case VKEY_6:
 513       return (dom_code == DomCode::NUMPAD6) ? VKEY_NUMPAD6 : VKEY_6;
 514     case VKEY_7:
 515       return (dom_code == DomCode::NUMPAD7) ? VKEY_NUMPAD7 : VKEY_7;
 516     case VKEY_8:
 517       return (dom_code == DomCode::NUMPAD8) ? VKEY_NUMPAD8 : VKEY_8;
 518     case VKEY_9:
 519       return (dom_code == DomCode::NUMPAD9) ? VKEY_NUMPAD9 : VKEY_9;
 520     default:
 521       return key_code;
 522   }
 523 }
 524
 525 DomCode UsLayoutKeyboardCodeToDomCode(KeyboardCode key_code) {
 526   key_code = NonLocatedToLocatedKeyboardCode(key_code, DomCode::NONE);
 527   for (const auto& it : kDomCodeToKeyboardCodeMap) {
 528     if (it.key_code == key_code)
 529       return it.dom_code;
 530   }
 531   for (const auto& it : kFallbackKeyboardCodeToDomCodeMap) {
 532     if (it.key_code == key_code)
 533       return it.dom_code;
 534   }
 535   return DomCode::NONE;
 536 }
 537
 538 KeyboardCode DomCodeToUsLayoutKeyboardCode(DomCode dom_code) {
 539   const DomCodeToKeyboardCodeEntry* end =
 540       kDomCodeToKeyboardCodeMap + arraysize(kDomCodeToKeyboardCodeMap);
 541   const DomCodeToKeyboardCodeEntry* found = std::lower_bound(
 542       kDomCodeToKeyboardCodeMap, end, dom_code,
 543       [](const DomCodeToKeyboardCodeEntry& a, DomCode b) {
 544         return static_cast<int>(a.dom_code) < static_cast<int>(b);
 545       });
 546   if ((found != end) && (found->dom_code == dom_code))
 547     return found->key_code;
 548
 549   return VKEY_UNKNOWN;
 550 }
 551
 552 }  // namespace ui