Generate located Windows keycodes for number pad keys under Ozone

ui/events/ozone/layout/xkb/xkb_keyboard_layout_engine.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 "ui/events/ozone/layout/xkb/xkb_keyboard_layout_engine.h"
 
 #include <stddef.h>
 #include <xkbcommon/xkbcommon-names.h>
 
 #include "base/bind.h"
@@ skipping 13 matching lines @@
 #include "ui/events/keycodes/keyboard_code_conversion_xkb.h"
 
 namespace ui {
 
 namespace {
 
 typedef base::Callback<void(const std::string&,
                             scoped_ptr<char, base::FreeDeleter>)>
     LoadKeymapCallback;
 
-KeyboardCode AlphanumericKeyboardCode(base::char16 character) {
+KeyboardCode AlphanumericKeyboardCode(xkb_keysym_t xkb_keysym,
+                                      base::char16 character) {
   // Plain ASCII letters and digits map directly to VKEY values.
-  if ((character >= '0') && (character <= '9'))
-    return static_cast<KeyboardCode>(VKEY_0 + character - '0');
+  if ((character >= '0') && (character <= '9')) {
+    int zero = ((xkb_keysym >= XKB_KEY_KP_0) && (xkb_keysym <= XKB_KEY_KP_9))
+                   ? VKEY_NUMPAD0
+                   : VKEY_0;
+    return static_cast<KeyboardCode>(zero + character - '0');
+  }
   if ((character >= 'a') && (character <= 'z'))
     return static_cast<KeyboardCode>(VKEY_A + character - 'a');
   if ((character >= 'A') && (character <= 'Z'))
     return static_cast<KeyboardCode>(VKEY_A + character - 'A');
   return VKEY_UNKNOWN;
 }
 
 // These tables map layout-dependent printable characters/codes
 // to legacy Windows-based VKEY values.
 //
@@ skipping 720 matching lines @@
                   &normal_character) &&
         !IsControlCharacter(normal_character)) {
       flags = normal_ui_flags;
       xkb_flags = normal_xkb_flags;
       character = normal_character;
       xkb_keysym = normal_keysym;
     }
   }
 
   *dom_key = DomKey::FromCharacter(character);
-  *key_code = AlphanumericKeyboardCode(character);
+  *key_code = AlphanumericKeyboardCode(xkb_keysym, character);
   if (*key_code == VKEY_UNKNOWN) {
     *key_code = DifficultKeyboardCode(dom_code, flags, xkb_keycode, xkb_flags,
                                       xkb_keysym, character);
     if (*key_code == VKEY_UNKNOWN)
       *key_code = DomCodeToUsLayoutNonLocatedKeyboardCode(dom_code);
   }
   return true;
 }
 
 void XkbKeyboardLayoutEngine::SetKeymapFromStringForTest(
@@ skipping 80 matching lines @@
   uint32_t plain_character;
   if (!XkbLookup(xkb_keycode, 0, &plain_keysym, &plain_character))
     return VKEY_UNKNOWN;
 
   // If the plain key is non-printable, that determines the VKEY.
   DomKey plain_key = NonPrintableXKeySymToDomKey(plain_keysym);
   if (plain_key != ui::DomKey::NONE)
     return NonPrintableDomKeyToKeyboardCode(plain_key);
 
   // Plain ASCII letters and digits map directly to VKEY values.
-  KeyboardCode key_code = AlphanumericKeyboardCode(plain_character);
+  KeyboardCode key_code = AlphanumericKeyboardCode(xkb_keysym, plain_character);
   if (key_code != VKEY_UNKNOWN)
     return key_code;
 
   // Check the multi-character tables.
   const PrintableMultiEntry* multi_end = kMultiMap + arraysize(kMultiMap);
   const PrintableMultiEntry* multi =
       std::lower_bound(kMultiMap, multi_end, plain_character,
                        [](const PrintableMultiEntry& e, base::char16 c) {
         return e.plain_character < c;
       });
@@ skipping 66 matching lines @@
       close_index = layout_name.size();
     *layout_variant = layout_name.substr(parentheses_index + 1,
                                          close_index - parentheses_index - 1);
   } else if (dash_index != std::string::npos) {
     *layout_id = layout_name.substr(0, dash_index);
     *layout_variant = layout_name.substr(dash_index + 1);
   }
 }
 
 }  // namespace ui