src/chrome/browser/ui/ash/event_rewriter_unittest.cc

   1 // Copyright (c) 2012 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 "chrome/browser/ui/ash/event_rewriter.h"
   6
   7 #include "base/basictypes.h"
   8 #include "base/command_line.h"
   9 #include "base/prefs/pref_member.h"
  10 #include "base/strings/stringprintf.h"
  11 #include "chrome/common/pref_names.h"
  12 #include "chrome/test/base/testing_pref_service_syncable.h"
  13 #include "testing/gtest/include/gtest/gtest.h"
  14 #include "ui/events/event.h"
  15
  16 #if defined(OS_CHROMEOS)
  17 #include <X11/keysym.h>
  18 #include <X11/XF86keysym.h>
  19 #include <X11/Xlib.h>
  20
  21 #include "ash/test/ash_test_base.h"
  22 #include "ash/wm/window_state.h"
  23 #include "chrome/browser/chromeos/input_method/input_method_configuration.h"
  24 #include "chrome/browser/chromeos/input_method/mock_input_method_manager.h"
  25 #include "chrome/browser/chromeos/login/mock_user_manager.h"
  26 #include "chrome/browser/chromeos/login/user_manager.h"
  27 #include "chrome/browser/chromeos/preferences.h"
  28 #include "chromeos/chromeos_switches.h"
  29 #include "chromeos/ime/mock_xkeyboard.h"
  30 #include "ui/aura/window.h"
  31 #include "ui/events/x/events_x_utils.h"
  32 #include "ui/gfx/x/x11_types.h"
  33
  34 namespace {
  35
  36 void InitXKeyEvent(ui::KeyboardCode ui_keycode,
  37                    int ui_flags,
  38                    ui::EventType ui_type,
  39                    KeyCode x_keycode,
  40                    unsigned int x_state,
  41                    XEvent* event) {
  42   ui::InitXKeyEventForTesting(ui_type,
  43                               ui_keycode,
  44                               ui_flags,
  45                               event);
  46   event->xkey.keycode = x_keycode;
  47   event->xkey.state = x_state;
  48 }
  49
  50 std::string GetRewrittenEventAsString(EventRewriter* rewriter,
  51                                       ui::KeyboardCode ui_keycode,
  52                                       int ui_flags,
  53                                       ui::EventType ui_type,
  54                                       KeyCode x_keycode,
  55                                       unsigned int x_state) {
  56   XEvent xev;
  57   InitXKeyEvent(ui_keycode, ui_flags, ui_type, x_keycode, x_state, &xev);
  58   ui::KeyEvent keyevent(&xev, false /* is_char */);
  59   rewriter->RewriteForTesting(&keyevent);
  60   return base::StringPrintf(
  61       "ui_keycode=%d ui_flags=%d ui_type=%d x_keycode=%u x_state=%u x_type=%d",
  62       keyevent.key_code(), keyevent.flags(), keyevent.type(),
  63       xev.xkey.keycode, xev.xkey.state, xev.xkey.type);
  64 }
  65
  66 std::string GetExpectedResultAsString(ui::KeyboardCode ui_keycode,
  67                                       int ui_flags,
  68                                       ui::EventType ui_type,
  69                                       KeyCode x_keycode,
  70                                       unsigned int x_state,
  71                                       int x_type) {
  72   return base::StringPrintf(
  73       "ui_keycode=%d ui_flags=%d ui_type=%d x_keycode=%u x_state=%u x_type=%d",
  74       ui_keycode, ui_flags, ui_type, x_keycode, x_state, x_type);
  75 }
  76
  77 class EventRewriterTest : public testing::Test {
  78  public:
  79   EventRewriterTest()
  80       : display_(gfx::GetXDisplay()),
  81         keycode_a_(XKeysymToKeycode(display_, XK_a)),
  82         keycode_alt_l_(XKeysymToKeycode(display_, XK_Alt_L)),
  83         keycode_alt_r_(XKeysymToKeycode(display_, XK_Alt_R)),
  84         keycode_b_(XKeysymToKeycode(display_, XK_B)),
  85         keycode_caps_lock_(XKeysymToKeycode(display_, XK_Caps_Lock)),
  86         keycode_control_l_(XKeysymToKeycode(display_, XK_Control_L)),
  87         keycode_control_r_(XKeysymToKeycode(display_, XK_Control_R)),
  88         keycode_meta_l_(XKeysymToKeycode(display_, XK_Meta_L)),
  89         keycode_meta_r_(XKeysymToKeycode(display_, XK_Meta_R)),
  90         keycode_num_pad_0_(XKeysymToKeycode(display_, XK_KP_0)),
  91         keycode_num_pad_1_(XKeysymToKeycode(display_, XK_KP_1)),
  92         keycode_num_pad_2_(XKeysymToKeycode(display_, XK_KP_2)),
  93         keycode_num_pad_3_(XKeysymToKeycode(display_, XK_KP_3)),
  94         keycode_num_pad_4_(XKeysymToKeycode(display_, XK_KP_4)),
  95         keycode_num_pad_5_(XKeysymToKeycode(display_, XK_KP_5)),
  96         keycode_num_pad_6_(XKeysymToKeycode(display_, XK_KP_6)),
  97         keycode_num_pad_7_(XKeysymToKeycode(display_, XK_KP_7)),
  98         keycode_num_pad_8_(XKeysymToKeycode(display_, XK_KP_8)),
  99         keycode_num_pad_9_(XKeysymToKeycode(display_, XK_KP_9)),
 100         keycode_num_pad_begin_(XKeysymToKeycode(display_, XK_KP_Begin)),
 101         keycode_num_pad_decimal_(XKeysymToKeycode(display_, XK_KP_Decimal)),
 102         keycode_num_pad_delete_(XKeysymToKeycode(display_, XK_KP_Delete)),
 103         keycode_num_pad_down_(XKeysymToKeycode(display_, XK_KP_Down)),
 104         keycode_num_pad_end_(XKeysymToKeycode(display_, XK_KP_End)),
 105         keycode_num_pad_home_(XKeysymToKeycode(display_, XK_KP_Home)),
 106         keycode_num_pad_insert_(XKeysymToKeycode(display_, XK_KP_Insert)),
 107         keycode_num_pad_left_(XKeysymToKeycode(display_, XK_KP_Left)),
 108         keycode_num_pad_next_(XKeysymToKeycode(display_, XK_KP_Next)),
 109         keycode_num_pad_prior_(XKeysymToKeycode(display_, XK_KP_Prior)),
 110         keycode_num_pad_right_(XKeysymToKeycode(display_, XK_KP_Right)),
 111         keycode_num_pad_up_(XKeysymToKeycode(display_, XK_KP_Up)),
 112         keycode_super_l_(XKeysymToKeycode(display_, XK_Super_L)),
 113         keycode_super_r_(XKeysymToKeycode(display_, XK_Super_R)),
 114         keycode_void_symbol_(XKeysymToKeycode(display_, XK_VoidSymbol)),
 115         keycode_delete_(XKeysymToKeycode(display_, XK_Delete)),
 116         keycode_backspace_(XKeysymToKeycode(display_, XK_BackSpace)),
 117         keycode_up_(XKeysymToKeycode(display_, XK_Up)),
 118         keycode_down_(XKeysymToKeycode(display_, XK_Down)),
 119         keycode_left_(XKeysymToKeycode(display_, XK_Left)),
 120         keycode_right_(XKeysymToKeycode(display_, XK_Right)),
 121         keycode_prior_(XKeysymToKeycode(display_, XK_Prior)),
 122         keycode_next_(XKeysymToKeycode(display_, XK_Next)),
 123         keycode_home_(XKeysymToKeycode(display_, XK_Home)),
 124         keycode_end_(XKeysymToKeycode(display_, XK_End)),
 125         keycode_escape_(XKeysymToKeycode(display_, XK_Escape)),
 126         keycode_launch6_(XKeysymToKeycode(display_, XF86XK_Launch6)),
 127         keycode_launch7_(XKeysymToKeycode(display_, XF86XK_Launch7)),
 128         keycode_f1_(XKeysymToKeycode(display_, XK_F1)),
 129         keycode_f2_(XKeysymToKeycode(display_, XK_F2)),
 130         keycode_f3_(XKeysymToKeycode(display_, XK_F3)),
 131         keycode_f4_(XKeysymToKeycode(display_, XK_F4)),
 132         keycode_f5_(XKeysymToKeycode(display_, XK_F5)),
 133         keycode_f6_(XKeysymToKeycode(display_, XK_F6)),
 134         keycode_f7_(XKeysymToKeycode(display_, XK_F7)),
 135         keycode_f8_(XKeysymToKeycode(display_, XK_F8)),
 136         keycode_f9_(XKeysymToKeycode(display_, XK_F9)),
 137         keycode_f10_(XKeysymToKeycode(display_, XK_F10)),
 138         keycode_f11_(XKeysymToKeycode(display_, XK_F11)),
 139         keycode_f12_(XKeysymToKeycode(display_, XK_F12)),
 140         keycode_browser_back_(XKeysymToKeycode(display_, XF86XK_Back)),
 141         keycode_browser_forward_(XKeysymToKeycode(display_, XF86XK_Forward)),
 142         keycode_browser_refresh_(XKeysymToKeycode(display_, XF86XK_Reload)),
 143         keycode_media_launch_app1_(XKeysymToKeycode(display_, XF86XK_LaunchA)),
 144         keycode_media_launch_app2_(XKeysymToKeycode(display_, XF86XK_LaunchB)),
 145         keycode_brightness_down_(XKeysymToKeycode(
 146             display_, XF86XK_MonBrightnessDown)),
 147         keycode_brightness_up_(XKeysymToKeycode(
 148             display_, XF86XK_MonBrightnessUp)),
 149         keycode_volume_mute_(XKeysymToKeycode(display_, XF86XK_AudioMute)),
 150         keycode_volume_down_(XKeysymToKeycode(
 151             display_, XF86XK_AudioLowerVolume)),
 152         keycode_volume_up_(XKeysymToKeycode(
 153             display_, XF86XK_AudioRaiseVolume)),
 154         keycode_power_(XKeysymToKeycode(display_, XF86XK_PowerOff)),
 155         keycode_1_(XKeysymToKeycode(display_, XK_1)),
 156         keycode_2_(XKeysymToKeycode(display_, XK_2)),
 157         keycode_3_(XKeysymToKeycode(display_, XK_3)),
 158         keycode_4_(XKeysymToKeycode(display_, XK_4)),
 159         keycode_5_(XKeysymToKeycode(display_, XK_5)),
 160         keycode_6_(XKeysymToKeycode(display_, XK_6)),
 161         keycode_7_(XKeysymToKeycode(display_, XK_7)),
 162         keycode_8_(XKeysymToKeycode(display_, XK_8)),
 163         keycode_9_(XKeysymToKeycode(display_, XK_9)),
 164         keycode_0_(XKeysymToKeycode(display_, XK_0)),
 165         keycode_minus_(XKeysymToKeycode(display_, XK_minus)),
 166         keycode_equal_(XKeysymToKeycode(display_, XK_equal)),
 167         keycode_period_(XKeysymToKeycode(display_, XK_period)),
 168         keycode_insert_(XKeysymToKeycode(display_, XK_Insert)),
 169         mock_user_manager_(new chromeos::MockUserManager),
 170         user_manager_enabler_(mock_user_manager_),
 171         input_method_manager_mock_(NULL) {
 172   }
 173   virtual ~EventRewriterTest() {}
 174
 175   virtual void SetUp() {
 176     // Mocking user manager because the real one needs to be called on UI thread
 177     EXPECT_CALL(*mock_user_manager_, IsLoggedInAsGuest())
 178         .WillRepeatedly(testing::Return(false));
 179     input_method_manager_mock_ =
 180         new chromeos::input_method::MockInputMethodManager;
 181     chromeos::input_method::InitializeForTesting(
 182         input_method_manager_mock_);  // pass ownership
 183   }
 184
 185   virtual void TearDown() {
 186     // Shutdown() deletes the IME mock object.
 187     chromeos::input_method::Shutdown();
 188   }
 189
 190  protected:
 191   void TestRewriteNumPadKeys();
 192   void TestRewriteNumPadKeysOnAppleKeyboard();
 193
 194   Display* display_;
 195   const KeyCode keycode_a_;
 196   const KeyCode keycode_alt_l_;
 197   const KeyCode keycode_alt_r_;
 198   const KeyCode keycode_b_;
 199   const KeyCode keycode_caps_lock_;
 200   const KeyCode keycode_control_l_;
 201   const KeyCode keycode_control_r_;
 202   const KeyCode keycode_meta_l_;
 203   const KeyCode keycode_meta_r_;
 204   const KeyCode keycode_num_pad_0_;
 205   const KeyCode keycode_num_pad_1_;
 206   const KeyCode keycode_num_pad_2_;
 207   const KeyCode keycode_num_pad_3_;
 208   const KeyCode keycode_num_pad_4_;
 209   const KeyCode keycode_num_pad_5_;
 210   const KeyCode keycode_num_pad_6_;
 211   const KeyCode keycode_num_pad_7_;
 212   const KeyCode keycode_num_pad_8_;
 213   const KeyCode keycode_num_pad_9_;
 214   const KeyCode keycode_num_pad_begin_;
 215   const KeyCode keycode_num_pad_decimal_;
 216   const KeyCode keycode_num_pad_delete_;
 217   const KeyCode keycode_num_pad_down_;
 218   const KeyCode keycode_num_pad_end_;
 219   const KeyCode keycode_num_pad_home_;
 220   const KeyCode keycode_num_pad_insert_;
 221   const KeyCode keycode_num_pad_left_;
 222   const KeyCode keycode_num_pad_next_;
 223   const KeyCode keycode_num_pad_prior_;
 224   const KeyCode keycode_num_pad_right_;
 225   const KeyCode keycode_num_pad_up_;
 226   const KeyCode keycode_super_l_;
 227   const KeyCode keycode_super_r_;
 228   const KeyCode keycode_void_symbol_;
 229   const KeyCode keycode_delete_;
 230   const KeyCode keycode_backspace_;
 231   const KeyCode keycode_up_;
 232   const KeyCode keycode_down_;
 233   const KeyCode keycode_left_;
 234   const KeyCode keycode_right_;
 235   const KeyCode keycode_prior_;
 236   const KeyCode keycode_next_;
 237   const KeyCode keycode_home_;
 238   const KeyCode keycode_end_;
 239   const KeyCode keycode_escape_;
 240   const KeyCode keycode_launch6_;  // F15
 241   const KeyCode keycode_launch7_;  // F16
 242   const KeyCode keycode_f1_;
 243   const KeyCode keycode_f2_;
 244   const KeyCode keycode_f3_;
 245   const KeyCode keycode_f4_;
 246   const KeyCode keycode_f5_;
 247   const KeyCode keycode_f6_;
 248   const KeyCode keycode_f7_;
 249   const KeyCode keycode_f8_;
 250   const KeyCode keycode_f9_;
 251   const KeyCode keycode_f10_;
 252   const KeyCode keycode_f11_;
 253   const KeyCode keycode_f12_;
 254   const KeyCode keycode_browser_back_;
 255   const KeyCode keycode_browser_forward_;
 256   const KeyCode keycode_browser_refresh_;
 257   const KeyCode keycode_media_launch_app1_;
 258   const KeyCode keycode_media_launch_app2_;
 259   const KeyCode keycode_brightness_down_;
 260   const KeyCode keycode_brightness_up_;
 261   const KeyCode keycode_volume_mute_;
 262   const KeyCode keycode_volume_down_;
 263   const KeyCode keycode_volume_up_;
 264   const KeyCode keycode_power_;
 265   const KeyCode keycode_1_;
 266   const KeyCode keycode_2_;
 267   const KeyCode keycode_3_;
 268   const KeyCode keycode_4_;
 269   const KeyCode keycode_5_;
 270   const KeyCode keycode_6_;
 271   const KeyCode keycode_7_;
 272   const KeyCode keycode_8_;
 273   const KeyCode keycode_9_;
 274   const KeyCode keycode_0_;
 275   const KeyCode keycode_minus_;
 276   const KeyCode keycode_equal_;
 277   const KeyCode keycode_period_;
 278   const KeyCode keycode_insert_;
 279   chromeos::MockUserManager* mock_user_manager_;  // Not owned.
 280   chromeos::ScopedUserManagerEnabler user_manager_enabler_;
 281   chromeos::input_method::MockInputMethodManager* input_method_manager_mock_;
 282 };
 283
 284 }  // namespace
 285 #else
 286 class EventRewriterTest : public testing::Test {
 287  public:
 288   EventRewriterTest() {}
 289   virtual ~EventRewriterTest() {}
 290 };
 291 #endif
 292
 293 TEST_F(EventRewriterTest, TestGetDeviceType) {
 294   // This is the typical string which an Apple keyboard sends.
 295   EXPECT_EQ(EventRewriter::kDeviceAppleKeyboard,
 296             EventRewriter::GetDeviceType("Apple Inc. Apple Keyboard"));
 297
 298   // Other cases we accept.
 299   EXPECT_EQ(EventRewriter::kDeviceAppleKeyboard,
 300             EventRewriter::GetDeviceType("Apple Keyboard"));
 301   EXPECT_EQ(EventRewriter::kDeviceAppleKeyboard,
 302             EventRewriter::GetDeviceType("apple keyboard"));
 303   EXPECT_EQ(EventRewriter::kDeviceAppleKeyboard,
 304             EventRewriter::GetDeviceType("apple keyboard."));
 305   EXPECT_EQ(EventRewriter::kDeviceAppleKeyboard,
 306             EventRewriter::GetDeviceType("apple.keyboard."));
 307   EXPECT_EQ(EventRewriter::kDeviceAppleKeyboard,
 308             EventRewriter::GetDeviceType(".apple.keyboard."));
 309
 310   // Dell, Microsoft, Logitech, ... should be recognized as a kDeviceUnknown.
 311   EXPECT_EQ(EventRewriter::kDeviceUnknown,
 312             EventRewriter::GetDeviceType("Dell Dell USB Entry Keyboard"));
 313   EXPECT_EQ(EventRewriter::kDeviceUnknown,
 314             EventRewriter::GetDeviceType(
 315                 "Microsoft Natural Ergonomic Keyboard"));
 316   EXPECT_EQ(EventRewriter::kDeviceUnknown,
 317             EventRewriter::GetDeviceType("CHESEN USB Keyboard"));
 318
 319   // Some corner cases.
 320   EXPECT_EQ(EventRewriter::kDeviceUnknown, EventRewriter::GetDeviceType(""));
 321   EXPECT_EQ(EventRewriter::kDeviceUnknown,
 322             EventRewriter::GetDeviceType("."));
 323   EXPECT_EQ(EventRewriter::kDeviceUnknown,
 324             EventRewriter::GetDeviceType(". "));
 325   EXPECT_EQ(EventRewriter::kDeviceUnknown,
 326             EventRewriter::GetDeviceType(" ."));
 327   EXPECT_EQ(EventRewriter::kDeviceUnknown,
 328             EventRewriter::GetDeviceType("not-an-apple keyboard"));
 329 }
 330
 331 TEST_F(EventRewriterTest, TestDeviceAddedOrRemoved) {
 332   EventRewriter rewriter;
 333   EXPECT_TRUE(rewriter.device_id_to_type_for_testing().empty());
 334   EXPECT_EQ(EventRewriter::kDeviceUnknown,
 335             rewriter.DeviceAddedForTesting(0, "PC Keyboard"));
 336   EXPECT_EQ(1U, rewriter.device_id_to_type_for_testing().size());
 337   EXPECT_EQ(EventRewriter::kDeviceAppleKeyboard,
 338             rewriter.DeviceAddedForTesting(1, "Apple Keyboard"));
 339   EXPECT_EQ(2U, rewriter.device_id_to_type_for_testing().size());
 340   // Try to reuse the first ID.
 341   EXPECT_EQ(EventRewriter::kDeviceAppleKeyboard,
 342             rewriter.DeviceAddedForTesting(0, "Apple Keyboard"));
 343   EXPECT_EQ(2U, rewriter.device_id_to_type_for_testing().size());
 344 }
 345
 346 #if defined(OS_CHROMEOS)
 347 TEST_F(EventRewriterTest, TestRewriteCommandToControl) {
 348   // First, test with a PC keyboard.
 349   TestingPrefServiceSyncable prefs;
 350   EventRewriter rewriter;
 351   rewriter.DeviceAddedForTesting(0, "PC Keyboard");
 352   rewriter.set_last_device_id_for_testing(0);
 353   rewriter.set_pref_service_for_testing(&prefs);
 354
 355   // XK_a, Alt modifier.
 356   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_A,
 357                                       ui::EF_ALT_DOWN,
 358                                       ui::ET_KEY_PRESSED,
 359                                       keycode_a_,
 360                                       Mod1Mask,
 361                                       KeyPress),
 362             GetRewrittenEventAsString(&rewriter,
 363                                       ui::VKEY_A,
 364                                       ui::EF_ALT_DOWN,
 365                                       ui::ET_KEY_PRESSED,
 366                                       keycode_a_,
 367                                       Mod1Mask));
 368
 369   // XK_a, Win modifier.
 370   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_A,
 371                                       0,
 372                                       ui::ET_KEY_PRESSED,
 373                                       keycode_a_,
 374                                       Mod4Mask,
 375                                       KeyPress),
 376             GetRewrittenEventAsString(&rewriter,
 377                                       ui::VKEY_A,
 378                                       0,
 379                                       ui::ET_KEY_PRESSED,
 380                                       keycode_a_,
 381                                       Mod4Mask));
 382
 383   // XK_a, Alt+Win modifier.
 384   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_A,
 385                                       ui::EF_ALT_DOWN,
 386                                       ui::ET_KEY_PRESSED,
 387                                       keycode_a_,
 388                                       Mod1Mask | Mod4Mask,
 389                                       KeyPress),
 390             GetRewrittenEventAsString(&rewriter,
 391                                       ui::VKEY_A,
 392                                       ui::EF_ALT_DOWN,
 393                                       ui::ET_KEY_PRESSED,
 394                                       keycode_a_,
 395                                       Mod1Mask | Mod4Mask));
 396
 397   // XK_Super_L (left Windows key), Alt modifier.
 398   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_LWIN,
 399                                       ui::EF_ALT_DOWN,
 400                                       ui::ET_KEY_PRESSED,
 401                                       keycode_super_l_,
 402                                       Mod1Mask,
 403                                       KeyPress),
 404             GetRewrittenEventAsString(&rewriter,
 405                                       ui::VKEY_LWIN,
 406                                       ui::EF_ALT_DOWN,
 407                                       ui::ET_KEY_PRESSED,
 408                                       keycode_super_l_,
 409                                       Mod1Mask));
 410
 411   // XK_Super_R (right Windows key), Alt modifier.
 412   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_RWIN,
 413                                       ui::EF_ALT_DOWN,
 414                                       ui::ET_KEY_PRESSED,
 415                                       keycode_super_r_,
 416                                       Mod1Mask,
 417                                       KeyPress),
 418             GetRewrittenEventAsString(&rewriter,
 419                                       ui::VKEY_RWIN,
 420                                       ui::EF_ALT_DOWN,
 421                                       ui::ET_KEY_PRESSED,
 422                                       keycode_super_r_,
 423                                       Mod1Mask));
 424
 425   // An Apple keyboard reusing the ID, zero.
 426   rewriter.DeviceAddedForTesting(0, "Apple Keyboard");
 427   rewriter.set_last_device_id_for_testing(0);
 428
 429   // XK_a, Alt modifier.
 430   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_A,
 431                                       ui::EF_ALT_DOWN,
 432                                       ui::ET_KEY_PRESSED,
 433                                       keycode_a_,
 434                                       Mod1Mask,
 435                                       KeyPress),
 436             GetRewrittenEventAsString(&rewriter,
 437                                       ui::VKEY_A,
 438                                       ui::EF_ALT_DOWN,
 439                                       ui::ET_KEY_PRESSED,
 440                                       keycode_a_,
 441                                       Mod1Mask));
 442
 443   // XK_a, Win modifier.
 444   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_A,
 445                                       ui::EF_CONTROL_DOWN,
 446                                       ui::ET_KEY_PRESSED,
 447                                       keycode_a_,
 448                                       ControlMask,
 449                                       KeyPress),
 450             GetRewrittenEventAsString(&rewriter,
 451                                       ui::VKEY_A,
 452                                       0,
 453                                       ui::ET_KEY_PRESSED,
 454                                       keycode_a_,
 455                                       Mod4Mask));
 456
 457   // XK_a, Alt+Win modifier.
 458   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_A,
 459                                       ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN,
 460                                       ui::ET_KEY_PRESSED,
 461                                       keycode_a_,
 462                                       Mod1Mask | ControlMask,
 463                                       KeyPress),
 464             GetRewrittenEventAsString(&rewriter,
 465                                       ui::VKEY_A,
 466                                       ui::EF_ALT_DOWN,
 467                                       ui::ET_KEY_PRESSED,
 468                                       keycode_a_,
 469                                       Mod1Mask | Mod4Mask));
 470
 471   // XK_Super_L (left Windows key), Alt modifier.
 472   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CONTROL,
 473                                       ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN,
 474                                       ui::ET_KEY_PRESSED,
 475                                       keycode_control_l_,
 476                                       Mod1Mask,
 477                                       KeyPress),
 478             GetRewrittenEventAsString(&rewriter,
 479                                       ui::VKEY_LWIN,
 480                                       ui::EF_ALT_DOWN,
 481                                       ui::ET_KEY_PRESSED,
 482                                       keycode_super_l_,
 483                                       Mod1Mask));
 484
 485   // XK_Super_R (right Windows key), Alt modifier.
 486   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CONTROL,
 487                                       ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN,
 488                                       ui::ET_KEY_PRESSED,
 489                                       keycode_control_r_,
 490                                       Mod1Mask,
 491                                       KeyPress),
 492             GetRewrittenEventAsString(&rewriter,
 493                                       ui::VKEY_RWIN,
 494                                       ui::EF_ALT_DOWN,
 495                                       ui::ET_KEY_PRESSED,
 496                                       keycode_super_r_,
 497                                       Mod1Mask));
 498 }
 499
 500 // For crbug.com/133896.
 501 TEST_F(EventRewriterTest, TestRewriteCommandToControlWithControlRemapped) {
 502   // Remap Control to Alt.
 503   TestingPrefServiceSyncable prefs;
 504   chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
 505   IntegerPrefMember control;
 506   control.Init(prefs::kLanguageRemapControlKeyTo, &prefs);
 507   control.SetValue(chromeos::input_method::kAltKey);
 508
 509   EventRewriter rewriter;
 510   rewriter.set_pref_service_for_testing(&prefs);
 511   rewriter.DeviceAddedForTesting(0, "PC Keyboard");
 512   rewriter.set_last_device_id_for_testing(0);
 513
 514   // XK_Control_L (left Control key) should be remapped to Alt.
 515   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_MENU,
 516                                       ui::EF_ALT_DOWN,
 517                                       ui::ET_KEY_PRESSED,
 518                                       keycode_alt_l_,
 519                                       0U,
 520                                       KeyPress),
 521             GetRewrittenEventAsString(&rewriter,
 522                                       ui::VKEY_CONTROL,
 523                                       0,
 524                                       ui::ET_KEY_PRESSED,
 525                                       keycode_control_l_,
 526                                       0U));
 527
 528   // An Apple keyboard reusing the ID, zero.
 529   rewriter.DeviceAddedForTesting(0, "Apple Keyboard");
 530   rewriter.set_last_device_id_for_testing(0);
 531
 532   // XK_Super_L (left Command key) with  Alt modifier. The remapped Command key
 533   // should never be re-remapped to Alt.
 534   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CONTROL,
 535                                       ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN,
 536                                       ui::ET_KEY_PRESSED,
 537                                       keycode_control_l_,
 538                                       Mod1Mask,
 539                                       KeyPress),
 540             GetRewrittenEventAsString(&rewriter,
 541                                       ui::VKEY_LWIN,
 542                                       ui::EF_ALT_DOWN,
 543                                       ui::ET_KEY_PRESSED,
 544                                       keycode_super_l_,
 545                                       Mod1Mask));
 546
 547   // XK_Super_R (right Command key) with  Alt modifier. The remapped Command key
 548   // should never be re-remapped to Alt.
 549   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CONTROL,
 550                                       ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN,
 551                                       ui::ET_KEY_PRESSED,
 552                                       keycode_control_r_,
 553                                       Mod1Mask,
 554                                       KeyPress),
 555             GetRewrittenEventAsString(&rewriter,
 556                                       ui::VKEY_RWIN,
 557                                       ui::EF_ALT_DOWN,
 558                                       ui::ET_KEY_PRESSED,
 559                                       keycode_super_r_,
 560                                       Mod1Mask));
 561 }
 562
 563 void EventRewriterTest::TestRewriteNumPadKeys() {
 564   TestingPrefServiceSyncable prefs;
 565   EventRewriter rewriter;
 566   rewriter.set_pref_service_for_testing(&prefs);
 567
 568   // XK_KP_Insert (= NumPad 0 without Num Lock), no modifier.
 569   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_NUMPAD0,
 570                                       0,
 571                                       ui::ET_KEY_PRESSED,
 572                                       keycode_num_pad_0_,
 573                                       Mod2Mask,  // Num Lock
 574                                       KeyPress),
 575             GetRewrittenEventAsString(&rewriter,
 576                                       ui::VKEY_INSERT,
 577                                       0,
 578                                       ui::ET_KEY_PRESSED,
 579                                       keycode_num_pad_insert_,
 580                                       0));
 581
 582   // XK_KP_Insert (= NumPad 0 without Num Lock), Alt modifier.
 583   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_NUMPAD0,
 584                                       ui::EF_ALT_DOWN,
 585                                       ui::ET_KEY_PRESSED,
 586                                       keycode_num_pad_0_,
 587                                       Mod1Mask | Mod2Mask,
 588                                       KeyPress),
 589             GetRewrittenEventAsString(&rewriter,
 590                                       ui::VKEY_INSERT,
 591                                       ui::EF_ALT_DOWN,
 592                                       ui::ET_KEY_PRESSED,
 593                                       keycode_num_pad_insert_,
 594                                       Mod1Mask));
 595
 596   // XK_KP_Delete (= NumPad . without Num Lock), Alt modifier.
 597   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_DECIMAL,
 598                                       ui::EF_ALT_DOWN,
 599                                       ui::ET_KEY_PRESSED,
 600                                       keycode_num_pad_decimal_,
 601                                       Mod1Mask | Mod2Mask,
 602                                       KeyPress),
 603             GetRewrittenEventAsString(&rewriter,
 604                                       ui::VKEY_DELETE,
 605                                       ui::EF_ALT_DOWN,
 606                                       ui::ET_KEY_PRESSED,
 607                                       keycode_num_pad_delete_,
 608                                       Mod1Mask));
 609
 610   // XK_KP_End (= NumPad 1 without Num Lock), Alt modifier.
 611   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_NUMPAD1,
 612                                       ui::EF_ALT_DOWN,
 613                                       ui::ET_KEY_PRESSED,
 614                                       keycode_num_pad_1_,
 615                                       Mod1Mask | Mod2Mask,
 616                                       KeyPress),
 617             GetRewrittenEventAsString(&rewriter,
 618                                       ui::VKEY_END,
 619                                       ui::EF_ALT_DOWN,
 620                                       ui::ET_KEY_PRESSED,
 621                                       keycode_num_pad_end_,
 622                                       Mod1Mask));
 623
 624   // XK_KP_Down (= NumPad 2 without Num Lock), Alt modifier.
 625   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_NUMPAD2,
 626                                       ui::EF_ALT_DOWN,
 627                                       ui::ET_KEY_PRESSED,
 628                                       keycode_num_pad_2_,
 629                                       Mod1Mask | Mod2Mask,
 630                                       KeyPress),
 631             GetRewrittenEventAsString(&rewriter,
 632                                       ui::VKEY_DOWN,
 633                                       ui::EF_ALT_DOWN,
 634                                       ui::ET_KEY_PRESSED,
 635                                       keycode_num_pad_down_,
 636                                       Mod1Mask));
 637
 638   // XK_KP_Next (= NumPad 3 without Num Lock), Alt modifier.
 639   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_NUMPAD3,
 640                                       ui::EF_ALT_DOWN,
 641                                       ui::ET_KEY_PRESSED,
 642                                       keycode_num_pad_3_,
 643                                       Mod1Mask | Mod2Mask,
 644                                       KeyPress),
 645             GetRewrittenEventAsString(&rewriter,
 646                                       ui::VKEY_NEXT,
 647                                       ui::EF_ALT_DOWN,
 648                                       ui::ET_KEY_PRESSED,
 649                                       keycode_num_pad_next_,
 650                                       Mod1Mask));
 651
 652   // XK_KP_Left (= NumPad 4 without Num Lock), Alt modifier.
 653   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_NUMPAD4,
 654                                       ui::EF_ALT_DOWN,
 655                                       ui::ET_KEY_PRESSED,
 656                                       keycode_num_pad_4_,
 657                                       Mod1Mask | Mod2Mask,
 658                                       KeyPress),
 659             GetRewrittenEventAsString(&rewriter,
 660                                       ui::VKEY_LEFT,
 661                                       ui::EF_ALT_DOWN,
 662                                       ui::ET_KEY_PRESSED,
 663                                       keycode_num_pad_left_,
 664                                       Mod1Mask));
 665
 666   // XK_KP_Begin (= NumPad 5 without Num Lock), Alt modifier.
 667   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_NUMPAD5,
 668                                       ui::EF_ALT_DOWN,
 669                                       ui::ET_KEY_PRESSED,
 670                                       keycode_num_pad_5_,
 671                                       Mod1Mask | Mod2Mask,
 672                                       KeyPress),
 673             GetRewrittenEventAsString(&rewriter,
 674                                       ui::VKEY_CLEAR,
 675                                       ui::EF_ALT_DOWN,
 676                                       ui::ET_KEY_PRESSED,
 677                                       keycode_num_pad_begin_,
 678                                       Mod1Mask));
 679
 680   // XK_KP_Right (= NumPad 6 without Num Lock), Alt modifier.
 681   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_NUMPAD6,
 682                                       ui::EF_ALT_DOWN,
 683                                       ui::ET_KEY_PRESSED,
 684                                       keycode_num_pad_6_,
 685                                       Mod1Mask | Mod2Mask,
 686                                       KeyPress),
 687             GetRewrittenEventAsString(&rewriter,
 688                                       ui::VKEY_RIGHT,
 689                                       ui::EF_ALT_DOWN,
 690                                       ui::ET_KEY_PRESSED,
 691                                       keycode_num_pad_right_,
 692                                       Mod1Mask));
 693
 694   // XK_KP_Home (= NumPad 7 without Num Lock), Alt modifier.
 695   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_NUMPAD7,
 696                                       ui::EF_ALT_DOWN,
 697                                       ui::ET_KEY_PRESSED,
 698                                       keycode_num_pad_7_,
 699                                       Mod1Mask | Mod2Mask,
 700                                       KeyPress),
 701             GetRewrittenEventAsString(&rewriter,
 702                                       ui::VKEY_HOME,
 703                                       ui::EF_ALT_DOWN,
 704                                       ui::ET_KEY_PRESSED,
 705                                       keycode_num_pad_home_,
 706                                       Mod1Mask));
 707
 708   // XK_KP_Up (= NumPad 8 without Num Lock), Alt modifier.
 709   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_NUMPAD8,
 710                                       ui::EF_ALT_DOWN,
 711                                       ui::ET_KEY_PRESSED,
 712                                       keycode_num_pad_8_,
 713                                       Mod1Mask | Mod2Mask,
 714                                       KeyPress),
 715             GetRewrittenEventAsString(&rewriter,
 716                                       ui::VKEY_UP,
 717                                       ui::EF_ALT_DOWN,
 718                                       ui::ET_KEY_PRESSED,
 719                                       keycode_num_pad_up_,
 720                                       Mod1Mask));
 721
 722   // XK_KP_Prior (= NumPad 9 without Num Lock), Alt modifier.
 723   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_NUMPAD9,
 724                                       ui::EF_ALT_DOWN,
 725                                       ui::ET_KEY_PRESSED,
 726                                       keycode_num_pad_9_,
 727                                       Mod1Mask | Mod2Mask,
 728                                       KeyPress),
 729             GetRewrittenEventAsString(&rewriter,
 730                                       ui::VKEY_PRIOR,
 731                                       ui::EF_ALT_DOWN,
 732                                       ui::ET_KEY_PRESSED,
 733                                       keycode_num_pad_prior_,
 734                                       Mod1Mask));
 735
 736   // XK_KP_0 (= NumPad 0 with Num Lock), Num Lock modifier.
 737   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_NUMPAD0,
 738                                       0,
 739                                       ui::ET_KEY_PRESSED,
 740                                       keycode_num_pad_0_,
 741                                       Mod2Mask,
 742                                       KeyPress),
 743             GetRewrittenEventAsString(&rewriter,
 744                                       ui::VKEY_NUMPAD0,
 745                                       0,
 746                                       ui::ET_KEY_PRESSED,
 747                                       keycode_num_pad_0_,
 748                                       Mod2Mask));
 749
 750   // XK_KP_DECIMAL (= NumPad . with Num Lock), Num Lock modifier.
 751   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_DECIMAL,
 752                                       0,
 753                                       ui::ET_KEY_PRESSED,
 754                                       keycode_num_pad_decimal_,
 755                                       Mod2Mask,
 756                                       KeyPress),
 757             GetRewrittenEventAsString(&rewriter,
 758                                       ui::VKEY_DECIMAL,
 759                                       0,
 760                                       ui::ET_KEY_PRESSED,
 761                                       keycode_num_pad_decimal_,
 762                                       Mod2Mask));
 763
 764   // XK_KP_1 (= NumPad 1 with Num Lock), Num Lock modifier.
 765   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_NUMPAD1,
 766                                       0,
 767                                       ui::ET_KEY_PRESSED,
 768                                       keycode_num_pad_1_,
 769                                       Mod2Mask,
 770                                       KeyPress),
 771             GetRewrittenEventAsString(&rewriter,
 772                                       ui::VKEY_NUMPAD1,
 773                                       0,
 774                                       ui::ET_KEY_PRESSED,
 775                                       keycode_num_pad_1_,
 776                                       Mod2Mask));
 777
 778   // XK_KP_2 (= NumPad 2 with Num Lock), Num Lock modifier.
 779   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_NUMPAD2,
 780                                       0,
 781                                       ui::ET_KEY_PRESSED,
 782                                       keycode_num_pad_2_,
 783                                       Mod2Mask,
 784                                       KeyPress),
 785             GetRewrittenEventAsString(&rewriter,
 786                                       ui::VKEY_NUMPAD2,
 787                                       0,
 788                                       ui::ET_KEY_PRESSED,
 789                                       keycode_num_pad_2_,
 790                                       Mod2Mask));
 791
 792   // XK_KP_3 (= NumPad 3 with Num Lock), Num Lock modifier.
 793   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_NUMPAD3,
 794                                       0,
 795                                       ui::ET_KEY_PRESSED,
 796                                       keycode_num_pad_3_,
 797                                       Mod2Mask,
 798                                       KeyPress),
 799             GetRewrittenEventAsString(&rewriter,
 800                                       ui::VKEY_NUMPAD3,
 801                                       0,
 802                                       ui::ET_KEY_PRESSED,
 803                                       keycode_num_pad_3_,
 804                                       Mod2Mask));
 805
 806   // XK_KP_4 (= NumPad 4 with Num Lock), Num Lock modifier.
 807   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_NUMPAD4,
 808                                       0,
 809                                       ui::ET_KEY_PRESSED,
 810                                       keycode_num_pad_4_,
 811                                       Mod2Mask,
 812                                       KeyPress),
 813             GetRewrittenEventAsString(&rewriter,
 814                                       ui::VKEY_NUMPAD4,
 815                                       0,
 816                                       ui::ET_KEY_PRESSED,
 817                                       keycode_num_pad_4_,
 818                                       Mod2Mask));
 819
 820   // XK_KP_5 (= NumPad 5 with Num Lock), Num Lock modifier.
 821   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_NUMPAD5,
 822                                       0,
 823                                       ui::ET_KEY_PRESSED,
 824                                       keycode_num_pad_5_,
 825                                       Mod2Mask,
 826                                       KeyPress),
 827             GetRewrittenEventAsString(&rewriter,
 828                                       ui::VKEY_NUMPAD5,
 829                                       0,
 830                                       ui::ET_KEY_PRESSED,
 831                                       keycode_num_pad_5_,
 832                                       Mod2Mask));
 833
 834   // XK_KP_6 (= NumPad 6 with Num Lock), Num Lock modifier.
 835   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_NUMPAD6,
 836                                       0,
 837                                       ui::ET_KEY_PRESSED,
 838                                       keycode_num_pad_6_,
 839                                       Mod2Mask,
 840                                       KeyPress),
 841             GetRewrittenEventAsString(&rewriter,
 842                                       ui::VKEY_NUMPAD6,
 843                                       0,
 844                                       ui::ET_KEY_PRESSED,
 845                                       keycode_num_pad_6_,
 846                                       Mod2Mask));
 847
 848   // XK_KP_7 (= NumPad 7 with Num Lock), Num Lock modifier.
 849   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_NUMPAD7,
 850                                       0,
 851                                       ui::ET_KEY_PRESSED,
 852                                       keycode_num_pad_7_,
 853                                       Mod2Mask,
 854                                       KeyPress),
 855             GetRewrittenEventAsString(&rewriter,
 856                                       ui::VKEY_NUMPAD7,
 857                                       0,
 858                                       ui::ET_KEY_PRESSED,
 859                                       keycode_num_pad_7_,
 860                                       Mod2Mask));
 861
 862   // XK_KP_8 (= NumPad 8 with Num Lock), Num Lock modifier.
 863   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_NUMPAD8,
 864                                       0,
 865                                       ui::ET_KEY_PRESSED,
 866                                       keycode_num_pad_8_,
 867                                       Mod2Mask,
 868                                       KeyPress),
 869             GetRewrittenEventAsString(&rewriter,
 870                                       ui::VKEY_NUMPAD8,
 871                                       0,
 872                                       ui::ET_KEY_PRESSED,
 873                                       keycode_num_pad_8_,
 874                                       Mod2Mask));
 875
 876   // XK_KP_9 (= NumPad 9 with Num Lock), Num Lock modifier.
 877   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_NUMPAD9,
 878                                       0,
 879                                       ui::ET_KEY_PRESSED,
 880                                       keycode_num_pad_9_,
 881                                       Mod2Mask,
 882                                       KeyPress),
 883             GetRewrittenEventAsString(&rewriter,
 884                                       ui::VKEY_NUMPAD9,
 885                                       0,
 886                                       ui::ET_KEY_PRESSED,
 887                                       keycode_num_pad_9_,
 888                                       Mod2Mask));
 889 }
 890
 891 TEST_F(EventRewriterTest, TestRewriteNumPadKeys) {
 892   TestRewriteNumPadKeys();
 893 }
 894
 895 TEST_F(EventRewriterTest, TestRewriteNumPadKeysWithDiamondKeyFlag) {
 896   // Make sure the num lock works correctly even when Diamond key exists.
 897   const CommandLine original_cl(*CommandLine::ForCurrentProcess());
 898   CommandLine::ForCurrentProcess()->AppendSwitchASCII(
 899       chromeos::switches::kHasChromeOSDiamondKey, "");
 900
 901   TestRewriteNumPadKeys();
 902   *CommandLine::ForCurrentProcess() = original_cl;
 903 }
 904
 905 // Tests if the rewriter can handle a Command + Num Pad event.
 906 void EventRewriterTest::TestRewriteNumPadKeysOnAppleKeyboard() {
 907   TestingPrefServiceSyncable prefs;
 908   EventRewriter rewriter;
 909   rewriter.DeviceAddedForTesting(0, "Apple Keyboard");
 910   rewriter.set_last_device_id_for_testing(0);
 911   rewriter.set_pref_service_for_testing(&prefs);
 912
 913   // XK_KP_End (= NumPad 1 without Num Lock), Win modifier.
 914   // The result should be "Num Pad 1 with Control + Num Lock modifiers".
 915   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_NUMPAD1,
 916                                       ui::EF_CONTROL_DOWN,
 917                                       ui::ET_KEY_PRESSED,
 918                                       keycode_num_pad_1_,
 919                                       ControlMask | Mod2Mask,
 920                                       KeyPress),
 921             GetRewrittenEventAsString(&rewriter,
 922                                       ui::VKEY_END,
 923                                       0,
 924                                       ui::ET_KEY_PRESSED,
 925                                       keycode_num_pad_end_,
 926                                       Mod4Mask));
 927
 928   // XK_KP_1 (= NumPad 1 without Num Lock), Win modifier.
 929   // The result should also be "Num Pad 1 with Control + Num Lock modifiers".
 930   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_NUMPAD1,
 931                                       ui::EF_CONTROL_DOWN,
 932                                       ui::ET_KEY_PRESSED,
 933                                       keycode_num_pad_1_,
 934                                       ControlMask | Mod2Mask,
 935                                       KeyPress),
 936             GetRewrittenEventAsString(&rewriter,
 937                                       ui::VKEY_NUMPAD1,
 938                                       0,
 939                                       ui::ET_KEY_PRESSED,
 940                                       keycode_num_pad_end_,
 941                                       Mod4Mask));
 942 }
 943
 944 TEST_F(EventRewriterTest, TestRewriteNumPadKeysOnAppleKeyboard) {
 945   TestRewriteNumPadKeysOnAppleKeyboard();
 946 }
 947
 948 TEST_F(EventRewriterTest,
 949        TestRewriteNumPadKeysOnAppleKeyboardWithDiamondKeyFlag) {
 950   // Makes sure the num lock works correctly even when Diamond key exists.
 951   const CommandLine original_cl(*CommandLine::ForCurrentProcess());
 952   CommandLine::ForCurrentProcess()->AppendSwitchASCII(
 953       chromeos::switches::kHasChromeOSDiamondKey, "");
 954
 955   TestRewriteNumPadKeysOnAppleKeyboard();
 956   *CommandLine::ForCurrentProcess() = original_cl;
 957 }
 958
 959 TEST_F(EventRewriterTest, TestRewriteModifiersNoRemap) {
 960   TestingPrefServiceSyncable prefs;
 961   EventRewriter rewriter;
 962   rewriter.set_pref_service_for_testing(&prefs);
 963
 964   // Press Search. Confirm the event is not rewritten.
 965   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_LWIN,
 966                                       0,
 967                                       ui::ET_KEY_PRESSED,
 968                                       keycode_super_l_,
 969                                       0U,
 970                                       KeyPress),
 971             GetRewrittenEventAsString(&rewriter,
 972                                       ui::VKEY_LWIN,
 973                                       0,
 974                                       ui::ET_KEY_PRESSED,
 975                                       keycode_super_l_,
 976                                       0U));
 977
 978   // Press left Control. Confirm the event is not rewritten.
 979   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CONTROL,
 980                                       ui::EF_CONTROL_DOWN,
 981                                       ui::ET_KEY_PRESSED,
 982                                       keycode_control_l_,
 983                                       0U,
 984                                       KeyPress),
 985             GetRewrittenEventAsString(&rewriter,
 986                                       ui::VKEY_CONTROL,
 987                                       0,
 988                                       ui::ET_KEY_PRESSED,
 989                                       keycode_control_l_,
 990                                       0U));
 991
 992   // Press right Control. Confirm the event is not rewritten.
 993   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CONTROL,
 994                                       ui::EF_CONTROL_DOWN,
 995                                       ui::ET_KEY_PRESSED,
 996                                       keycode_control_r_,
 997                                       0U,
 998                                       KeyPress),
 999             GetRewrittenEventAsString(&rewriter,
1000                                       ui::VKEY_CONTROL,
1001                                       0,
1002                                       ui::ET_KEY_PRESSED,
1003                                       keycode_control_r_,
1004                                       0U));
1005
1006   // Press left Alt. Confirm the event is not rewritten.
1007   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_MENU,
1008                                       ui::EF_ALT_DOWN,
1009                                       ui::ET_KEY_PRESSED,
1010                                       keycode_alt_l_,
1011                                       0,
1012                                       KeyPress),
1013             GetRewrittenEventAsString(&rewriter,
1014                                       ui::VKEY_MENU,
1015                                       0,
1016                                       ui::ET_KEY_PRESSED,
1017                                       keycode_alt_l_,
1018                                       0U));
1019
1020   // Press right Alt. Confirm the event is not rewritten.
1021   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_MENU,
1022                                       ui::EF_ALT_DOWN,
1023                                       ui::ET_KEY_PRESSED,
1024                                       keycode_alt_r_,
1025                                       0,
1026                                       KeyPress),
1027             GetRewrittenEventAsString(&rewriter,
1028                                       ui::VKEY_MENU,
1029                                       0,
1030                                       ui::ET_KEY_PRESSED,
1031                                       keycode_alt_r_,
1032                                       0U));
1033
1034   // Test KeyRelease event, just in case.
1035   // Release Search. Confirm the release event is not rewritten.
1036   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_LWIN,
1037                                       0,
1038                                       ui::ET_KEY_RELEASED,
1039                                       keycode_super_l_,
1040                                       Mod4Mask,
1041                                       KeyRelease),
1042             GetRewrittenEventAsString(&rewriter,
1043                                       ui::VKEY_LWIN,
1044                                       0,
1045                                       ui::ET_KEY_RELEASED,
1046                                       keycode_super_l_,
1047                                       Mod4Mask));
1048 }
1049
1050 TEST_F(EventRewriterTest, TestRewriteModifiersNoRemapMultipleKeys) {
1051   TestingPrefServiceSyncable prefs;
1052   EventRewriter rewriter;
1053   rewriter.set_pref_service_for_testing(&prefs);
1054
1055   // Press left Alt with Shift. Confirm the event is not rewritten.
1056   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_MENU,
1057                                       ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN,
1058                                       ui::ET_KEY_PRESSED,
1059                                       keycode_meta_l_,
1060                                       ShiftMask,
1061                                       KeyPress),
1062             GetRewrittenEventAsString(&rewriter,
1063                                       ui::VKEY_MENU,
1064                                       ui::EF_SHIFT_DOWN,
1065                                       ui::ET_KEY_PRESSED,
1066                                       keycode_meta_l_,
1067                                       ShiftMask));
1068
1069   // Press right Alt with Shift. Confirm the event is not rewritten.
1070   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_MENU,
1071                                       ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN,
1072                                       ui::ET_KEY_PRESSED,
1073                                       keycode_meta_r_,
1074                                       ShiftMask,
1075                                       KeyPress),
1076             GetRewrittenEventAsString(&rewriter,
1077                                       ui::VKEY_MENU,
1078                                       ui::EF_SHIFT_DOWN,
1079                                       ui::ET_KEY_PRESSED,
1080                                       keycode_meta_r_,
1081                                       ShiftMask));
1082
1083   // Press Search with Caps Lock mask. Confirm the event is not rewritten.
1084   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_LWIN,
1085                                       ui::EF_CAPS_LOCK_DOWN,
1086                                       ui::ET_KEY_PRESSED,
1087                                       keycode_super_l_,
1088                                       LockMask,
1089                                       KeyPress),
1090             GetRewrittenEventAsString(&rewriter,
1091                                       ui::VKEY_LWIN,
1092                                       ui::EF_CAPS_LOCK_DOWN,
1093                                       ui::ET_KEY_PRESSED,
1094                                       keycode_super_l_,
1095                                       LockMask));
1096
1097   // Release Search with Caps Lock mask. Confirm the event is not rewritten.
1098   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_LWIN,
1099                                       ui::EF_CAPS_LOCK_DOWN,
1100                                       ui::ET_KEY_RELEASED,
1101                                       keycode_super_l_,
1102                                       LockMask | Mod4Mask,
1103                                       KeyRelease),
1104             GetRewrittenEventAsString(&rewriter,
1105                                       ui::VKEY_LWIN,
1106                                       ui::EF_CAPS_LOCK_DOWN,
1107                                       ui::ET_KEY_RELEASED,
1108                                       keycode_super_l_,
1109                                       LockMask | Mod4Mask));
1110
1111   // Press Shift+Ctrl+Alt+Search+A. Confirm the event is not rewritten.
1112   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_B,
1113                                       ui::EF_SHIFT_DOWN |
1114                                       ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN,
1115                                       ui::ET_KEY_PRESSED,
1116                                       keycode_b_,
1117                                       ShiftMask | ControlMask | Mod1Mask |
1118                                       Mod4Mask,
1119                                       KeyPress),
1120             GetRewrittenEventAsString(&rewriter,
1121                                       ui::VKEY_B,
1122                                       ui::EF_SHIFT_DOWN |
1123                                       ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN,
1124                                       ui::ET_KEY_PRESSED,
1125                                       keycode_b_,
1126                                       ShiftMask | ControlMask | Mod1Mask |
1127                                       Mod4Mask));
1128 }
1129
1130 TEST_F(EventRewriterTest, TestRewriteModifiersDisableSome) {
1131   // Disable Search and Control keys.
1132   TestingPrefServiceSyncable prefs;
1133   chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
1134   IntegerPrefMember search;
1135   search.Init(prefs::kLanguageRemapSearchKeyTo, &prefs);
1136   search.SetValue(chromeos::input_method::kVoidKey);
1137   IntegerPrefMember control;
1138   control.Init(prefs::kLanguageRemapControlKeyTo, &prefs);
1139   control.SetValue(chromeos::input_method::kVoidKey);
1140
1141   EventRewriter rewriter;
1142   rewriter.set_pref_service_for_testing(&prefs);
1143
1144   // Press left Alt with Shift. This key press shouldn't be affected by the
1145   // pref. Confirm the event is not rewritten.
1146   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_MENU,
1147                                       ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN,
1148                                       ui::ET_KEY_PRESSED,
1149                                       keycode_meta_l_,
1150                                       ShiftMask,
1151                                       KeyPress),
1152             GetRewrittenEventAsString(&rewriter,
1153                                       ui::VKEY_MENU,
1154                                       ui::EF_SHIFT_DOWN,
1155                                       ui::ET_KEY_PRESSED,
1156                                       keycode_meta_l_,
1157                                       ShiftMask));
1158
1159   // Press Search. Confirm the event is now VKEY_UNKNOWN + XK_VoidSymbol.
1160   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_UNKNOWN,
1161                                       0,
1162                                       ui::ET_KEY_PRESSED,
1163                                       keycode_void_symbol_,
1164                                       0U,
1165                                       KeyPress),
1166             GetRewrittenEventAsString(&rewriter,
1167                                       ui::VKEY_LWIN,
1168                                       0,
1169                                       ui::ET_KEY_PRESSED,
1170                                       keycode_super_l_,
1171                                       0U));
1172
1173   // Press Control. Confirm the event is now VKEY_UNKNOWN + XK_VoidSymbol.
1174   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_UNKNOWN,
1175                                       0,
1176                                       ui::ET_KEY_PRESSED,
1177                                       keycode_void_symbol_,
1178                                       0U,
1179                                       KeyPress),
1180             GetRewrittenEventAsString(&rewriter,
1181                                       ui::VKEY_CONTROL,
1182                                       0,
1183                                       ui::ET_KEY_PRESSED,
1184                                       keycode_control_l_,
1185                                       0U));
1186
1187   // Press Control+Search. Confirm the event is now VKEY_UNKNOWN +
1188   // XK_VoidSymbol without any modifiers.
1189   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_UNKNOWN,
1190                                       0,
1191                                       ui::ET_KEY_PRESSED,
1192                                       keycode_void_symbol_,
1193                                       0U,
1194                                       KeyPress),
1195             GetRewrittenEventAsString(&rewriter,
1196                                       ui::VKEY_LWIN,
1197                                       ui::EF_CONTROL_DOWN,
1198                                       ui::ET_KEY_PRESSED,
1199                                       keycode_super_l_,
1200                                       ControlMask));
1201
1202   // Press Control+Search+a. Confirm the event is now VKEY_A without any
1203   // modifiers.
1204   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_A,
1205                                       0,
1206                                       ui::ET_KEY_PRESSED,
1207                                       keycode_a_,
1208                                       0U,
1209                                       KeyPress),
1210             GetRewrittenEventAsString(&rewriter,
1211                                       ui::VKEY_A,
1212                                       ui::EF_CONTROL_DOWN,
1213                                       ui::ET_KEY_PRESSED,
1214                                       keycode_a_,
1215                                       ControlMask | Mod4Mask));
1216
1217   // Press Control+Search+Alt+a. Confirm the event is now VKEY_A only with
1218   // the Alt modifier.
1219   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_A,
1220                                       ui::EF_ALT_DOWN,
1221                                       ui::ET_KEY_PRESSED,
1222                                       keycode_a_,
1223                                       Mod1Mask,
1224                                       KeyPress),
1225             GetRewrittenEventAsString(&rewriter,
1226                                       ui::VKEY_A,
1227                                       ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN,
1228                                       ui::ET_KEY_PRESSED,
1229                                       keycode_a_,
1230                                       ControlMask | Mod1Mask | Mod4Mask));
1231
1232   // Remap Alt to Control.
1233   IntegerPrefMember alt;
1234   alt.Init(prefs::kLanguageRemapAltKeyTo, &prefs);
1235   alt.SetValue(chromeos::input_method::kControlKey);
1236
1237   // Press left Alt. Confirm the event is now VKEY_CONTROL + XK_Control_L
1238   // even though the Control key itself is disabled.
1239   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CONTROL,
1240                                       ui::EF_CONTROL_DOWN,
1241                                       ui::ET_KEY_PRESSED,
1242                                       keycode_control_l_,
1243                                       0U,
1244                                       KeyPress),
1245             GetRewrittenEventAsString(&rewriter,
1246                                       ui::VKEY_MENU,
1247                                       0,
1248                                       ui::ET_KEY_PRESSED,
1249                                       keycode_alt_l_,
1250                                       0U));
1251
1252   // Press Alt+a. Confirm the event is now Control+a even though the Control
1253   // key itself is disabled.
1254   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_A,
1255                                       ui::EF_CONTROL_DOWN,
1256                                       ui::ET_KEY_PRESSED,
1257                                       keycode_a_,
1258                                       ControlMask,
1259                                       KeyPress),
1260             GetRewrittenEventAsString(&rewriter,
1261                                       ui::VKEY_A,
1262                                       ui::EF_ALT_DOWN,
1263                                       ui::ET_KEY_PRESSED,
1264                                       keycode_a_,
1265                                       Mod1Mask));
1266 }
1267
1268 TEST_F(EventRewriterTest, TestRewriteModifiersRemapToControl) {
1269   // Remap Search to Control.
1270   TestingPrefServiceSyncable prefs;
1271   chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
1272   IntegerPrefMember search;
1273   search.Init(prefs::kLanguageRemapSearchKeyTo, &prefs);
1274   search.SetValue(chromeos::input_method::kControlKey);
1275
1276   EventRewriter rewriter;
1277   rewriter.set_pref_service_for_testing(&prefs);
1278
1279   // Press Search. Confirm the event is now VKEY_CONTROL + XK_Control_L.
1280   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CONTROL,
1281                                       ui::EF_CONTROL_DOWN,
1282                                       ui::ET_KEY_PRESSED,
1283                                       keycode_control_l_,
1284                                       0U,
1285                                       KeyPress),
1286             GetRewrittenEventAsString(&rewriter,
1287                                       ui::VKEY_LWIN,
1288                                       0,
1289                                       ui::ET_KEY_PRESSED,
1290                                       keycode_super_l_,
1291                                       0U));
1292
1293   // Remap Alt to Control too.
1294   IntegerPrefMember alt;
1295   alt.Init(prefs::kLanguageRemapAltKeyTo, &prefs);
1296   alt.SetValue(chromeos::input_method::kControlKey);
1297
1298   // Press left Alt. Confirm the event is now VKEY_CONTROL + XK_Control_L.
1299   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CONTROL,
1300                                       ui::EF_CONTROL_DOWN,
1301                                       ui::ET_KEY_PRESSED,
1302                                       keycode_control_l_,
1303                                       0U,
1304                                       KeyPress),
1305             GetRewrittenEventAsString(&rewriter,
1306                                       ui::VKEY_MENU,
1307                                       0,
1308                                       ui::ET_KEY_PRESSED,
1309                                       keycode_alt_l_,
1310                                       0U));
1311
1312   // Press right Alt. Confirm the event is now VKEY_CONTROL + XK_Control_R.
1313   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CONTROL,
1314                                       ui::EF_CONTROL_DOWN,
1315                                       ui::ET_KEY_PRESSED,
1316                                       keycode_control_r_,
1317                                       0U,
1318                                       KeyPress),
1319             GetRewrittenEventAsString(&rewriter,
1320                                       ui::VKEY_MENU,
1321                                       0,
1322                                       ui::ET_KEY_PRESSED,
1323                                       keycode_alt_r_,
1324                                       0U));
1325
1326   // Press Alt+Search. Confirm the event is now VKEY_CONTROL + XK_Control_L.
1327   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CONTROL,
1328                                       ui::EF_CONTROL_DOWN,
1329                                       ui::ET_KEY_PRESSED,
1330                                       keycode_control_l_,
1331                                       ControlMask,
1332                                       KeyPress),
1333             GetRewrittenEventAsString(&rewriter,
1334                                       ui::VKEY_LWIN,
1335                                       ui::EF_ALT_DOWN,
1336                                       ui::ET_KEY_PRESSED,
1337                                       keycode_super_l_,
1338                                       Mod1Mask));
1339
1340   // Press Control+Alt+Search. Confirm the event is now VKEY_CONTROL +
1341   // XK_Control_L.
1342   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CONTROL,
1343                                       ui::EF_CONTROL_DOWN,
1344                                       ui::ET_KEY_PRESSED,
1345                                       keycode_control_l_,
1346                                       ControlMask,
1347                                       KeyPress),
1348             GetRewrittenEventAsString(&rewriter,
1349                                       ui::VKEY_LWIN,
1350                                       ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN,
1351                                       ui::ET_KEY_PRESSED,
1352                                       keycode_super_l_,
1353                                       ControlMask | Mod1Mask));
1354
1355   // Press Shift+Control+Alt+Search. Confirm the event is now Control with
1356   // Shift and Control modifiers.
1357   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CONTROL,
1358                                       ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN,
1359                                       ui::ET_KEY_PRESSED,
1360                                       keycode_control_l_,
1361                                       ShiftMask | ControlMask,
1362                                       KeyPress),
1363             GetRewrittenEventAsString(&rewriter,
1364                                       ui::VKEY_LWIN,
1365                                       ui::EF_SHIFT_DOWN |
1366                                       ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN,
1367                                       ui::ET_KEY_PRESSED,
1368                                       keycode_super_l_,
1369                                       ShiftMask | ControlMask | Mod1Mask));
1370
1371   // Press Shift+Control+Alt+Search+B. Confirm the event is now B with Shift
1372   // and Control modifiers.
1373   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_B,
1374                                       ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN,
1375                                       ui::ET_KEY_PRESSED,
1376                                       keycode_b_,
1377                                       ShiftMask | ControlMask,
1378                                       KeyPress),
1379             GetRewrittenEventAsString(&rewriter,
1380                                       ui::VKEY_B,
1381                                       ui::EF_SHIFT_DOWN |
1382                                       ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN,
1383                                       ui::ET_KEY_PRESSED,
1384                                       keycode_b_,
1385                                       ShiftMask | ControlMask | Mod1Mask));
1386 }
1387
1388 TEST_F(EventRewriterTest, TestRewriteModifiersRemapToEscape) {
1389   // Remap Search to ESC.
1390   TestingPrefServiceSyncable prefs;
1391   chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
1392   IntegerPrefMember search;
1393   search.Init(prefs::kLanguageRemapSearchKeyTo, &prefs);
1394   search.SetValue(chromeos::input_method::kEscapeKey);
1395
1396   EventRewriter rewriter;
1397   rewriter.set_pref_service_for_testing(&prefs);
1398
1399   // Press Search. Confirm the event is now VKEY_ESCAPE.
1400   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_ESCAPE,
1401                                       ui::EF_NONE,
1402                                       ui::ET_KEY_PRESSED,
1403                                       keycode_escape_,
1404                                       0U,
1405                                       KeyPress),
1406             GetRewrittenEventAsString(&rewriter,
1407                                       ui::VKEY_LWIN,
1408                                       0,
1409                                       ui::ET_KEY_PRESSED,
1410                                       keycode_super_l_,
1411                                       0U));
1412 }
1413
1414 TEST_F(EventRewriterTest, TestRewriteModifiersRemapMany) {
1415   // Remap Search to Alt.
1416   TestingPrefServiceSyncable prefs;
1417   chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
1418   IntegerPrefMember search;
1419   search.Init(prefs::kLanguageRemapSearchKeyTo, &prefs);
1420   search.SetValue(chromeos::input_method::kAltKey);
1421
1422   EventRewriter rewriter;
1423   rewriter.set_pref_service_for_testing(&prefs);
1424
1425   // Press Search. Confirm the event is now VKEY_MENU + XK_Alt_L.
1426   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_MENU,
1427                                       ui::EF_ALT_DOWN,
1428                                       ui::ET_KEY_PRESSED,
1429                                       keycode_alt_l_,
1430                                       0U,
1431                                       KeyPress),
1432             GetRewrittenEventAsString(&rewriter,
1433                                       ui::VKEY_LWIN,
1434                                       0,
1435                                       ui::ET_KEY_PRESSED,
1436                                       keycode_super_l_,
1437                                       0U));
1438
1439   // Remap Alt to Control.
1440   IntegerPrefMember alt;
1441   alt.Init(prefs::kLanguageRemapAltKeyTo, &prefs);
1442   alt.SetValue(chromeos::input_method::kControlKey);
1443
1444   // Press left Alt. Confirm the event is now VKEY_CONTROL + XK_Control_L.
1445   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CONTROL,
1446                                       ui::EF_CONTROL_DOWN,
1447                                       ui::ET_KEY_PRESSED,
1448                                       keycode_control_l_,
1449                                       0U,
1450                                       KeyPress),
1451             GetRewrittenEventAsString(&rewriter,
1452                                       ui::VKEY_MENU,
1453                                       0,
1454                                       ui::ET_KEY_PRESSED,
1455                                       keycode_alt_l_,
1456                                       0U));
1457
1458   // Remap Control to Search.
1459   IntegerPrefMember control;
1460   control.Init(prefs::kLanguageRemapControlKeyTo, &prefs);
1461   control.SetValue(chromeos::input_method::kSearchKey);
1462
1463   // Press left Control. Confirm the event is now VKEY_LWIN.
1464   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_LWIN,
1465                                       0,
1466                                       ui::ET_KEY_PRESSED,
1467                                       keycode_super_l_,
1468                                       0U,
1469                                       KeyPress),
1470             GetRewrittenEventAsString(&rewriter,
1471                                       ui::VKEY_CONTROL,
1472                                       0,
1473                                       ui::ET_KEY_PRESSED,
1474                                       keycode_control_l_,
1475                                       0U));
1476
1477   // Then, press all of the three, Control+Alt+Search.
1478   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_MENU,
1479                                       ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN,
1480                                       ui::ET_KEY_PRESSED,
1481                                       keycode_alt_l_,
1482                                       ControlMask | Mod4Mask,
1483                                       KeyPress),
1484             GetRewrittenEventAsString(&rewriter,
1485                                       ui::VKEY_LWIN,
1486                                       ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN,
1487                                       ui::ET_KEY_PRESSED,
1488                                       keycode_super_l_,
1489                                       ControlMask | Mod1Mask));
1490
1491   // Press Shift+Control+Alt+Search.
1492   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_MENU,
1493                                       (ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN |
1494                                        ui::EF_ALT_DOWN),
1495                                       ui::ET_KEY_PRESSED,
1496                                       keycode_alt_l_,
1497                                       ShiftMask | ControlMask | Mod4Mask,
1498                                       KeyPress),
1499             GetRewrittenEventAsString(&rewriter,
1500                                       ui::VKEY_LWIN,
1501                                       ui::EF_SHIFT_DOWN |
1502                                       ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN,
1503                                       ui::ET_KEY_PRESSED,
1504                                       keycode_super_l_,
1505                                       ShiftMask | ControlMask | Mod1Mask));
1506
1507   // Press Shift+Control+Alt+Search+B
1508   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_B,
1509                                       ui::EF_SHIFT_DOWN |
1510                                       ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN,
1511                                       ui::ET_KEY_PRESSED,
1512                                       keycode_b_,
1513                                       ShiftMask | ControlMask | Mod1Mask |
1514                                       Mod4Mask,
1515                                       KeyPress),
1516             GetRewrittenEventAsString(&rewriter,
1517                                       ui::VKEY_B,
1518                                       ui::EF_SHIFT_DOWN |
1519                                       ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN,
1520                                       ui::ET_KEY_PRESSED,
1521                                       keycode_b_,
1522                                       ShiftMask | ControlMask | Mod1Mask |
1523                                       Mod4Mask));
1524 }
1525
1526 TEST_F(EventRewriterTest, TestRewriteModifiersRemapToCapsLock) {
1527   // Remap Search to Caps Lock.
1528   TestingPrefServiceSyncable prefs;
1529   chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
1530   IntegerPrefMember search;
1531   search.Init(prefs::kLanguageRemapSearchKeyTo, &prefs);
1532   search.SetValue(chromeos::input_method::kCapsLockKey);
1533
1534   chromeos::input_method::MockXKeyboard xkeyboard;
1535   EventRewriter rewriter;
1536   rewriter.set_pref_service_for_testing(&prefs);
1537   rewriter.set_xkeyboard_for_testing(&xkeyboard);
1538   EXPECT_FALSE(xkeyboard.caps_lock_is_enabled_);
1539
1540   // Press Search.
1541   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CAPITAL,
1542                                       ui::EF_CAPS_LOCK_DOWN,
1543                                       ui::ET_KEY_PRESSED,
1544                                       keycode_caps_lock_,
1545                                       0U,
1546                                       KeyPress),
1547             GetRewrittenEventAsString(&rewriter,
1548                                       ui::VKEY_LWIN,
1549                                       0,
1550                                       ui::ET_KEY_PRESSED,
1551                                       keycode_super_l_,
1552                                       0U));
1553   // Confirm that the Caps Lock status is changed.
1554   EXPECT_TRUE(xkeyboard.caps_lock_is_enabled_);
1555
1556   // Release Search.
1557   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CAPITAL,
1558                                       ui::EF_NONE,
1559                                       ui::ET_KEY_RELEASED,
1560                                       keycode_caps_lock_,
1561                                       LockMask,
1562                                       KeyRelease),
1563             GetRewrittenEventAsString(&rewriter,
1564                                       ui::VKEY_LWIN,
1565                                       ui::EF_CAPS_LOCK_DOWN,
1566                                       ui::ET_KEY_RELEASED,
1567                                       keycode_super_l_,
1568                                       Mod4Mask | LockMask));
1569   // Confirm that the Caps Lock status is not changed.
1570   EXPECT_TRUE(xkeyboard.caps_lock_is_enabled_);
1571
1572   // Press Search.
1573   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CAPITAL,
1574                                       ui::EF_CAPS_LOCK_DOWN,
1575                                       ui::ET_KEY_PRESSED,
1576                                       keycode_caps_lock_,
1577                                       LockMask,
1578                                       KeyPress),
1579             GetRewrittenEventAsString(&rewriter,
1580                                       ui::VKEY_LWIN,
1581                                       ui::EF_CAPS_LOCK_DOWN,
1582                                       ui::ET_KEY_PRESSED,
1583                                       keycode_super_l_,
1584                                       LockMask));
1585   // Confirm that the Caps Lock status is changed.
1586   EXPECT_FALSE(xkeyboard.caps_lock_is_enabled_);
1587
1588   // Release Search.
1589   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CAPITAL,
1590                                       ui::EF_NONE,
1591                                       ui::ET_KEY_RELEASED,
1592                                       keycode_caps_lock_,
1593                                       LockMask,
1594                                       KeyRelease),
1595             GetRewrittenEventAsString(&rewriter,
1596                                       ui::VKEY_LWIN,
1597                                       ui::EF_CAPS_LOCK_DOWN,
1598                                       ui::ET_KEY_RELEASED,
1599                                       keycode_super_l_,
1600                                       Mod4Mask | LockMask));
1601   // Confirm that the Caps Lock status is not changed.
1602   EXPECT_FALSE(xkeyboard.caps_lock_is_enabled_);
1603
1604   // Press Caps Lock (on an external keyboard).
1605   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CAPITAL,
1606                                       ui::EF_CAPS_LOCK_DOWN,
1607                                       ui::ET_KEY_PRESSED,
1608                                       keycode_caps_lock_,
1609                                       0U,
1610                                       KeyPress),
1611             GetRewrittenEventAsString(&rewriter,
1612                                       ui::VKEY_CAPITAL,
1613                                       ui::EF_NONE,
1614                                       ui::ET_KEY_PRESSED,
1615                                       keycode_caps_lock_,
1616                                       0U));
1617
1618   // Confirm that calling RewriteForTesting() does not change the state of
1619   // |xkeyboard|. In this case, X Window system itself should change the
1620   // Caps Lock state, not ash::EventRewriter.
1621   EXPECT_FALSE(xkeyboard.caps_lock_is_enabled_);
1622
1623   // Release Caps Lock (on an external keyboard).
1624   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CAPITAL,
1625                                       ui::EF_NONE,
1626                                       ui::ET_KEY_RELEASED,
1627                                       keycode_caps_lock_,
1628                                       LockMask,
1629                                       KeyRelease),
1630             GetRewrittenEventAsString(&rewriter,
1631                                       ui::VKEY_CAPITAL,
1632                                       ui::EF_CAPS_LOCK_DOWN,
1633                                       ui::ET_KEY_RELEASED,
1634                                       keycode_caps_lock_,
1635                                       LockMask));
1636   EXPECT_FALSE(xkeyboard.caps_lock_is_enabled_);
1637 }
1638
1639 TEST_F(EventRewriterTest, DISABLED_TestRewriteCapsLock) {
1640   // It seems that the X server running on build servers is too old and does not
1641   // support F16 (i.e. 'XKeysymToKeycode(display_, XF86XK_Launch7)' call).
1642   // TODO(yusukes): Reenable the test once build servers are upgraded.
1643
1644   TestingPrefServiceSyncable prefs;
1645   chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
1646
1647   chromeos::input_method::MockXKeyboard xkeyboard;
1648   EventRewriter rewriter;
1649   rewriter.set_pref_service_for_testing(&prefs);
1650   rewriter.set_xkeyboard_for_testing(&xkeyboard);
1651   EXPECT_FALSE(xkeyboard.caps_lock_is_enabled_);
1652
1653   // On Chrome OS, CapsLock is mapped to F16 with Mod3Mask.
1654   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CAPITAL,
1655                                       ui::EF_CAPS_LOCK_DOWN,
1656                                       ui::ET_KEY_PRESSED,
1657                                       keycode_caps_lock_,
1658                                       0U,
1659                                       KeyPress),
1660             GetRewrittenEventAsString(&rewriter,
1661                                       ui::VKEY_F16,
1662                                       0,
1663                                       ui::ET_KEY_PRESSED,
1664                                       keycode_launch7_,
1665                                       0U));
1666   EXPECT_TRUE(xkeyboard.caps_lock_is_enabled_);
1667 }
1668
1669 TEST_F(EventRewriterTest, DISABLED_TestRewriteDiamondKey) {
1670   // TODO(yusukes): Reenable the test once build servers are upgraded.
1671
1672   TestingPrefServiceSyncable prefs;
1673   chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
1674
1675   chromeos::input_method::MockXKeyboard xkeyboard;
1676   EventRewriter rewriter;
1677   rewriter.set_pref_service_for_testing(&prefs);
1678   rewriter.set_xkeyboard_for_testing(&xkeyboard);
1679
1680   // F15 should work as Ctrl when --has-chromeos-diamond-key is not specified.
1681   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CONTROL,
1682                                       ui::EF_CONTROL_DOWN,
1683                                       ui::ET_KEY_PRESSED,
1684                                       keycode_control_l_,
1685                                       0U,
1686                                       KeyPress),
1687             GetRewrittenEventAsString(&rewriter,
1688                                       ui::VKEY_F15,
1689                                       0,
1690                                       ui::ET_KEY_PRESSED,
1691                                       keycode_launch6_,
1692                                       0U));
1693
1694   // However, Mod2Mask should not be rewritten to CtrlMask when
1695   // --has-chromeos-diamond-key is not specified.
1696   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_A,
1697                                       0,
1698                                       ui::ET_KEY_PRESSED,
1699                                       keycode_a_,
1700                                       Mod2Mask,
1701                                       KeyPress),
1702             GetRewrittenEventAsString(&rewriter,
1703                                       ui::VKEY_A,
1704                                       0,
1705                                       ui::ET_KEY_PRESSED,
1706                                       keycode_a_,
1707                                       Mod2Mask));
1708 }
1709
1710 TEST_F(EventRewriterTest, DISABLED_TestRewriteDiamondKeyWithFlag) {
1711   // TODO(yusukes): Reenable the test once build servers are upgraded.
1712
1713   const CommandLine original_cl(*CommandLine::ForCurrentProcess());
1714   CommandLine::ForCurrentProcess()->AppendSwitchASCII(
1715       chromeos::switches::kHasChromeOSDiamondKey, "");
1716
1717   TestingPrefServiceSyncable prefs;
1718   chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
1719
1720   chromeos::input_method::MockXKeyboard xkeyboard;
1721   EventRewriter rewriter;
1722   rewriter.set_pref_service_for_testing(&prefs);
1723   rewriter.set_xkeyboard_for_testing(&xkeyboard);
1724
1725   // By default, F15 should work as Control.
1726   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CONTROL,
1727                                       ui::EF_CONTROL_DOWN,
1728                                       ui::ET_KEY_PRESSED,
1729                                       keycode_control_l_,
1730                                       0U,
1731                                       KeyPress),
1732             GetRewrittenEventAsString(&rewriter,
1733                                       ui::VKEY_F15,
1734                                       0,
1735                                       ui::ET_KEY_PRESSED,
1736                                       keycode_launch6_,
1737                                       0U));
1738
1739   IntegerPrefMember diamond;
1740   diamond.Init(prefs::kLanguageRemapDiamondKeyTo, &prefs);
1741   diamond.SetValue(chromeos::input_method::kVoidKey);
1742
1743   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_UNKNOWN,
1744                                       0,
1745                                       ui::ET_KEY_PRESSED,
1746                                       keycode_void_symbol_,
1747                                       0U,
1748                                       KeyPress),
1749             GetRewrittenEventAsString(&rewriter,
1750                                       ui::VKEY_F15,
1751                                       0,
1752                                       ui::ET_KEY_PRESSED,
1753                                       keycode_launch6_,
1754                                       0U));
1755
1756   diamond.SetValue(chromeos::input_method::kControlKey);
1757
1758   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CONTROL,
1759                                       ui::EF_CONTROL_DOWN,
1760                                       ui::ET_KEY_PRESSED,
1761                                       keycode_control_l_,
1762                                       0U,
1763                                       KeyPress),
1764             GetRewrittenEventAsString(&rewriter,
1765                                       ui::VKEY_F15,
1766                                       0,
1767                                       ui::ET_KEY_PRESSED,
1768                                       keycode_launch6_,
1769                                       0U));
1770
1771   diamond.SetValue(chromeos::input_method::kAltKey);
1772
1773   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_MENU,
1774                                       ui::EF_ALT_DOWN,
1775                                       ui::ET_KEY_PRESSED,
1776                                       keycode_alt_l_,
1777                                       0,
1778                                       KeyPress),
1779             GetRewrittenEventAsString(&rewriter,
1780                                       ui::VKEY_F15,
1781                                       0,
1782                                       ui::ET_KEY_PRESSED,
1783                                       keycode_launch6_,
1784                                       0U));
1785
1786   diamond.SetValue(chromeos::input_method::kCapsLockKey);
1787
1788   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CAPITAL,
1789                                       ui::EF_CAPS_LOCK_DOWN,
1790                                       ui::ET_KEY_PRESSED,
1791                                       keycode_caps_lock_,
1792                                       0U,
1793                                       KeyPress),
1794             GetRewrittenEventAsString(&rewriter,
1795                                       ui::VKEY_F15,
1796                                       0,
1797                                       ui::ET_KEY_PRESSED,
1798                                       keycode_launch6_,
1799                                       0U));
1800
1801   *CommandLine::ForCurrentProcess() = original_cl;
1802 }
1803
1804 TEST_F(EventRewriterTest, TestRewriteCapsLockToControl) {
1805   TestingPrefServiceSyncable prefs;
1806   chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
1807   IntegerPrefMember control;
1808   control.Init(prefs::kLanguageRemapCapsLockKeyTo, &prefs);
1809   control.SetValue(chromeos::input_method::kControlKey);
1810
1811   EventRewriter rewriter;
1812   rewriter.set_pref_service_for_testing(&prefs);
1813
1814   // Press CapsLock+a. Confirm that Mod3Mask is rewritten to ControlMask.
1815   // On Chrome OS, CapsLock works as a Mod3 modifier.
1816   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_A,
1817                                       ui::EF_CONTROL_DOWN,
1818                                       ui::ET_KEY_PRESSED,
1819                                       keycode_a_,
1820                                       ControlMask,
1821                                       KeyPress),
1822             GetRewrittenEventAsString(&rewriter,
1823                                       ui::VKEY_A,
1824                                       0,
1825                                       ui::ET_KEY_PRESSED,
1826                                       keycode_a_,
1827                                       Mod3Mask));
1828
1829   // Press Control+CapsLock+a. Confirm that Mod3Mask is rewritten to ControlMask
1830   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_A,
1831                                       ui::EF_CONTROL_DOWN,
1832                                       ui::ET_KEY_PRESSED,
1833                                       keycode_a_,
1834                                       ControlMask,
1835                                       KeyPress),
1836             GetRewrittenEventAsString(&rewriter,
1837                                       ui::VKEY_A,
1838                                       ui::EF_CONTROL_DOWN,
1839                                       ui::ET_KEY_PRESSED,
1840                                       keycode_a_,
1841                                       Mod3Mask | ControlMask));
1842
1843   // Press Alt+CapsLock+a. Confirm that Mod3Mask is rewritten to ControlMask.
1844   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_A,
1845                                       ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN,
1846                                       ui::ET_KEY_PRESSED,
1847                                       keycode_a_,
1848                                       Mod1Mask | ControlMask,
1849                                       KeyPress),
1850             GetRewrittenEventAsString(&rewriter,
1851                                       ui::VKEY_A,
1852                                       ui::EF_ALT_DOWN,
1853                                       ui::ET_KEY_PRESSED,
1854                                       keycode_a_,
1855                                       Mod1Mask | Mod3Mask));
1856 }
1857
1858 TEST_F(EventRewriterTest, TestRewriteCapsLockMod3InUse) {
1859   // Remap CapsLock to Control.
1860   TestingPrefServiceSyncable prefs;
1861   chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
1862   IntegerPrefMember control;
1863   control.Init(prefs::kLanguageRemapCapsLockKeyTo, &prefs);
1864   control.SetValue(chromeos::input_method::kControlKey);
1865
1866   EventRewriter rewriter;
1867   rewriter.set_pref_service_for_testing(&prefs);
1868   input_method_manager_mock_->SetCurrentInputMethodId("xkb:de:neo:ger");
1869
1870   // Press CapsLock+a. Confirm that Mod3Mask is NOT rewritten to ControlMask
1871   // when Mod3Mask is already in use by the current XKB layout.
1872   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_A,
1873                                       0,
1874                                       ui::ET_KEY_PRESSED,
1875                                       keycode_a_,
1876                                       Mod3Mask,
1877                                       KeyPress),
1878             GetRewrittenEventAsString(&rewriter,
1879                                       ui::VKEY_A,
1880                                       0,
1881                                       ui::ET_KEY_PRESSED,
1882                                       keycode_a_,
1883                                       Mod3Mask));
1884
1885   input_method_manager_mock_->SetCurrentInputMethodId("xkb:us::eng");
1886 }
1887
1888 TEST_F(EventRewriterTest, TestRewriteExtendedKeys) {
1889   TestingPrefServiceSyncable prefs;
1890   chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
1891   EventRewriter rewriter;
1892   rewriter.set_pref_service_for_testing(&prefs);
1893
1894   struct {
1895     ui::KeyboardCode input;
1896     KeyCode input_native;
1897     unsigned int input_mods;
1898     unsigned int input_native_mods;
1899     ui::KeyboardCode output;
1900     KeyCode output_native;
1901     unsigned int output_mods;
1902     unsigned int output_native_mods;
1903   } chromeos_tests[] = {
1904     // Alt+Backspace -> Delete
1905     { ui::VKEY_BACK, keycode_backspace_,
1906       ui::EF_ALT_DOWN, Mod1Mask,
1907       ui::VKEY_DELETE, keycode_delete_,
1908       0, 0, },
1909     // Control+Alt+Backspace -> Control+Delete
1910     { ui::VKEY_BACK, keycode_backspace_,
1911       ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN, Mod1Mask | ControlMask,
1912       ui::VKEY_DELETE, keycode_delete_,
1913       ui::EF_CONTROL_DOWN, ControlMask, },
1914     // Search+Alt+Backspace -> Alt+Backspace
1915     { ui::VKEY_BACK, keycode_backspace_,
1916       ui::EF_ALT_DOWN, Mod1Mask | Mod4Mask,
1917       ui::VKEY_BACK, keycode_backspace_,
1918       ui::EF_ALT_DOWN, Mod1Mask, },
1919     // Search+Control+Alt+Backspace -> Control+Alt+Backspace
1920     { ui::VKEY_BACK, keycode_backspace_,
1921       ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN, Mod1Mask | ControlMask | Mod4Mask,
1922       ui::VKEY_BACK, keycode_backspace_,
1923       ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN, Mod1Mask | ControlMask, },
1924     // Alt+Up -> Prior
1925     { ui::VKEY_UP, keycode_up_,
1926       ui::EF_ALT_DOWN, Mod1Mask,
1927       ui::VKEY_PRIOR, keycode_prior_,
1928       0, 0, },
1929     // Alt+Down -> Next
1930     { ui::VKEY_DOWN, keycode_down_,
1931       ui::EF_ALT_DOWN, Mod1Mask,
1932       ui::VKEY_NEXT, keycode_next_,
1933       0, 0, },
1934     // Ctrl+Alt+Up -> Home
1935     { ui::VKEY_UP, keycode_up_,
1936       ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN, Mod1Mask | ControlMask,
1937       ui::VKEY_HOME, keycode_home_,
1938       0, 0, },
1939     // Ctrl+Alt+Down -> End
1940     { ui::VKEY_DOWN, keycode_down_,
1941       ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN, Mod1Mask | ControlMask,
1942       ui::VKEY_END, keycode_end_,
1943       0, 0, },
1944
1945     // Search+Alt+Up -> Alt+Up
1946     { ui::VKEY_UP, keycode_up_,
1947       ui::EF_ALT_DOWN, Mod1Mask | Mod4Mask,
1948       ui::VKEY_UP, keycode_up_,
1949       ui::EF_ALT_DOWN, Mod1Mask },
1950     // Search+Alt+Down -> Alt+Down
1951     { ui::VKEY_DOWN, keycode_down_,
1952       ui::EF_ALT_DOWN, Mod1Mask | Mod4Mask,
1953       ui::VKEY_DOWN, keycode_down_,
1954       ui::EF_ALT_DOWN, Mod1Mask },
1955     // Search+Ctrl+Alt+Up -> Search+Ctrl+Alt+Up
1956     { ui::VKEY_UP, keycode_up_,
1957       ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN, Mod1Mask | ControlMask | Mod4Mask,
1958       ui::VKEY_UP, keycode_up_,
1959       ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN, Mod1Mask | ControlMask },
1960     // Search+Ctrl+Alt+Down -> Ctrl+Alt+Down
1961     { ui::VKEY_DOWN, keycode_down_,
1962       ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN, Mod1Mask | ControlMask | Mod4Mask,
1963       ui::VKEY_DOWN, keycode_down_,
1964       ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN, Mod1Mask | ControlMask },
1965
1966     // Period -> Period
1967     { ui::VKEY_OEM_PERIOD, keycode_period_, 0, 0,
1968       ui::VKEY_OEM_PERIOD, keycode_period_, 0, 0 },
1969
1970     // Search+Backspace -> Delete
1971     { ui::VKEY_BACK, keycode_backspace_,
1972       0, Mod4Mask,
1973       ui::VKEY_DELETE, keycode_delete_,
1974       0, 0, },
1975     // Search+Up -> Prior
1976     { ui::VKEY_UP, keycode_up_,
1977       0, Mod4Mask,
1978       ui::VKEY_PRIOR, keycode_prior_,
1979       0, 0, },
1980     // Search+Down -> Next
1981     { ui::VKEY_DOWN, keycode_down_,
1982       0, Mod4Mask,
1983       ui::VKEY_NEXT, keycode_next_,
1984       0, 0, },
1985     // Search+Left -> Home
1986     { ui::VKEY_LEFT, keycode_left_,
1987       0, Mod4Mask,
1988       ui::VKEY_HOME, keycode_home_,
1989       0, 0, },
1990     // Control+Search+Left -> Home
1991     { ui::VKEY_LEFT, keycode_left_,
1992       ui::EF_CONTROL_DOWN, Mod4Mask | ControlMask,
1993       ui::VKEY_HOME, keycode_home_,
1994       ui::EF_CONTROL_DOWN, ControlMask },
1995     // Search+Right -> End
1996     { ui::VKEY_RIGHT, keycode_right_,
1997       0, Mod4Mask,
1998       ui::VKEY_END, keycode_end_,
1999       0, 0, },
2000     // Control+Search+Right -> End
2001     { ui::VKEY_RIGHT, keycode_right_,
2002       ui::EF_CONTROL_DOWN, Mod4Mask | ControlMask,
2003       ui::VKEY_END, keycode_end_,
2004       ui::EF_CONTROL_DOWN, ControlMask },
2005     // Search+Period -> Insert
2006     { ui::VKEY_OEM_PERIOD, keycode_period_, 0, Mod4Mask,
2007       ui::VKEY_INSERT, keycode_insert_, 0, 0 },
2008     // Control+Search+Period -> Control+Insert
2009     { ui::VKEY_OEM_PERIOD, keycode_period_,
2010       ui::EF_CONTROL_DOWN, Mod4Mask | ControlMask,
2011       ui::VKEY_INSERT, keycode_insert_,
2012       ui::EF_CONTROL_DOWN, ControlMask }
2013   };
2014
2015   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(chromeos_tests); ++i) {
2016     EXPECT_EQ(GetExpectedResultAsString(chromeos_tests[i].output,
2017                                         chromeos_tests[i].output_mods,
2018                                         ui::ET_KEY_PRESSED,
2019                                         chromeos_tests[i].output_native,
2020                                         chromeos_tests[i].output_native_mods,
2021                                         KeyPress),
2022               GetRewrittenEventAsString(&rewriter,
2023                                         chromeos_tests[i].input,
2024                                         chromeos_tests[i].input_mods,
2025                                         ui::ET_KEY_PRESSED,
2026                                         chromeos_tests[i].input_native,
2027                                         chromeos_tests[i].input_native_mods));
2028   }
2029 }
2030
2031 TEST_F(EventRewriterTest, TestRewriteFunctionKeys) {
2032   TestingPrefServiceSyncable prefs;
2033   chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
2034   EventRewriter rewriter;
2035   rewriter.set_pref_service_for_testing(&prefs);
2036
2037   struct {
2038     ui::KeyboardCode input;
2039     KeyCode input_native;
2040     unsigned int input_native_mods;
2041     unsigned int input_mods;
2042     ui::KeyboardCode output;
2043     KeyCode output_native;
2044     unsigned int output_native_mods;
2045     unsigned int output_mods;
2046   } tests[] = {
2047     // F1 -> Back
2048     { ui::VKEY_F1, keycode_f1_, 0, 0,
2049       ui::VKEY_BROWSER_BACK, keycode_browser_back_, 0, 0 },
2050     { ui::VKEY_F1, keycode_f1_, ControlMask, ui::EF_CONTROL_DOWN,
2051       ui::VKEY_BROWSER_BACK, keycode_browser_back_,
2052       ControlMask, ui::EF_CONTROL_DOWN },
2053     { ui::VKEY_F1, keycode_f1_, Mod1Mask, ui::EF_ALT_DOWN,
2054       ui::VKEY_BROWSER_BACK, keycode_browser_back_,
2055       Mod1Mask, ui::EF_ALT_DOWN },
2056     // F2 -> Forward
2057     { ui::VKEY_F2, keycode_f2_, 0, 0,
2058       ui::VKEY_BROWSER_FORWARD, keycode_browser_forward_, 0, 0 },
2059     { ui::VKEY_F2, keycode_f2_, ControlMask, ui::EF_CONTROL_DOWN,
2060       ui::VKEY_BROWSER_FORWARD, keycode_browser_forward_,
2061       ControlMask, ui::EF_CONTROL_DOWN },
2062     { ui::VKEY_F2, keycode_f2_, Mod1Mask, ui::EF_ALT_DOWN,
2063       ui::VKEY_BROWSER_FORWARD, keycode_browser_forward_,
2064       Mod1Mask, ui::EF_ALT_DOWN },
2065     // F3 -> Refresh
2066     { ui::VKEY_F3, keycode_f3_, 0, 0,
2067       ui::VKEY_BROWSER_REFRESH, keycode_browser_refresh_, 0, 0 },
2068     { ui::VKEY_F3, keycode_f3_, ControlMask, ui::EF_CONTROL_DOWN,
2069       ui::VKEY_BROWSER_REFRESH, keycode_browser_refresh_,
2070       ControlMask, ui::EF_CONTROL_DOWN },
2071     { ui::VKEY_F3, keycode_f3_, Mod1Mask, ui::EF_ALT_DOWN,
2072       ui::VKEY_BROWSER_REFRESH, keycode_browser_refresh_,
2073       Mod1Mask, ui::EF_ALT_DOWN },
2074     // F4 -> Launch App 2
2075     { ui::VKEY_F4, keycode_f4_, 0, 0,
2076       ui::VKEY_MEDIA_LAUNCH_APP2, keycode_media_launch_app2_, 0, 0 },
2077     { ui::VKEY_F4, keycode_f4_, ControlMask, ui::EF_CONTROL_DOWN,
2078       ui::VKEY_MEDIA_LAUNCH_APP2, keycode_media_launch_app2_,
2079       ControlMask, ui::EF_CONTROL_DOWN },
2080     { ui::VKEY_F4, keycode_f4_, Mod1Mask, ui::EF_ALT_DOWN,
2081       ui::VKEY_MEDIA_LAUNCH_APP2, keycode_media_launch_app2_,
2082       Mod1Mask, ui::EF_ALT_DOWN },
2083     // F5 -> Launch App 1
2084     { ui::VKEY_F5, keycode_f5_, 0, 0,
2085       ui::VKEY_MEDIA_LAUNCH_APP1, keycode_media_launch_app1_, 0, 0 },
2086     { ui::VKEY_F5, keycode_f5_, ControlMask, ui::EF_CONTROL_DOWN,
2087       ui::VKEY_MEDIA_LAUNCH_APP1, keycode_media_launch_app1_,
2088       ControlMask, ui::EF_CONTROL_DOWN },
2089     { ui::VKEY_F5, keycode_f5_, Mod1Mask, ui::EF_ALT_DOWN,
2090       ui::VKEY_MEDIA_LAUNCH_APP1, keycode_media_launch_app1_,
2091       Mod1Mask, ui::EF_ALT_DOWN },
2092     // F6 -> Brightness down
2093     { ui::VKEY_F6, keycode_f6_, 0, 0,
2094       ui::VKEY_BRIGHTNESS_DOWN, keycode_brightness_down_, 0, 0 },
2095     { ui::VKEY_F6, keycode_f6_, ControlMask, ui::EF_CONTROL_DOWN,
2096       ui::VKEY_BRIGHTNESS_DOWN, keycode_brightness_down_,
2097       ControlMask, ui::EF_CONTROL_DOWN },
2098     { ui::VKEY_F6, keycode_f6_, Mod1Mask, ui::EF_ALT_DOWN,
2099       ui::VKEY_BRIGHTNESS_DOWN, keycode_brightness_down_,
2100       Mod1Mask, ui::EF_ALT_DOWN },
2101     // F7 -> Brightness up
2102     { ui::VKEY_F7, keycode_f7_, 0, 0,
2103       ui::VKEY_BRIGHTNESS_UP, keycode_brightness_up_, 0, 0 },
2104     { ui::VKEY_F7, keycode_f7_, ControlMask, ui::EF_CONTROL_DOWN,
2105       ui::VKEY_BRIGHTNESS_UP, keycode_brightness_up_,
2106       ControlMask, ui::EF_CONTROL_DOWN },
2107     { ui::VKEY_F7, keycode_f7_, Mod1Mask, ui::EF_ALT_DOWN,
2108       ui::VKEY_BRIGHTNESS_UP, keycode_brightness_up_,
2109       Mod1Mask, ui::EF_ALT_DOWN },
2110     // F8 -> Volume Mute
2111     { ui::VKEY_F8, keycode_f8_, 0, 0,
2112       ui::VKEY_VOLUME_MUTE, keycode_volume_mute_, 0, 0 },
2113     { ui::VKEY_F8, keycode_f8_, ControlMask, ui::EF_CONTROL_DOWN,
2114       ui::VKEY_VOLUME_MUTE, keycode_volume_mute_,
2115       ControlMask, ui::EF_CONTROL_DOWN },
2116     { ui::VKEY_F8, keycode_f8_, Mod1Mask, ui::EF_ALT_DOWN,
2117       ui::VKEY_VOLUME_MUTE, keycode_volume_mute_,
2118       Mod1Mask, ui::EF_ALT_DOWN },
2119     // F9 -> Volume Down
2120     { ui::VKEY_F9, keycode_f9_, 0, 0,
2121       ui::VKEY_VOLUME_DOWN, keycode_volume_down_, 0, 0 },
2122     { ui::VKEY_F9, keycode_f9_, ControlMask, ui::EF_CONTROL_DOWN,
2123       ui::VKEY_VOLUME_DOWN, keycode_volume_down_,
2124       ControlMask, ui::EF_CONTROL_DOWN },
2125     { ui::VKEY_F9, keycode_f9_, Mod1Mask, ui::EF_ALT_DOWN,
2126       ui::VKEY_VOLUME_DOWN, keycode_volume_down_,
2127       Mod1Mask, ui::EF_ALT_DOWN },
2128     // F10 -> Volume Up
2129     { ui::VKEY_F10, keycode_f10_, 0, 0,
2130       ui::VKEY_VOLUME_UP, keycode_volume_up_, 0, 0 },
2131     { ui::VKEY_F10, keycode_f10_, ControlMask, ui::EF_CONTROL_DOWN,
2132       ui::VKEY_VOLUME_UP, keycode_volume_up_,
2133       ControlMask, ui::EF_CONTROL_DOWN },
2134     { ui::VKEY_F10, keycode_f10_, Mod1Mask, ui::EF_ALT_DOWN,
2135       ui::VKEY_VOLUME_UP, keycode_volume_up_,
2136       Mod1Mask, ui::EF_ALT_DOWN },
2137     // F11 -> F11
2138     { ui::VKEY_F11, keycode_f11_, 0, 0,
2139       ui::VKEY_F11, keycode_f11_, 0, 0 },
2140     { ui::VKEY_F11, keycode_f11_, ControlMask, ui::EF_CONTROL_DOWN,
2141       ui::VKEY_F11, keycode_f11_, ControlMask, ui::EF_CONTROL_DOWN },
2142     { ui::VKEY_F11, keycode_f11_, Mod1Mask, ui::EF_ALT_DOWN,
2143       ui::VKEY_F11, keycode_f11_, Mod1Mask, ui::EF_ALT_DOWN },
2144     // F12 -> F12
2145     { ui::VKEY_F12, keycode_f12_, 0, 0,
2146       ui::VKEY_F12, keycode_f12_, 0, 0 },
2147     { ui::VKEY_F12, keycode_f12_, ControlMask, ui::EF_CONTROL_DOWN,
2148       ui::VKEY_F12, keycode_f12_, ControlMask, ui::EF_CONTROL_DOWN },
2149     { ui::VKEY_F12, keycode_f12_, Mod1Mask, ui::EF_ALT_DOWN,
2150       ui::VKEY_F12, keycode_f12_, Mod1Mask, ui::EF_ALT_DOWN },
2151
2152     // The number row should not be rewritten without Search key.
2153     { ui::VKEY_1, keycode_1_, 0, 0,
2154       ui::VKEY_1, keycode_1_, 0, 0 },
2155     { ui::VKEY_2, keycode_2_, 0, 0,
2156       ui::VKEY_2, keycode_2_, 0, 0 },
2157     { ui::VKEY_3, keycode_3_, 0, 0,
2158       ui::VKEY_3, keycode_3_, 0, 0 },
2159     { ui::VKEY_4, keycode_4_, 0, 0,
2160       ui::VKEY_4, keycode_4_, 0, 0 },
2161     { ui::VKEY_5, keycode_5_, 0, 0,
2162       ui::VKEY_5, keycode_5_, 0, 0 },
2163     { ui::VKEY_6, keycode_6_, 0, 0,
2164       ui::VKEY_6, keycode_6_, 0, 0 },
2165     { ui::VKEY_7, keycode_7_, 0, 0,
2166       ui::VKEY_7, keycode_7_, 0, 0 },
2167     { ui::VKEY_8, keycode_8_, 0, 0,
2168       ui::VKEY_8, keycode_8_, 0, 0 },
2169     { ui::VKEY_9, keycode_9_, 0, 0,
2170       ui::VKEY_9, keycode_9_, 0, 0 },
2171     { ui::VKEY_0, keycode_0_, 0, 0,
2172       ui::VKEY_0, keycode_0_, 0, 0 },
2173     { ui::VKEY_OEM_MINUS, keycode_minus_, 0, 0,
2174       ui::VKEY_OEM_MINUS, keycode_minus_, 0, 0 },
2175     { ui::VKEY_OEM_PLUS, keycode_equal_, 0, 0,
2176       ui::VKEY_OEM_PLUS, keycode_equal_, 0, 0 },
2177
2178     // The number row should be rewritten as the F<number> row with Search key.
2179     { ui::VKEY_1, keycode_1_, Mod4Mask, 0,
2180       ui::VKEY_F1, keycode_f1_, 0, 0 },
2181     { ui::VKEY_2, keycode_2_, Mod4Mask, 0,
2182       ui::VKEY_F2, keycode_f2_, 0, 0 },
2183     { ui::VKEY_3, keycode_3_, Mod4Mask, 0,
2184       ui::VKEY_F3, keycode_f3_, 0, 0 },
2185     { ui::VKEY_4, keycode_4_, Mod4Mask, 0,
2186       ui::VKEY_F4, keycode_f4_, 0, 0 },
2187     { ui::VKEY_5, keycode_5_, Mod4Mask, 0,
2188       ui::VKEY_F5, keycode_f5_, 0, 0 },
2189     { ui::VKEY_6, keycode_6_, Mod4Mask, 0,
2190       ui::VKEY_F6, keycode_f6_, 0, 0 },
2191     { ui::VKEY_7, keycode_7_, Mod4Mask, 0,
2192       ui::VKEY_F7, keycode_f7_, 0, 0 },
2193     { ui::VKEY_8, keycode_8_, Mod4Mask, 0,
2194       ui::VKEY_F8, keycode_f8_, 0, 0 },
2195     { ui::VKEY_9, keycode_9_, Mod4Mask, 0,
2196       ui::VKEY_F9, keycode_f9_, 0, 0 },
2197     { ui::VKEY_0, keycode_0_, Mod4Mask, 0,
2198       ui::VKEY_F10, keycode_f10_, 0, 0 },
2199     { ui::VKEY_OEM_MINUS, keycode_minus_, Mod4Mask, 0,
2200       ui::VKEY_F11, keycode_f11_, 0, 0 },
2201     { ui::VKEY_OEM_PLUS, keycode_equal_, Mod4Mask, 0,
2202       ui::VKEY_F12, keycode_f12_, 0, 0 },
2203
2204     // The function keys should not be rewritten with Search key pressed.
2205     { ui::VKEY_F1, keycode_f1_, Mod4Mask, 0,
2206       ui::VKEY_F1, keycode_f1_, 0, 0 },
2207     { ui::VKEY_F2, keycode_f2_, Mod4Mask, 0,
2208       ui::VKEY_F2, keycode_f2_, 0, 0 },
2209     { ui::VKEY_F3, keycode_f3_, Mod4Mask, 0,
2210       ui::VKEY_F3, keycode_f3_, 0, 0 },
2211     { ui::VKEY_F4, keycode_f4_, Mod4Mask, 0,
2212       ui::VKEY_F4, keycode_f4_, 0, 0 },
2213     { ui::VKEY_F5, keycode_f5_, Mod4Mask, 0,
2214       ui::VKEY_F5, keycode_f5_, 0, 0 },
2215     { ui::VKEY_F6, keycode_f6_, Mod4Mask, 0,
2216       ui::VKEY_F6, keycode_f6_, 0, 0 },
2217     { ui::VKEY_F7, keycode_f7_, Mod4Mask, 0,
2218       ui::VKEY_F7, keycode_f7_, 0, 0 },
2219     { ui::VKEY_F8, keycode_f8_, Mod4Mask, 0,
2220       ui::VKEY_F8, keycode_f8_, 0, 0 },
2221     { ui::VKEY_F9, keycode_f9_, Mod4Mask, 0,
2222       ui::VKEY_F9, keycode_f9_, 0, 0 },
2223     { ui::VKEY_F10, keycode_f10_, Mod4Mask, 0,
2224       ui::VKEY_F10, keycode_f10_, 0, 0 },
2225     { ui::VKEY_F11, keycode_f11_, Mod4Mask, 0,
2226       ui::VKEY_F11, keycode_f11_, 0, 0 },
2227     { ui::VKEY_F12, keycode_f12_, Mod4Mask, 0,
2228       ui::VKEY_F12, keycode_f12_, 0, 0 },
2229   };
2230
2231   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
2232     EXPECT_EQ(GetExpectedResultAsString(tests[i].output,
2233                                         tests[i].output_mods,
2234                                         ui::ET_KEY_PRESSED,
2235                                         tests[i].output_native,
2236                                         tests[i].output_native_mods,
2237                                         KeyPress),
2238               GetRewrittenEventAsString(&rewriter,
2239                                         tests[i].input,
2240                                         tests[i].input_mods,
2241                                         ui::ET_KEY_PRESSED,
2242                                         tests[i].input_native,
2243                                         tests[i].input_native_mods));
2244   }
2245 }
2246
2247 TEST_F(EventRewriterTest, TestRewriteExtendedKeysWithSearchRemapped) {
2248   const CommandLine original_cl(*CommandLine::ForCurrentProcess());
2249
2250   // Remap Search to Control.
2251   TestingPrefServiceSyncable prefs;
2252   chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
2253   IntegerPrefMember search;
2254   search.Init(prefs::kLanguageRemapSearchKeyTo, &prefs);
2255   search.SetValue(chromeos::input_method::kControlKey);
2256
2257   EventRewriter rewriter;
2258   rewriter.set_pref_service_for_testing(&prefs);
2259
2260   CommandLine::ForCurrentProcess()->AppendSwitchASCII(
2261       chromeos::switches::kHasChromeOSKeyboard, "");
2262
2263   // Alt+Search+Down -> End
2264   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_END,
2265                                       0,
2266                                       ui::ET_KEY_PRESSED,
2267                                       keycode_end_,
2268                                       0U,
2269                                       KeyPress),
2270             GetRewrittenEventAsString(&rewriter,
2271                                       ui::VKEY_DOWN,
2272                                       ui::EF_ALT_DOWN,
2273                                       ui::ET_KEY_PRESSED,
2274                                       keycode_down_,
2275                                       Mod1Mask | Mod4Mask));
2276
2277   // Shift+Alt+Search+Down -> Shift+End
2278   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_END,
2279                                       ui::EF_SHIFT_DOWN,
2280                                       ui::ET_KEY_PRESSED,
2281                                       keycode_end_,
2282                                       ShiftMask,
2283                                       KeyPress),
2284             GetRewrittenEventAsString(&rewriter,
2285                                       ui::VKEY_DOWN,
2286                                       ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN,
2287                                       ui::ET_KEY_PRESSED,
2288                                       keycode_down_,
2289                                       ShiftMask | Mod1Mask | Mod4Mask));
2290
2291   *CommandLine::ForCurrentProcess() = original_cl;
2292 }
2293
2294 TEST_F(EventRewriterTest, TestRewriteKeyEventSentByXSendEvent) {
2295   // Remap Control to Alt.
2296   TestingPrefServiceSyncable prefs;
2297   chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
2298   IntegerPrefMember control;
2299   control.Init(prefs::kLanguageRemapControlKeyTo, &prefs);
2300   control.SetValue(chromeos::input_method::kAltKey);
2301
2302   EventRewriter rewriter;
2303   rewriter.set_pref_service_for_testing(&prefs);
2304
2305   // Send left control press.
2306   std::string rewritten_event;
2307   {
2308     XEvent xev;
2309     InitXKeyEvent(ui::VKEY_CONTROL, 0, ui::ET_KEY_PRESSED,
2310                   keycode_control_l_, 0U, &xev);
2311     xev.xkey.send_event = True;  // XSendEvent() always does this.
2312     ui::KeyEvent keyevent(&xev, false /* is_char */);
2313     rewriter.RewriteForTesting(&keyevent);
2314     rewritten_event = base::StringPrintf(
2315         "ui_keycode=%d ui_flags=%d ui_type=%d "
2316         "x_keycode=%u x_state=%u x_type=%d",
2317         keyevent.key_code(), keyevent.flags(), keyevent.type(),
2318         xev.xkey.keycode, xev.xkey.state, xev.xkey.type);
2319   }
2320
2321   // XK_Control_L (left Control key) should NOT be remapped to Alt if send_event
2322   // flag in the event is True.
2323   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CONTROL,
2324                                       ui::EF_CONTROL_DOWN,
2325                                       ui::ET_KEY_PRESSED,
2326                                       keycode_control_l_,
2327                                       0U,
2328                                       KeyPress),
2329             rewritten_event);
2330 }
2331
2332 // Tests of event rewriting that depend on the Ash window manager.
2333 class EventRewriterAshTest : public ash::test::AshTestBase {
2334  public:
2335   EventRewriterAshTest() {
2336     chromeos::Preferences::RegisterProfilePrefs(prefs_.registry());
2337     rewriter_.set_pref_service_for_testing(&prefs_);
2338   }
2339   virtual ~EventRewriterAshTest() {}
2340
2341   bool RewriteFunctionKeys(ui::KeyEvent* event) {
2342     return rewriter_.RewriteFunctionKeys(event);
2343   }
2344
2345  protected:
2346   TestingPrefServiceSyncable prefs_;
2347
2348  private:
2349   EventRewriter rewriter_;
2350
2351   DISALLOW_COPY_AND_ASSIGN(EventRewriterAshTest);
2352 };
2353
2354 TEST_F(EventRewriterAshTest, TopRowKeysAreFunctionKeys) {
2355   scoped_ptr<aura::Window> window(CreateTestWindowInShellWithId(1));
2356   ash::wm::WindowState* window_state = ash::wm::GetWindowState(window.get());
2357   window_state->Activate();
2358
2359   // Create a simulated keypress of F1 targetted at the window.
2360   XEvent xev_f1;
2361   KeyCode keycode_f1 = XKeysymToKeycode(gfx::GetXDisplay(), XK_F1);
2362   InitXKeyEvent(ui::VKEY_F1, 0, ui::ET_KEY_PRESSED, keycode_f1, 0u, &xev_f1);
2363   ui::KeyEvent press_f1(&xev_f1, false);
2364   ui::Event::DispatcherApi dispatch_helper(&press_f1);
2365   dispatch_helper.set_target(window.get());
2366
2367   // Simulate an apps v2 window that has requested top row keys as function
2368   // keys. The event should not be rewritten.
2369   window_state->set_top_row_keys_are_function_keys(true);
2370   ASSERT_FALSE(RewriteFunctionKeys(&press_f1));
2371   ASSERT_EQ(ui::VKEY_F1, press_f1.key_code());
2372
2373   // The event should also not be rewritten if the send-function-keys pref is
2374   // additionally set, for both apps v2 and regular windows.
2375   BooleanPrefMember send_function_keys_pref;
2376   send_function_keys_pref.Init(prefs::kLanguageSendFunctionKeys, &prefs_);
2377   send_function_keys_pref.SetValue(true);
2378   ASSERT_FALSE(RewriteFunctionKeys(&press_f1));
2379   ASSERT_EQ(ui::VKEY_F1, press_f1.key_code());
2380   window_state->set_top_row_keys_are_function_keys(false);
2381   ASSERT_FALSE(RewriteFunctionKeys(&press_f1));
2382   ASSERT_EQ(ui::VKEY_F1, press_f1.key_code());
2383
2384   // If the pref isn't set when an event is sent to a regular window, F1 is
2385   // rewritten to the back key.
2386   send_function_keys_pref.SetValue(false);
2387   ASSERT_TRUE(RewriteFunctionKeys(&press_f1));
2388   ASSERT_EQ(ui::VKEY_BROWSER_BACK, press_f1.key_code());
2389 }
2390
2391 #endif  // OS_CHROMEOS