[DomKey] Support Japanese (JIS) layout special keys

ui/events/keycodes/platform_key_map_win_unittest.cc

 // Copyright (c) 2016 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/keycodes/platform_key_map_win.h"
 
 #include "base/macros.h"
 #include "base/strings/string16.h"
 #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/dom/keycode_converter.h"
 #include "ui/events/keycodes/dom_us_layout_data.h"
 
 namespace ui {
 
 namespace {
 
 enum Layout {
   LAYOUT_US,
   LAYOUT_FR,
   LAYOUT_KR,
+  LAYOUT_JP,
 };
 
 // |LoadKeyboardLayout()| ensures the locale to be loaded into the system
 // (Similar to temporarily adding a locale in Control Panel), otherwise
 // |ToUnicodeEx()| will fall-back to the default locale.
 // See MSDN LoadKeyboardLayout():
 // https://msdn.microsoft.com/en-us/library/windows/desktop/ms646305(v=vs.85).aspx
 // And language constants and strings:
 // https://msdn.microsoft.com/en-us/library/windows/desktop/dd318693(v=vs.85).aspx
 HKL GetInputLocale(Layout layout) {
   switch (layout) {
     case LAYOUT_US:
       return ::LoadKeyboardLayout(L"00000409", KLF_ACTIVATE);
     case LAYOUT_FR:
       return ::LoadKeyboardLayout(L"0000040c", KLF_ACTIVATE);
     case LAYOUT_KR:
       // |LoadKeyboardLayout(L"00000412", KLF_ACTIVATE)| returns the correct
       // Korean locale, but it will fail on DrMemory tests.
       // See https://crbug.com/612736#c6
       // However we could bypass it since we are only testing non-printable keys
       // on Korean locale.
       // (This issue only happens on Korean and Japanese).
       return reinterpret_cast<HKL>(0x04120412);
+    case LAYOUT_JP:
+      return reinterpret_cast<HKL>(0x04110411);
     default:
       return 0;
   }
 }
 
 struct TestKey {
   KeyboardCode key_code;
   const char* normal;
   const char* shift;
   const char* capslock;
   const char* altgr;
   const char* shift_capslock;
   const char* shift_altgr;
   const char* altgr_capslock;
 };
 
 }  // anonymous namespace
 
 class PlatformKeyMapTest : public testing::Test {
  public:
   PlatformKeyMapTest() {}
   ~PlatformKeyMapTest() override {}
 
   void CheckKeyboardCodeToKeyString(const char* label,
                                     const PlatformKeyMap& keymap,
-                                    const TestKey& test_case,
-                                    HKL layout) {
+                                    const TestKey& test_case) {
     KeyboardCode key_code = test_case.key_code;
     EXPECT_STREQ(test_case.normal,
                  KeycodeConverter::DomKeyToKeyString(
                      keymap.DomKeyFromKeyboardCodeImpl(key_code, EF_NONE))
                      .c_str())
         << label;
     EXPECT_STREQ(test_case.shift,
                  KeycodeConverter::DomKeyToKeyString(
                      keymap.DomKeyFromKeyboardCodeImpl(key_code, EF_SHIFT_DOWN))
                      .c_str())
@@ skipping 21 matching lines @@
                      .c_str())
         << label;
     EXPECT_STREQ(test_case.altgr_capslock,
                  KeycodeConverter::DomKeyToKeyString(
                      keymap.DomKeyFromKeyboardCodeImpl(
                          key_code, EF_ALTGR_DOWN | EF_CAPS_LOCK_ON))
                      .c_str())
         << label;
   }
 
+  // Need this helper function to access private methods of |PlatformKeyMap|.
   DomKey DomKeyFromKeyboardCodeImpl(const PlatformKeyMap& keymap,
                                     KeyboardCode key_code,
                                     int flags) {
     return keymap.DomKeyFromKeyboardCodeImpl(key_code, flags);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PlatformKeyMapTest);
 };
 
 TEST_F(PlatformKeyMapTest, USLayout) {
-  HKL layout = GetInputLocale(LAYOUT_US);
-  PlatformKeyMap keymap(layout);
+  PlatformKeyMap keymap(GetInputLocale(LAYOUT_US));
 
   const TestKey kUSLayoutTestCases[] = {
       //       n    s    c    a    sc   sa   ac
       {VKEY_0, "0", ")", "0", "0", ")", ")", "0"},
       {VKEY_1, "1", "!", "1", "1", "!", "!", "1"},
       {VKEY_2, "2", "@", "2", "2", "@", "@", "2"},
       {VKEY_3, "3", "#", "3", "3", "#", "#", "3"},
       {VKEY_4, "4", "$", "4", "4", "$", "$", "4"},
       {VKEY_5, "5", "%", "5", "5", "%", "%", "5"},
       {VKEY_6, "6", "^", "6", "6", "^", "^", "6"},
@@ skipping 22 matching lines @@
       {VKEY_T, "t", "T", "T", "t", "t", "T", "T"},
       {VKEY_U, "u", "U", "U", "u", "u", "U", "U"},
       {VKEY_V, "v", "V", "V", "v", "v", "V", "V"},
       {VKEY_W, "w", "W", "W", "w", "w", "W", "W"},
       {VKEY_X, "x", "X", "X", "x", "x", "X", "X"},
       {VKEY_Y, "y", "Y", "Y", "y", "y", "Y", "Y"},
       {VKEY_Z, "z", "Z", "Z", "z", "z", "Z", "Z"},
   };
 
   for (const auto& test_case : kUSLayoutTestCases) {
-    CheckKeyboardCodeToKeyString("USLayout", keymap, test_case, layout);
+    CheckKeyboardCodeToKeyString("USLayout", keymap, test_case);
   }
 }
 
 TEST_F(PlatformKeyMapTest, FRLayout) {
-  HKL layout = GetInputLocale(LAYOUT_FR);
-  PlatformKeyMap keymap(layout);
+  PlatformKeyMap keymap(GetInputLocale(LAYOUT_FR));
 
   const TestKey kFRLayoutTestCases[] = {
       //       n     s    c    a       sc    sa   ac
       {VKEY_0, "à",  "0", "0", "@",    "à",  "0", "@"},
       {VKEY_1, "&",  "1", "1", "&",    "&",  "1", "1"},
       {VKEY_2, "é",  "2", "2", "Dead", "é",  "2", "Dead"},
       {VKEY_3, "\"", "3", "3", "#",    "\"", "3", "#"},
       {VKEY_4, "\'", "4", "4", "{",    "\'", "4", "{"},
       {VKEY_5, "(",  "5", "5", "[",    "(",  "5", "["},
       {VKEY_6, "-",  "6", "6", "|",    "-",  "6", "|"},
@@ skipping 22 matching lines @@
       {VKEY_T, "t",  "T", "T", "t",    "t",  "T", "T"},
       {VKEY_U, "u",  "U", "U", "u",    "u",  "U", "U"},
       {VKEY_V, "v",  "V", "V", "v",    "v",  "V", "V"},
       {VKEY_W, "w",  "W", "W", "w",    "w",  "W", "W"},
       {VKEY_X, "x",  "X", "X", "x",    "x",  "X", "X"},
       {VKEY_Y, "y",  "Y", "Y", "y",    "y",  "Y", "Y"},
       {VKEY_Z, "z",  "Z", "Z", "z",    "z",  "Z", "Z"},
   };
 
   for (const auto& test_case : kFRLayoutTestCases) {
-    CheckKeyboardCodeToKeyString("FRLayout", keymap, test_case, layout);
+    CheckKeyboardCodeToKeyString("FRLayout", keymap, test_case);
   }
 }
 
 TEST_F(PlatformKeyMapTest, NumPad) {
-  HKL layout = GetInputLocale(LAYOUT_US);
-  PlatformKeyMap keymap(layout);
+  PlatformKeyMap keymap(GetInputLocale(LAYOUT_US));
 
   const struct TestCase {
     KeyboardCode key_code;
     DomKey key;
   } kNumPadTestCases[] = {
       {VKEY_NUMPAD0, DomKey::FromCharacter('0')},
       {VKEY_NUMPAD1, DomKey::FromCharacter('1')},
       {VKEY_NUMPAD2, DomKey::FromCharacter('2')},
       {VKEY_NUMPAD3, DomKey::FromCharacter('3')},
       {VKEY_NUMPAD4, DomKey::FromCharacter('4')},
@@ skipping 67 matching lines @@
     EXPECT_EQ(test_case.dom_key,
               DomKeyFromKeyboardCodeImpl(keymap, key_code,
                                          EF_ALTGR_DOWN | EF_CONTROL_DOWN))
         << key_code << ", " << scan_code;
   }
 }
 
 TEST_F(PlatformKeyMapTest, KoreanSpecificKeys) {
   const struct TestCase {
     KeyboardCode key_code;
-    DomKey key;
+    DomKey kr_key;
+    DomKey us_key;
   } kKoreanTestCases[] = {
-      {VKEY_HANGUL, DomKey::HANGUL_MODE}, {VKEY_HANJA, DomKey::HANJA_MODE},
+      {VKEY_HANGUL, DomKey::HANGUL_MODE, DomKey::UNIDENTIFIED},
+      {VKEY_HANJA, DomKey::HANJA_MODE, DomKey::UNIDENTIFIED},
   };
 
-  // US English should not return values for these keys.
-  HKL us_layout = GetInputLocale(LAYOUT_US);
-  PlatformKeyMap us_keymap(us_layout);
+  PlatformKeyMap us_keymap(GetInputLocale(LAYOUT_US));
+  PlatformKeyMap kr_keymap(GetInputLocale(LAYOUT_KR));
   for (const auto& test_case : kKoreanTestCases) {
-    EXPECT_EQ(DomKey::NONE, DomKeyFromKeyboardCodeImpl(
-                                us_keymap, test_case.key_code, EF_NONE))
+    EXPECT_EQ(test_case.us_key, DomKeyFromKeyboardCodeImpl(
+                                    us_keymap, test_case.key_code, EF_NONE))
         << test_case.key_code;
-  }
-
-  // Korean layout should return specific DomKey.
-  HKL ko_layout = GetInputLocale(LAYOUT_KR);
-  PlatformKeyMap ko_keymap(ko_layout);
-  for (const auto& test_case : kKoreanTestCases) {
-    EXPECT_EQ(test_case.key, DomKeyFromKeyboardCodeImpl(
-                                 ko_keymap, test_case.key_code, EF_NONE))
+    EXPECT_EQ(test_case.kr_key, DomKeyFromKeyboardCodeImpl(
+                                    kr_keymap, test_case.key_code, EF_NONE))
         << test_case.key_code;
   }
 }
+
+TEST_F(PlatformKeyMapTest, JapaneseSpecificKeys) {
+  const struct TestCase {
+    KeyboardCode key_code;
+    DomKey jp_key;
+    DomKey us_key;
+  } kJapaneseTestCases[] = {
+      {VKEY_KANA, DomKey::KANA_MODE, DomKey::UNIDENTIFIED},
+      {VKEY_KANJI, DomKey::KANJI_MODE, DomKey::UNIDENTIFIED},
+      {VKEY_OEM_ATTN, DomKey::ALPHANUMERIC, DomKey::UNIDENTIFIED},
+      {VKEY_OEM_FINISH, DomKey::KATAKANA, DomKey::UNIDENTIFIED},
+      {VKEY_OEM_COPY, DomKey::HIRAGANA, DomKey::UNIDENTIFIED},
+      {VKEY_DBE_SBCSCHAR, DomKey::HANKAKU, DomKey::UNIDENTIFIED},
+      {VKEY_DBE_DBCSCHAR, DomKey::ZENKAKU, DomKey::UNIDENTIFIED},
+      {VKEY_OEM_BACKTAB, DomKey::ROMAJI, DomKey::UNIDENTIFIED},
+      {VKEY_ATTN, DomKey::KANA_MODE, DomKey::ATTN},
+  };
+
+  PlatformKeyMap us_keymap(GetInputLocale(LAYOUT_US));
+  PlatformKeyMap jp_keymap(GetInputLocale(LAYOUT_JP));
+  for (const auto& test_case : kJapaneseTestCases) {
+    EXPECT_EQ(test_case.us_key, DomKeyFromKeyboardCodeImpl(
+                                    us_keymap, test_case.key_code, EF_NONE))
+        << test_case.key_code;
+    EXPECT_EQ(test_case.jp_key, DomKeyFromKeyboardCodeImpl(
+                                    jp_keymap, test_case.key_code, EF_NONE))
+        << test_case.key_code;
+  }
+}
 
 }  // namespace ui