Use XInput2 events for keyboard events.

chrome/browser/chromeos/events/event_rewriter_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/chromeos/events/event_rewriter.h"
 
 #include <vector>
 
 #include "ash/shell.h"
 #include "ash/sticky_keys/sticky_keys_controller.h"
@@ skipping 11 matching lines @@
 #include "chrome/browser/chromeos/preferences.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_pref_service_syncable.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/ime/fake_ime_keyboard.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/events/event.h"
 #include "ui/events/event_rewriter.h"
+#include "ui/events/test/events_test_utils.h"
 #include "ui/events/test/test_event_processor.h"
 
 #if defined(USE_X11)
 #include <X11/keysym.h>
 
 #include "ui/events/test/events_test_utils_x11.h"
 #include "ui/events/x/touch_factory_x11.h"
 #include "ui/gfx/x/x11_types.h"
 #endif
 
 namespace {
 
 // The device id of the test touchpad device.
 const unsigned int kTouchPadDeviceId = 1;
+const int kKeyboardDeviceId = 2;
 
 std::string GetExpectedResultAsString(ui::KeyboardCode ui_keycode,
                                       int ui_flags,
                                       ui::EventType ui_type) {
   return base::StringPrintf("ui_keycode=0x%X ui_flags=0x%X ui_type=%d",
                             ui_keycode,
                             ui_flags & ~ui::EF_IS_REPEAT,
                             ui_type);
 }
 
@@ skipping 28 matching lines @@
                          // between pairs like XK_Insert and XK_KP_Insert.
   };
   int test;
   ui::EventType type;
   struct {
     ui::KeyboardCode key_code;
     int flags;
   } input, expected;
 };
 
+#if defined(USE_X11)
+// Check rewriting of an X11-based key event.
+void CheckX11KeyTestCase(const std::string& expected,
+                         chromeos::EventRewriter* rewriter,
+                         const KeyTestCase& test,
+                         XEvent* xevent) {
+  ui::KeyEvent xkey_event(xevent, false);
+  if (test.test & KeyTestCase::NUMPAD)
+    xkey_event.set_flags(xkey_event.flags() | ui::EF_NUMPAD_KEY);
+  // Verify that the X11-based key event is as expected.
+  EXPECT_EQ(GetExpectedResultAsString(
+                     test.input.key_code, test.input.flags, test.type),
+            GetKeyEventAsString(xkey_event));
+  // Rewrite the event and check the result.
+  scoped_ptr<ui::Event> new_event;
+  rewriter->RewriteEvent(xkey_event, &new_event);
+  ui::KeyEvent& rewritten_key_event =
+      new_event ? *static_cast<ui::KeyEvent*>(new_event.get()) : xkey_event;
+  EXPECT_EQ(expected, GetKeyEventAsString(rewritten_key_event));
+  if ((rewritten_key_event.key_code() != ui::VKEY_UNKNOWN) &&
+      (rewritten_key_event.native_event()->xkey.keycode != 0)) {
+    // Build a new ui::KeyEvent from the rewritten native component,
+    // and check that it also matches the rewritten event.
+    EXPECT_TRUE(rewritten_key_event.native_event());
+    ui::KeyEvent from_native_event(rewritten_key_event.native_event(), false);
+    EXPECT_EQ(expected, GetKeyEventAsString(from_native_event));
+  }
+}
+#endif
+
 // Tests a single stateless key rewrite operation.
 // |i| is a an identifying number to locate failing tests in the tables.
-void CheckKeyTestCase(size_t i,
-                      chromeos::EventRewriter* rewriter,
+void CheckKeyTestCase(chromeos::EventRewriter* rewriter,
                       const KeyTestCase& test) {
-  std::string id = base::StringPrintf("(%zu) ", i);
   std::string expected =
-      id + GetExpectedResultAsString(
+      GetExpectedResultAsString(
                test.expected.key_code, test.expected.flags, test.type);
 
   if (test.test & KeyTestCase::TEST_VKEY) {
     // Check rewriting of a non-native-based key event.
     EXPECT_EQ(
         expected,
-        id + GetRewrittenEventAsString(
+        GetRewrittenEventAsString(
                  rewriter, test.input.key_code, test.input.flags, test.type));
   }
 
 #if defined(USE_X11)
   if (test.test & KeyTestCase::TEST_X11) {
     ui::ScopedXI2Event xev;
+    // Test an XKeyEvent.
     xev.InitKeyEvent(test.type, test.input.key_code, test.input.flags);
     XEvent* xevent = xev;
-    if (xevent->xkey.keycode) {
-      ui::KeyEvent xkey_event(xevent, false);
-      if (test.test & KeyTestCase::NUMPAD)
-        xkey_event.set_flags(xkey_event.flags() | ui::EF_NUMPAD_KEY);
-      // Verify that the X11-based key event is as expected.
-      EXPECT_EQ(id + GetExpectedResultAsString(
-                         test.input.key_code, test.input.flags, test.type),
-                id + GetKeyEventAsString(xkey_event));
-      // Rewrite the event and check the result.
-      scoped_ptr<ui::Event> new_event;
-      rewriter->RewriteEvent(xkey_event, &new_event);
-      ui::KeyEvent& rewritten_key_event =
-          new_event ? *static_cast<ui::KeyEvent*>(new_event.get()) : xkey_event;
-      EXPECT_EQ(expected, id + GetKeyEventAsString(rewritten_key_event));
-      if ((rewritten_key_event.key_code() != ui::VKEY_UNKNOWN) &&
-          (rewritten_key_event.native_event()->xkey.keycode != 0)) {
-        // Build a new ui::KeyEvent from the rewritten native component,
-        // and check that it also matches the rewritten event.
-        ui::KeyEvent from_native_event(rewritten_key_event.native_event(),
-                                       false);
-        EXPECT_EQ(expected, id + GetKeyEventAsString(from_native_event));
-      }
-    }
+    DCHECK((xevent->type == KeyPress) || (xevent->type == KeyRelease));
+    if (xevent->xkey.keycode)
+      CheckX11KeyTestCase(expected, rewriter, test, xevent);
+    // Test an XI2 GenericEvent.
+    xev.InitGenericKeyEvent(
+        kKeyboardDeviceId, test.type, test.input.key_code, test.input.flags);
+    xevent = xev;
+    DCHECK(xevent->type == GenericEvent);
+    XIDeviceEvent* xievent = static_cast<XIDeviceEvent*>(xevent->xcookie.data);
+    DCHECK((xievent->evtype == XI_KeyPress) ||
+           (xievent->evtype == XI_KeyRelease));
+    if (xievent->detail)
+      CheckX11KeyTestCase(expected, rewriter, test, xevent);
   }
 #endif
 }
 
 // Table entry for simple single function key event rewriting tests.
 struct FunctionKeyTestCase {
   ui::EventType type;
   struct {
     ui::KeyboardCode key_code;
     int flags;
   } input, vkey_expected, native_expected;
 };
 
 // Tests a single stateless function key rewrite operation.
 // |i| is a an identifying number to locate failing tests in the tables.
 // Function key mapping differs from the other key mappings because the
 // EF_FUNCTION_KEY flag is set during ui::KeyEvent construction when passing in
 // a native X11 event and the flag is not set when using other constructors.
-void CheckFunctionKeyTestCase(size_t i,
-                              chromeos::EventRewriter* rewriter,
+void CheckFunctionKeyTestCase(chromeos::EventRewriter* rewriter,
                               const FunctionKeyTestCase& test) {
-  std::string id = base::StringPrintf("(%zu) ", i);
   std::string vkey_expected =
-      id + GetExpectedResultAsString(
+      GetExpectedResultAsString(
           test.vkey_expected.key_code,
           test.vkey_expected.flags,
           test.type);
   // Check rewriting of a non-native-based key event.
   EXPECT_EQ(
       vkey_expected,
-      id + GetRewrittenEventAsString(
+      GetRewrittenEventAsString(
                rewriter, test.input.key_code, test.input.flags, test.type));
 
 #if defined(USE_X11)
   ui::ScopedXI2Event xev;
   xev.InitKeyEvent(test.type, test.input.key_code, test.input.flags);
   XEvent* xevent = xev;
   if (xevent->xkey.keycode) {
     ui::KeyEvent xkey_event(xevent, false);
     // Rewrite the event and check the result.
     scoped_ptr<ui::Event> new_event;
     rewriter->RewriteEvent(xkey_event, &new_event);
     ui::KeyEvent& rewritten_key_event =
         new_event ? *static_cast<ui::KeyEvent*>(new_event.get()) : xkey_event;
     std::string native_expected =
-        id + GetExpectedResultAsString(
+        GetExpectedResultAsString(
             test.native_expected.key_code,
             test.native_expected.flags,
             test.type);
-    EXPECT_EQ(native_expected, id + GetKeyEventAsString(rewritten_key_event));
+    EXPECT_EQ(native_expected, GetKeyEventAsString(rewritten_key_event));
   }
 #endif
 }
 
 }  // namespace
 
 namespace chromeos {
 
 class EventRewriterTest : public ash::test::AshTestBase {
  public:
@@ skipping 18 matching lines @@
   virtual void TearDown() {
     AshTestBase::TearDown();
     // Shutdown() deletes the IME mock object.
     chromeos::input_method::Shutdown();
   }
 
  protected:
   void TestRewriteNumPadKeys();
   void TestRewriteNumPadKeysOnAppleKeyboard();
 
-  int RewriteMouseEvent(chromeos::EventRewriter* rewriter,
-                        const ui::MouseEvent& event) {
-    int flags = event.flags();
-    rewriter->RewriteLocatedEventForTesting(event, &flags);
-    return flags;
+  const ui::MouseEvent* RewriteMouseButtonEvent(
+      chromeos::EventRewriter* rewriter,
+      const ui::MouseEvent& event,
+      scoped_ptr<ui::Event>* new_event) {
+    rewriter->RewriteMouseButtonEventForTesting(event, new_event);
+    return *new_event ? static_cast<const ui::MouseEvent*>(new_event->get())
+                      : &event;
   }
 
   chromeos::MockUserManager* mock_user_manager_;  // Not owned.
   chromeos::ScopedUserManagerEnabler user_manager_enabler_;
   chromeos::input_method::MockInputMethodManager* input_method_manager_mock_;
 };
 
 TEST_F(EventRewriterTest, TestRewriteCommandToControl) {
   // First, test with a PC keyboard.
   TestingPrefServiceSyncable prefs;
   EventRewriter rewriter(NULL);
-  rewriter.DeviceAddedForTesting(0, "PC Keyboard");
-  rewriter.set_last_device_id_for_testing(0);
+  rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard");
+  rewriter.set_last_keyboard_device_id_for_testing(kKeyboardDeviceId);
   rewriter.set_pref_service_for_testing(&prefs);
 
   KeyTestCase pc_keyboard_tests[] = {
       // VKEY_A, Alt modifier.
       {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
        {ui::VKEY_A, ui::EF_ALT_DOWN},
        {ui::VKEY_A, ui::EF_ALT_DOWN}},
 
       // VKEY_A, Win modifier.
       {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
@@ skipping 10 matching lines @@
        {ui::VKEY_LWIN, ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN},
        {ui::VKEY_LWIN, ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN}},
 
       // VKEY_RWIN (right Windows key), Alt modifier.
       {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
        {ui::VKEY_RWIN, ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN},
        {ui::VKEY_RWIN, ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN}},
   };
 
   for (size_t i = 0; i < arraysize(pc_keyboard_tests); ++i) {
-    CheckKeyTestCase(1000 + i, &rewriter, pc_keyboard_tests[i]);
+    SCOPED_TRACE(i);
+    CheckKeyTestCase(&rewriter, pc_keyboard_tests[i]);
   }
 
   // An Apple keyboard reusing the ID, zero.
-  rewriter.DeviceAddedForTesting(0, "Apple Keyboard");
-  rewriter.set_last_device_id_for_testing(0);
+  rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "Apple Keyboard");
+  rewriter.set_last_keyboard_device_id_for_testing(kKeyboardDeviceId);
 
   KeyTestCase apple_keyboard_tests[] = {
       // VKEY_A, Alt modifier.
       {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
        {ui::VKEY_A, ui::EF_ALT_DOWN},
        {ui::VKEY_A, ui::EF_ALT_DOWN}},
 
       // VKEY_A, Win modifier.
       {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
        {ui::VKEY_A, ui::EF_COMMAND_DOWN},
        {ui::VKEY_A, ui::EF_CONTROL_DOWN}},
 
       // VKEY_A, Alt+Win modifier.
       {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
        {ui::VKEY_A, ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN},
        {ui::VKEY_A, ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN}},
 
       // VKEY_LWIN (left Windows key), Alt modifier.
       {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
        {ui::VKEY_LWIN, ui::EF_COMMAND_DOWN | ui::EF_ALT_DOWN},
        {ui::VKEY_CONTROL, ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN}},
 
       // VKEY_RWIN (right Windows key), Alt modifier.
       {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
        {ui::VKEY_RWIN, ui::EF_COMMAND_DOWN | ui::EF_ALT_DOWN},
        {ui::VKEY_CONTROL, ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN}},
   };
 
   for (size_t i = 0; i < arraysize(apple_keyboard_tests); ++i) {
-    CheckKeyTestCase(2000 + i, &rewriter, apple_keyboard_tests[i]);
+    SCOPED_TRACE(i);
+    CheckKeyTestCase(&rewriter, apple_keyboard_tests[i]);
   }
 }
 
 // For crbug.com/133896.
 TEST_F(EventRewriterTest, TestRewriteCommandToControlWithControlRemapped) {
   // Remap Control to Alt.
   TestingPrefServiceSyncable prefs;
   chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
   IntegerPrefMember control;
   control.Init(prefs::kLanguageRemapControlKeyTo, &prefs);
   control.SetValue(chromeos::input_method::kAltKey);
 
   EventRewriter rewriter(NULL);
   rewriter.set_pref_service_for_testing(&prefs);
-  rewriter.DeviceAddedForTesting(0, "PC Keyboard");
-  rewriter.set_last_device_id_for_testing(0);
+  rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard");
+  rewriter.set_last_keyboard_device_id_for_testing(kKeyboardDeviceId);
 
   KeyTestCase pc_keyboard_tests[] = {// Control should be remapped to Alt.
                                      {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
                                       {ui::VKEY_CONTROL, ui::EF_CONTROL_DOWN},
                                       {ui::VKEY_MENU, ui::EF_ALT_DOWN}},
   };
 
   for (size_t i = 0; i < arraysize(pc_keyboard_tests); ++i) {
-    CheckKeyTestCase(1000 + i, &rewriter, pc_keyboard_tests[i]);
+    SCOPED_TRACE(i);
+    CheckKeyTestCase(&rewriter, pc_keyboard_tests[i]);
   }
 
   // An Apple keyboard reusing the ID, zero.
-  rewriter.DeviceAddedForTesting(0, "Apple Keyboard");
-  rewriter.set_last_device_id_for_testing(0);
+  rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "Apple Keyboard");
+  rewriter.set_last_keyboard_device_id_for_testing(kKeyboardDeviceId);
 
   KeyTestCase apple_keyboard_tests[] = {
       // VKEY_LWIN (left Command key) with  Alt modifier. The remapped Command
       // key should never be re-remapped to Alt.
       {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
        {ui::VKEY_LWIN, ui::EF_COMMAND_DOWN | ui::EF_ALT_DOWN},
        {ui::VKEY_CONTROL, ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN}},
 
       // VKEY_RWIN (right Command key) with  Alt modifier. The remapped Command
       // key should never be re-remapped to Alt.
       {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
        {ui::VKEY_RWIN, ui::EF_COMMAND_DOWN | ui::EF_ALT_DOWN},
        {ui::VKEY_CONTROL, ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN}},
   };
 
   for (size_t i = 0; i < arraysize(apple_keyboard_tests); ++i) {
-    CheckKeyTestCase(2000 + i, &rewriter, apple_keyboard_tests[i]);
+    SCOPED_TRACE(i);
+    CheckKeyTestCase(&rewriter, apple_keyboard_tests[i]);
   }
 }
 
 void EventRewriterTest::TestRewriteNumPadKeys() {
   TestingPrefServiceSyncable prefs;
   EventRewriter rewriter(NULL);
+  rewriter.set_last_keyboard_device_id_for_testing(kKeyboardDeviceId);
   rewriter.set_pref_service_for_testing(&prefs);
 
   KeyTestCase tests[] = {
       // XK_KP_Insert (= NumPad 0 without Num Lock), no modifier.
       {KeyTestCase::TEST_ALL|KeyTestCase::NUMPAD, ui::ET_KEY_PRESSED,
        {ui::VKEY_INSERT, ui::EF_NUMPAD_KEY},
        {ui::VKEY_NUMPAD0, ui::EF_NUMPAD_KEY}},
 
       // XK_KP_Insert (= NumPad 0 without Num Lock), Alt modifier.
       {KeyTestCase::TEST_ALL|KeyTestCase::NUMPAD, ui::ET_KEY_PRESSED,
@@ skipping 100 matching lines @@
        {ui::VKEY_NUMPAD8, ui::EF_NUMPAD_KEY},
        {ui::VKEY_NUMPAD8, ui::EF_NUMPAD_KEY}},
 
       // XK_KP_9 (= NumPad 9 with Num Lock), Num Lock modifier.
       {KeyTestCase::TEST_ALL|KeyTestCase::NUMPAD, ui::ET_KEY_PRESSED,
        {ui::VKEY_NUMPAD9, ui::EF_NUMPAD_KEY},
        {ui::VKEY_NUMPAD9, ui::EF_NUMPAD_KEY}},
   };
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
-    CheckKeyTestCase(1000 + i, &rewriter, tests[i]);
+    SCOPED_TRACE(i);
+    CheckKeyTestCase(&rewriter, tests[i]);
   }
 }
 
 TEST_F(EventRewriterTest, TestRewriteNumPadKeys) {
   TestRewriteNumPadKeys();
 }
 
 TEST_F(EventRewriterTest, TestRewriteNumPadKeysWithDiamondKeyFlag) {
   // Make sure the num lock works correctly even when Diamond key exists.
   const CommandLine original_cl(*CommandLine::ForCurrentProcess());
   CommandLine::ForCurrentProcess()->AppendSwitchASCII(
       chromeos::switches::kHasChromeOSDiamondKey, "");
 
   TestRewriteNumPadKeys();
   *CommandLine::ForCurrentProcess() = original_cl;
 }
 
 // Tests if the rewriter can handle a Command + Num Pad event.
 void EventRewriterTest::TestRewriteNumPadKeysOnAppleKeyboard() {
   TestingPrefServiceSyncable prefs;
   EventRewriter rewriter(NULL);
-  rewriter.DeviceAddedForTesting(0, "Apple Keyboard");
-  rewriter.set_last_device_id_for_testing(0);
+  rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "Apple Keyboard");
+  rewriter.set_last_keyboard_device_id_for_testing(kKeyboardDeviceId);
   rewriter.set_pref_service_for_testing(&prefs);
 
   KeyTestCase tests[] = {
       // XK_KP_End (= NumPad 1 without Num Lock), Win modifier.
       // The result should be "Num Pad 1 with Control + Num Lock modifiers".
       {KeyTestCase::TEST_ALL|KeyTestCase::NUMPAD, ui::ET_KEY_PRESSED,
        {ui::VKEY_END, ui::EF_COMMAND_DOWN | ui::EF_NUMPAD_KEY},
        {ui::VKEY_NUMPAD1, ui::EF_CONTROL_DOWN | ui::EF_NUMPAD_KEY}},
 
       // XK_KP_1 (= NumPad 1 with Num Lock), Win modifier.
       // The result should also be "Num Pad 1 with Control + Num Lock
       // modifiers".
       {KeyTestCase::TEST_ALL|KeyTestCase::NUMPAD, ui::ET_KEY_PRESSED,
        {ui::VKEY_NUMPAD1, ui::EF_COMMAND_DOWN | ui::EF_NUMPAD_KEY},
        {ui::VKEY_NUMPAD1, ui::EF_CONTROL_DOWN | ui::EF_NUMPAD_KEY}},
   };
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
-    CheckKeyTestCase(1000 + i, &rewriter, tests[i]);
+    SCOPED_TRACE(i);
+    CheckKeyTestCase(&rewriter, tests[i]);
   }
 }
 
 TEST_F(EventRewriterTest, TestRewriteNumPadKeysOnAppleKeyboard) {
   TestRewriteNumPadKeysOnAppleKeyboard();
 }
 
 TEST_F(EventRewriterTest,
        TestRewriteNumPadKeysOnAppleKeyboardWithDiamondKeyFlag) {
   // Makes sure the num lock works correctly even when Diamond key exists.
   const CommandLine original_cl(*CommandLine::ForCurrentProcess());
   CommandLine::ForCurrentProcess()->AppendSwitchASCII(
       chromeos::switches::kHasChromeOSDiamondKey, "");
 
   TestRewriteNumPadKeysOnAppleKeyboard();
   *CommandLine::ForCurrentProcess() = original_cl;
 }
 
 TEST_F(EventRewriterTest, TestRewriteModifiersNoRemap) {
   TestingPrefServiceSyncable prefs;
   EventRewriter rewriter(NULL);
+  rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard");
   rewriter.set_pref_service_for_testing(&prefs);
 
   KeyTestCase tests[] = {
       // Press Search. Confirm the event is not rewritten.
       {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
        {ui::VKEY_LWIN, ui::EF_NONE},
        {ui::VKEY_LWIN, ui::EF_COMMAND_DOWN}},
 
       // Press left Control. Confirm the event is not rewritten.
       {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
@@ skipping 16 matching lines @@
        {ui::VKEY_MENU, ui::EF_ALT_DOWN}},
 
       // Test KeyRelease event, just in case.
       // Release Search. Confirm the release event is not rewritten.
       {KeyTestCase::TEST_ALL, ui::ET_KEY_RELEASED,
        {ui::VKEY_LWIN, ui::EF_NONE},
        {ui::VKEY_LWIN, ui::EF_NONE}},
   };
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
-    CheckKeyTestCase(1000 + i, &rewriter, tests[i]);
+    SCOPED_TRACE(i);
+    CheckKeyTestCase(&rewriter, tests[i]);
   }
 }
 
 TEST_F(EventRewriterTest, TestRewriteModifiersNoRemapMultipleKeys) {
   TestingPrefServiceSyncable prefs;
   EventRewriter rewriter(NULL);
+  rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard");
   rewriter.set_pref_service_for_testing(&prefs);
 
   KeyTestCase tests[] = {
       // Press Alt with Shift. Confirm the event is not rewritten.
       {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
        {ui::VKEY_MENU, ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN},
        {ui::VKEY_MENU, ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN}},
 
       // Press Search with Caps Lock mask. Confirm the event is not rewritten.
       {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
        {ui::VKEY_LWIN, ui::EF_CAPS_LOCK_DOWN | ui::EF_COMMAND_DOWN},
        {ui::VKEY_LWIN, ui::EF_CAPS_LOCK_DOWN | ui::EF_COMMAND_DOWN}},
 
       // Release Search with Caps Lock mask. Confirm the event is not rewritten.
       {KeyTestCase::TEST_ALL, ui::ET_KEY_RELEASED,
        {ui::VKEY_LWIN, ui::EF_CAPS_LOCK_DOWN},
        {ui::VKEY_LWIN, ui::EF_CAPS_LOCK_DOWN}},
 
       // Press Shift+Ctrl+Alt+Search+A. Confirm the event is not rewritten.
       {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
        {ui::VKEY_B, ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN |
                         ui::EF_COMMAND_DOWN},
        {ui::VKEY_B, ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN |
                         ui::EF_COMMAND_DOWN}},
   };
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
-    CheckKeyTestCase(1000 + i, &rewriter, tests[i]);
+    SCOPED_TRACE(i);
+    CheckKeyTestCase(&rewriter, tests[i]);
   }
 }
 
 TEST_F(EventRewriterTest, TestRewriteModifiersDisableSome) {
   // Disable Search and Control keys.
   TestingPrefServiceSyncable prefs;
   chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
   IntegerPrefMember search;
   search.Init(prefs::kLanguageRemapSearchKeyTo, &prefs);
   search.SetValue(chromeos::input_method::kVoidKey);
   IntegerPrefMember control;
   control.Init(prefs::kLanguageRemapControlKeyTo, &prefs);
   control.SetValue(chromeos::input_method::kVoidKey);
 
   EventRewriter rewriter(NULL);
+  rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard");
   rewriter.set_pref_service_for_testing(&prefs);
 
   KeyTestCase disabled_modifier_tests[] = {
       // Press Alt with Shift. This key press shouldn't be affected by the
       // pref. Confirm the event is not rewritten.
       {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
        {ui::VKEY_MENU, ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN},
        {ui::VKEY_MENU, ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN}},
 
       // Press Search. Confirm the event is now VKEY_UNKNOWN.
@@ skipping 19 matching lines @@
        {ui::VKEY_A, ui::EF_NONE}},
 
       // Press Control+Search+Alt+a. Confirm the event is now VKEY_A only with
       // the Alt modifier.
       {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
        {ui::VKEY_A, ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN},
        {ui::VKEY_A, ui::EF_ALT_DOWN}},
   };
 
   for (size_t i = 0; i < arraysize(disabled_modifier_tests); ++i) {
-    CheckKeyTestCase(1000 + i, &rewriter, disabled_modifier_tests[i]);
+    SCOPED_TRACE(i);
+    CheckKeyTestCase(&rewriter, disabled_modifier_tests[i]);
   }
 
   // Remap Alt to Control.
   IntegerPrefMember alt;
   alt.Init(prefs::kLanguageRemapAltKeyTo, &prefs);
   alt.SetValue(chromeos::input_method::kControlKey);
 
   KeyTestCase tests[] = {
       // Press left Alt. Confirm the event is now VKEY_CONTROL
       // even though the Control key itself is disabled.
       {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
        {ui::VKEY_MENU, ui::EF_ALT_DOWN},
        {ui::VKEY_CONTROL, ui::EF_CONTROL_DOWN}},
 
       // Press Alt+a. Confirm the event is now Control+a even though the Control
       // key itself is disabled.
       {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
        {ui::VKEY_A, ui::EF_ALT_DOWN},
        {ui::VKEY_A, ui::EF_CONTROL_DOWN}},
   };
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
-    CheckKeyTestCase(2000 + i, &rewriter, tests[i]);
+    SCOPED_TRACE(i);
+    CheckKeyTestCase(&rewriter, tests[i]);
   }
 }
 
 TEST_F(EventRewriterTest, TestRewriteModifiersRemapToControl) {
   // Remap Search to Control.
   TestingPrefServiceSyncable prefs;
   chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
   IntegerPrefMember search;
   search.Init(prefs::kLanguageRemapSearchKeyTo, &prefs);
   search.SetValue(chromeos::input_method::kControlKey);
 
   EventRewriter rewriter(NULL);
+  rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard");
   rewriter.set_pref_service_for_testing(&prefs);
 
   KeyTestCase s_tests[] = {
       // Press Search. Confirm the event is now VKEY_CONTROL.
       {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
        {ui::VKEY_LWIN, ui::EF_COMMAND_DOWN},
        {ui::VKEY_CONTROL, ui::EF_CONTROL_DOWN}},
   };
 
   for (size_t i = 0; i < arraysize(s_tests); ++i) {
-    CheckKeyTestCase(1000 + i, &rewriter, s_tests[i]);
+    SCOPED_TRACE(i);
+    CheckKeyTestCase(&rewriter, s_tests[i]);
   }
 
   // Remap Alt to Control too.
   IntegerPrefMember alt;
   alt.Init(prefs::kLanguageRemapAltKeyTo, &prefs);
   alt.SetValue(chromeos::input_method::kControlKey);
 
   KeyTestCase sa_tests[] = {
       // Press Alt. Confirm the event is now VKEY_CONTROL.
       {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
@@ skipping 20 matching lines @@
 
       // Press Shift+Control+Alt+Search+B. Confirm the event is now B with Shift
       // and Control modifiers.
       {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
        {ui::VKEY_B, ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN |
                         ui::EF_COMMAND_DOWN},
        {ui::VKEY_B, ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN}},
   };
 
   for (size_t i = 0; i < arraysize(sa_tests); ++i) {
-    CheckKeyTestCase(2000 + i, &rewriter, sa_tests[i]);
+    SCOPED_TRACE(i);
+    CheckKeyTestCase(&rewriter, sa_tests[i]);
   }
 }
 
 TEST_F(EventRewriterTest, TestRewriteModifiersRemapToEscape) {
   // Remap Search to ESC.
   TestingPrefServiceSyncable prefs;
   chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
   IntegerPrefMember search;
   search.Init(prefs::kLanguageRemapSearchKeyTo, &prefs);
   search.SetValue(chromeos::input_method::kEscapeKey);
 
   EventRewriter rewriter(NULL);
+  rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard");
   rewriter.set_pref_service_for_testing(&prefs);
 
   KeyTestCase tests[] = {// Press Search. Confirm the event is now VKEY_ESCAPE.
                          {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
                           {ui::VKEY_LWIN, ui::EF_COMMAND_DOWN},
                           {ui::VKEY_ESCAPE, ui::EF_NONE}},
   };
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
-    CheckKeyTestCase(1000 + i, &rewriter, tests[i]);
+    SCOPED_TRACE(i);
+    CheckKeyTestCase(&rewriter, tests[i]);
   }
 }
 
 TEST_F(EventRewriterTest, TestRewriteModifiersRemapMany) {
   // Remap Search to Alt.
   TestingPrefServiceSyncable prefs;
   chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
   IntegerPrefMember search;
   search.Init(prefs::kLanguageRemapSearchKeyTo, &prefs);
   search.SetValue(chromeos::input_method::kAltKey);
 
   EventRewriter rewriter(NULL);
+  rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard");
   rewriter.set_pref_service_for_testing(&prefs);
 
   KeyTestCase s2a_tests[] = {
       // Press Search. Confirm the event is now VKEY_MENU.
       {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
        {ui::VKEY_LWIN, ui::EF_COMMAND_DOWN},
        {ui::VKEY_MENU, ui::EF_ALT_DOWN}},
   };
 
   for (size_t i = 0; i < arraysize(s2a_tests); ++i) {
-    CheckKeyTestCase(1000 + i, &rewriter, s2a_tests[i]);
+    SCOPED_TRACE(i);
+    CheckKeyTestCase(&rewriter, s2a_tests[i]);
   }
 
   // Remap Alt to Control.
   IntegerPrefMember alt;
   alt.Init(prefs::kLanguageRemapAltKeyTo, &prefs);
   alt.SetValue(chromeos::input_method::kControlKey);
 
   KeyTestCase a2c_tests[] = {
       // Press left Alt. Confirm the event is now VKEY_CONTROL.
       {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
        {ui::VKEY_MENU, ui::EF_ALT_DOWN},
        {ui::VKEY_CONTROL, ui::EF_CONTROL_DOWN}},
   };
 
   for (size_t i = 0; i < arraysize(a2c_tests); ++i) {
-    CheckKeyTestCase(2000 + i, &rewriter, a2c_tests[i]);
+    SCOPED_TRACE(i);
+    CheckKeyTestCase(&rewriter, a2c_tests[i]);
   }
 
   // Remap Control to Search.
   IntegerPrefMember control;
   control.Init(prefs::kLanguageRemapControlKeyTo, &prefs);
   control.SetValue(chromeos::input_method::kSearchKey);
 
   KeyTestCase c2s_tests[] = {
       // Press left Control. Confirm the event is now VKEY_LWIN.
       {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
@@ skipping 16 matching lines @@
 
       // Press Shift+Control+Alt+Search+B
       {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
        {ui::VKEY_B, ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN |
                         ui::EF_COMMAND_DOWN},
        {ui::VKEY_B, ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN |
                         ui::EF_COMMAND_DOWN}},
   };
 
   for (size_t i = 0; i < arraysize(c2s_tests); ++i) {
-    CheckKeyTestCase(3000 + i, &rewriter, c2s_tests[i]);
+    SCOPED_TRACE(i);
+    CheckKeyTestCase(&rewriter, c2s_tests[i]);
   }
 }
 
 TEST_F(EventRewriterTest, TestRewriteModifiersRemapToCapsLock) {
   // Remap Search to Caps Lock.
   TestingPrefServiceSyncable prefs;
   chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
   IntegerPrefMember search;
   search.Init(prefs::kLanguageRemapSearchKeyTo, &prefs);
   search.SetValue(chromeos::input_method::kCapsLockKey);
 
   chromeos::input_method::FakeImeKeyboard ime_keyboard;
   EventRewriter rewriter(NULL);
+  rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard");
   rewriter.set_pref_service_for_testing(&prefs);
   rewriter.set_ime_keyboard_for_testing(&ime_keyboard);
   EXPECT_FALSE(ime_keyboard.caps_lock_is_enabled_);
 
   // Press Search.
   EXPECT_EQ(
       GetExpectedResultAsString(ui::VKEY_CAPITAL,
                                 ui::EF_CAPS_LOCK_DOWN | ui::EF_MOD3_DOWN,
                                 ui::ET_KEY_PRESSED),
       GetRewrittenEventAsString(
@@ skipping 50 matching lines @@
                 &rewriter, ui::VKEY_CAPITAL, ui::EF_NONE, ui::ET_KEY_RELEASED));
   EXPECT_FALSE(ime_keyboard.caps_lock_is_enabled_);
 }
 
 TEST_F(EventRewriterTest, TestRewriteCapsLock) {
   TestingPrefServiceSyncable prefs;
   chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
 
   chromeos::input_method::FakeImeKeyboard ime_keyboard;
   EventRewriter rewriter(NULL);
+  rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard");
   rewriter.set_pref_service_for_testing(&prefs);
   rewriter.set_ime_keyboard_for_testing(&ime_keyboard);
   EXPECT_FALSE(ime_keyboard.caps_lock_is_enabled_);
 
   // On Chrome OS, CapsLock is mapped to F16 with Mod3Mask.
   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CAPITAL,
                                       ui::EF_CAPS_LOCK_DOWN | ui::EF_MOD3_DOWN,
                                       ui::ET_KEY_PRESSED),
             GetRewrittenEventAsString(
                 &rewriter, ui::VKEY_F16, ui::EF_MOD3_DOWN, ui::ET_KEY_PRESSED));
   EXPECT_TRUE(ime_keyboard.caps_lock_is_enabled_);
 }
 
 TEST_F(EventRewriterTest, TestRewriteDiamondKey) {
   TestingPrefServiceSyncable prefs;
   chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
 
   chromeos::input_method::FakeImeKeyboard ime_keyboard;
   EventRewriter rewriter(NULL);
+  rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard");
   rewriter.set_pref_service_for_testing(&prefs);
   rewriter.set_ime_keyboard_for_testing(&ime_keyboard);
 
   KeyTestCase tests[] = {
       // F15 should work as Ctrl when --has-chromeos-diamond-key is not
       // specified.
       {KeyTestCase::TEST_VKEY,
        ui::ET_KEY_PRESSED,
        {ui::VKEY_F15, ui::EF_NONE},
        {ui::VKEY_CONTROL, ui::EF_CONTROL_DOWN}},
 
       // However, Mod2Mask should not be rewritten to CtrlMask when
       // --has-chromeos-diamond-key is not specified.
       {KeyTestCase::TEST_VKEY,
        ui::ET_KEY_PRESSED,
        {ui::VKEY_A, ui::EF_NONE},
        {ui::VKEY_A, ui::EF_NONE}},
   };
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
-    CheckKeyTestCase(1000 + i, &rewriter, tests[i]);
+    SCOPED_TRACE(i);
+    CheckKeyTestCase(&rewriter, tests[i]);
   }
 }
+
 TEST_F(EventRewriterTest, TestRewriteDiamondKeyWithFlag) {
   const CommandLine original_cl(*CommandLine::ForCurrentProcess());
   CommandLine::ForCurrentProcess()->AppendSwitchASCII(
       chromeos::switches::kHasChromeOSDiamondKey, "");
 
   TestingPrefServiceSyncable prefs;
   chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
 
   chromeos::input_method::FakeImeKeyboard ime_keyboard;
   EventRewriter rewriter(NULL);
+  rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard");
   rewriter.set_pref_service_for_testing(&prefs);
   rewriter.set_ime_keyboard_for_testing(&ime_keyboard);
 
   // By default, F15 should work as Control.
   EXPECT_EQ(GetExpectedResultAsString(
                 ui::VKEY_CONTROL, ui::EF_CONTROL_DOWN, ui::ET_KEY_PRESSED),
             GetRewrittenEventAsString(
                 &rewriter, ui::VKEY_F15, ui::EF_NONE, ui::ET_KEY_PRESSED));
 
   IntegerPrefMember diamond;
@@ skipping 32 matching lines @@
 
 TEST_F(EventRewriterTest, TestRewriteCapsLockToControl) {
   // Remap CapsLock to Control.
   TestingPrefServiceSyncable prefs;
   chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
   IntegerPrefMember control;
   control.Init(prefs::kLanguageRemapCapsLockKeyTo, &prefs);
   control.SetValue(chromeos::input_method::kControlKey);
 
   EventRewriter rewriter(NULL);
+  rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard");
   rewriter.set_pref_service_for_testing(&prefs);
 
   KeyTestCase tests[] = {
       // Press CapsLock+a. Confirm that Mod3Mask is rewritten to ControlMask.
       // On Chrome OS, CapsLock works as a Mod3 modifier.
       {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
        {ui::VKEY_A, ui::EF_MOD3_DOWN},
        {ui::VKEY_A, ui::EF_CONTROL_DOWN}},
 
       // Press Control+CapsLock+a. Confirm that Mod3Mask is rewritten to
       // ControlMask
       {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
        {ui::VKEY_A, ui::EF_CONTROL_DOWN | ui::EF_MOD3_DOWN},
        {ui::VKEY_A, ui::EF_CONTROL_DOWN}},
 
       // Press Alt+CapsLock+a. Confirm that Mod3Mask is rewritten to
       // ControlMask.
       {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
        {ui::VKEY_A, ui::EF_ALT_DOWN | ui::EF_MOD3_DOWN},
        {ui::VKEY_A, ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN}},
   };
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
-    CheckKeyTestCase(1000 + i, &rewriter, tests[i]);
+    SCOPED_TRACE(i);
+    CheckKeyTestCase(&rewriter, tests[i]);
   }
 }
 
 TEST_F(EventRewriterTest, TestRewriteCapsLockMod3InUse) {
   // Remap CapsLock to Control.
   TestingPrefServiceSyncable prefs;
   chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
   IntegerPrefMember control;
   control.Init(prefs::kLanguageRemapCapsLockKeyTo, &prefs);
   control.SetValue(chromeos::input_method::kControlKey);
 
   EventRewriter rewriter(NULL);
+  rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard");
   rewriter.set_pref_service_for_testing(&prefs);
   input_method_manager_mock_->set_mod3_used(true);
 
   // Press CapsLock+a. Confirm that Mod3Mask is NOT rewritten to ControlMask
   // when Mod3Mask is already in use by the current XKB layout.
   EXPECT_EQ(
       GetExpectedResultAsString(ui::VKEY_A, ui::EF_NONE, ui::ET_KEY_PRESSED),
       GetRewrittenEventAsString(
           &rewriter, ui::VKEY_A, ui::EF_NONE, ui::ET_KEY_PRESSED));
 
   input_method_manager_mock_->set_mod3_used(false);
 }
 
 TEST_F(EventRewriterTest, TestRewriteExtendedKeys) {
   TestingPrefServiceSyncable prefs;
   chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
   EventRewriter rewriter(NULL);
-  rewriter.DeviceAddedForTesting(0, "PC Keyboard");
-  rewriter.set_last_device_id_for_testing(0);
+  rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard");
+  rewriter.set_last_keyboard_device_id_for_testing(kKeyboardDeviceId);
   rewriter.set_pref_service_for_testing(&prefs);
 
   KeyTestCase tests[] = {
       // Alt+Backspace -> Delete
       {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
        {ui::VKEY_BACK, ui::EF_ALT_DOWN},
        {ui::VKEY_DELETE, ui::EF_NONE}},
       // Control+Alt+Backspace -> Control+Delete
       {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
        {ui::VKEY_BACK, ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN},
@@ skipping 79 matching lines @@
       // Search+Period -> Insert
       {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
        {ui::VKEY_OEM_PERIOD, ui::EF_COMMAND_DOWN},
        {ui::VKEY_INSERT, ui::EF_NONE}},
       // Control+Search+Period -> Control+Insert
       {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
        {ui::VKEY_OEM_PERIOD, ui::EF_COMMAND_DOWN | ui::EF_CONTROL_DOWN},
        {ui::VKEY_INSERT, ui::EF_CONTROL_DOWN}}};
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
-    CheckKeyTestCase(1000 + i, &rewriter, tests[i]);
+    SCOPED_TRACE(i);
+    CheckKeyTestCase(&rewriter, tests[i]);
   }
 }
 
 TEST_F(EventRewriterTest, TestRewriteFunctionKeys) {
   TestingPrefServiceSyncable prefs;
   chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
   EventRewriter rewriter(NULL);
+  rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard");
   rewriter.set_pref_service_for_testing(&prefs);
 
   FunctionKeyTestCase tests[] = {
       // F1 -> Back
       {ui::ET_KEY_PRESSED,
        {ui::VKEY_F1, ui::EF_NONE},
        {ui::VKEY_BROWSER_BACK, ui::EF_NONE},
        {ui::VKEY_BROWSER_BACK, ui::EF_FUNCTION_KEY}},
       {ui::ET_KEY_PRESSED,
        {ui::VKEY_F1, ui::EF_CONTROL_DOWN},
@@ skipping 293 matching lines @@
        {ui::VKEY_F11, ui::EF_COMMAND_DOWN},
        {ui::VKEY_F11, ui::EF_NONE},
        {ui::VKEY_F11, ui::EF_FUNCTION_KEY}},
       {ui::ET_KEY_PRESSED,
        {ui::VKEY_F12, ui::EF_COMMAND_DOWN},
        {ui::VKEY_F12, ui::EF_NONE},
        {ui::VKEY_F12, ui::EF_FUNCTION_KEY}},
   };
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
-    CheckFunctionKeyTestCase(1000 + i, &rewriter, tests[i]);
+    SCOPED_TRACE(i);
+    CheckFunctionKeyTestCase(&rewriter, tests[i]);
   }
 }
 
 TEST_F(EventRewriterTest, TestRewriteExtendedKeysWithSearchRemapped) {
   const CommandLine original_cl(*CommandLine::ForCurrentProcess());
 
   // Remap Search to Control.
   TestingPrefServiceSyncable prefs;
   chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
   IntegerPrefMember search;
   search.Init(prefs::kLanguageRemapSearchKeyTo, &prefs);
   search.SetValue(chromeos::input_method::kControlKey);
 
   EventRewriter rewriter(NULL);
+  rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard");
   rewriter.set_pref_service_for_testing(&prefs);
 
   CommandLine::ForCurrentProcess()->AppendSwitchASCII(
       chromeos::switches::kHasChromeOSKeyboard, "");
 
   KeyTestCase tests[] = {
       // Alt+Search+Down -> End
       {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
        {ui::VKEY_DOWN, ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN},
        {ui::VKEY_END, ui::EF_NONE}},
 
       // Shift+Alt+Search+Down -> Shift+End
       {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
        {ui::VKEY_DOWN,
         ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN},
        {ui::VKEY_END, ui::EF_SHIFT_DOWN}},
   };
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
-    CheckKeyTestCase(1000 + i, &rewriter, tests[i]);
+    SCOPED_TRACE(i);
+    CheckKeyTestCase(&rewriter, tests[i]);
   }
 
   *CommandLine::ForCurrentProcess() = original_cl;
 }
 
 TEST_F(EventRewriterTest, TestRewriteKeyEventSentByXSendEvent) {
 #if defined(USE_X11)
   // TODO(kpschoedel): pending alternative to xevent.xany.send_event
   // Remap Control to Alt.
   TestingPrefServiceSyncable prefs;
   chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
   IntegerPrefMember control;
   control.Init(prefs::kLanguageRemapControlKeyTo, &prefs);
   control.SetValue(chromeos::input_method::kAltKey);
 
   EventRewriter rewriter(NULL);
+  rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard");
   rewriter.set_pref_service_for_testing(&prefs);
 
   // Send left control press.
   std::string rewritten_event;
   {
     ui::ScopedXI2Event xev;
     xev.InitKeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_CONTROL, 0);
     XEvent* xevent = xev;
     xevent->xkey.keycode = XKeysymToKeycode(gfx::GetXDisplay(), XK_Control_L);
     xevent->xkey.send_event = True;  // XSendEvent() always does this.
@@ skipping 10 matching lines @@
 
 TEST_F(EventRewriterTest, TestRewriteNonNativeEvent) {
   // Remap Control to Alt.
   TestingPrefServiceSyncable prefs;
   chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
   IntegerPrefMember control;
   control.Init(prefs::kLanguageRemapControlKeyTo, &prefs);
   control.SetValue(chromeos::input_method::kAltKey);
 
   EventRewriter rewriter(NULL);
+  rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard");
   rewriter.set_pref_service_for_testing(&prefs);
 
   const int kTouchId = 2;
   gfx::Point location(0, 0);
   ui::TouchEvent press(
       ui::ET_TOUCH_PRESSED, location, kTouchId, base::TimeDelta());
   press.set_flags(ui::EF_CONTROL_DOWN);
 
   scoped_ptr<ui::Event> new_event;
   rewriter.RewriteEvent(press, &new_event);
@@ skipping 174 matching lines @@
   ui::TouchFactory::GetInstance()->SetPointerDeviceForTest(device_list);
 
   // Remap Control to Alt.
   TestingPrefServiceSyncable prefs;
   chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
   IntegerPrefMember control;
   control.Init(prefs::kLanguageRemapControlKeyTo, &prefs);
   control.SetValue(chromeos::input_method::kAltKey);
 
   EventRewriter rewriter(NULL);
+  rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard");
   rewriter.set_pref_service_for_testing(&prefs);
 
   // Check that Control + Left Button is converted (via Alt + Left Button)
   // to Right Button.
   ui::ScopedXI2Event xev;
   xev.InitGenericButtonEvent(10,
                              ui::ET_MOUSE_PRESSED,
                              gfx::Point(),
                              ui::EF_LEFT_MOUSE_BUTTON | ui::EF_CONTROL_DOWN);
   ui::MouseEvent press(xev);
   // Sanity check.
   EXPECT_EQ(ui::ET_MOUSE_PRESSED, press.type());
   EXPECT_EQ(ui::EF_LEFT_MOUSE_BUTTON | ui::EF_CONTROL_DOWN, press.flags());
-  int flags = RewriteMouseEvent(&rewriter, press);
-  EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & flags);
-  EXPECT_FALSE(ui::EF_CONTROL_DOWN & flags);
-  EXPECT_FALSE(ui::EF_ALT_DOWN & flags);
+  scoped_ptr<ui::Event> new_event;
+  const ui::MouseEvent* result =
+      RewriteMouseButtonEvent(&rewriter, press, &new_event);
+  EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & result->flags());
+  EXPECT_FALSE(ui::EF_LEFT_MOUSE_BUTTON & result->flags());
+  EXPECT_FALSE(ui::EF_CONTROL_DOWN & result->flags());
+  EXPECT_FALSE(ui::EF_ALT_DOWN & result->flags());
+  EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & result->flags());
 }
 
-
 TEST_F(EventRewriterTest, DontRewriteIfNotRewritten) {
-#if defined(USE_X11)
   // TODO(kpschoedel): pending changes for crbug.com/360377
   // to |chromeos::EventRewriter::RewriteLocatedEvent()
   std::vector<unsigned int> device_list;
   device_list.push_back(10);
   device_list.push_back(11);
   ui::TouchFactory::GetInstance()->SetPointerDeviceForTest(device_list);
   TestingPrefServiceSyncable prefs;
   EventRewriter rewriter(NULL);
   rewriter.set_pref_service_for_testing(&prefs);
   const int kLeftAndAltFlag = ui::EF_LEFT_MOUSE_BUTTON | ui::EF_ALT_DOWN;
+
+  // Test Alt + Left click.
+  {
+    ui::MouseEvent press(ui::ET_MOUSE_PRESSED,
+                         gfx::Point(),
+                         gfx::Point(),
+                         kLeftAndAltFlag,
+                         ui::EF_LEFT_MOUSE_BUTTON);
+    ui::EventTestApi test_press(&press);
+    test_press.set_source_device_id(10);
+    // Sanity check.
+    EXPECT_EQ(ui::ET_MOUSE_PRESSED, press.type());
+    EXPECT_EQ(kLeftAndAltFlag, press.flags());
+    scoped_ptr<ui::Event> new_event;
+    const ui::MouseEvent* result =
+        RewriteMouseButtonEvent(&rewriter, press, &new_event);
+    EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & result->flags());
+    EXPECT_FALSE(kLeftAndAltFlag & result->flags());
+    EXPECT_EQ(ui::EF_RIGHT_MOUSE_BUTTON, result->changed_button_flags());
+  }
+  {
+    ui::MouseEvent release(ui::ET_MOUSE_RELEASED,
+                           gfx::Point(),
+                           gfx::Point(),
+                           kLeftAndAltFlag,
+                           ui::EF_LEFT_MOUSE_BUTTON);
+    ui::EventTestApi test_release(&release);
+    test_release.set_source_device_id(10);
+    scoped_ptr<ui::Event> new_event;
+    const ui::MouseEvent* result =
+        RewriteMouseButtonEvent(&rewriter, release, &new_event);
+    EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & result->flags());
+    EXPECT_FALSE(kLeftAndAltFlag & result->flags());
+    EXPECT_EQ(ui::EF_RIGHT_MOUSE_BUTTON, result->changed_button_flags());
+  }
+#if defined(USE_X11)
+  // Test Alt + Left click, using XI2 native events.
   {
     ui::ScopedXI2Event xev;
     xev.InitGenericButtonEvent(
         10, ui::ET_MOUSE_PRESSED, gfx::Point(), kLeftAndAltFlag);
     ui::MouseEvent press(xev);
     // Sanity check.
     EXPECT_EQ(ui::ET_MOUSE_PRESSED, press.type());
     EXPECT_EQ(kLeftAndAltFlag, press.flags());
-    int flags = RewriteMouseEvent(&rewriter, press);
-    EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & flags);
+    scoped_ptr<ui::Event> new_event;
+    const ui::MouseEvent* result =
+        RewriteMouseButtonEvent(&rewriter, press, &new_event);
+    EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & result->flags());
+    EXPECT_FALSE(kLeftAndAltFlag & result->flags());
+    EXPECT_EQ(ui::EF_RIGHT_MOUSE_BUTTON, result->changed_button_flags());
   }
   {
     ui::ScopedXI2Event xev;
     xev.InitGenericButtonEvent(
         10, ui::ET_MOUSE_RELEASED, gfx::Point(), kLeftAndAltFlag);
     ui::MouseEvent release(xev);
-    int flags = RewriteMouseEvent(&rewriter, release);
-    EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & flags);
+    scoped_ptr<ui::Event> new_event;
+    const ui::MouseEvent* result =
+        RewriteMouseButtonEvent(&rewriter, release, &new_event);
+    EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & result->flags());
+    EXPECT_FALSE(kLeftAndAltFlag & result->flags());
+    EXPECT_EQ(ui::EF_RIGHT_MOUSE_BUTTON, result->changed_button_flags());
   }
+#endif
 
   // No ALT in frst click.
   {
+    ui::MouseEvent press(ui::ET_MOUSE_PRESSED,
+                         gfx::Point(),
+                         gfx::Point(),
+                         ui::EF_LEFT_MOUSE_BUTTON,
+                         ui::EF_LEFT_MOUSE_BUTTON);
+    ui::EventTestApi test_press(&press);
+    test_press.set_source_device_id(10);
+    scoped_ptr<ui::Event> new_event;
+    const ui::MouseEvent* result =
+        RewriteMouseButtonEvent(&rewriter, press, &new_event);
+    EXPECT_TRUE(ui::EF_LEFT_MOUSE_BUTTON & result->flags());
+    EXPECT_EQ(ui::EF_LEFT_MOUSE_BUTTON, result->changed_button_flags());
+  }
+  {
+    ui::MouseEvent release(ui::ET_MOUSE_RELEASED,
+                           gfx::Point(),
+                           gfx::Point(),
+                           kLeftAndAltFlag,
+                           ui::EF_LEFT_MOUSE_BUTTON);
+    ui::EventTestApi test_release(&release);
+    test_release.set_source_device_id(10);
+    scoped_ptr<ui::Event> new_event;
+    const ui::MouseEvent* result =
+        RewriteMouseButtonEvent(&rewriter, release, &new_event);
+    EXPECT_TRUE((ui::EF_LEFT_MOUSE_BUTTON | ui::EF_ALT_DOWN) & result->flags());
+    EXPECT_EQ(ui::EF_LEFT_MOUSE_BUTTON, result->changed_button_flags());
+  }
+#if defined(USE_X11)
+  // No ALT in frst click, using XI2 native events.
+  {
     ui::ScopedXI2Event xev;
     xev.InitGenericButtonEvent(
         10, ui::ET_MOUSE_PRESSED, gfx::Point(), ui::EF_LEFT_MOUSE_BUTTON);
     ui::MouseEvent press(xev);
-    int flags = RewriteMouseEvent(&rewriter, press);
-    EXPECT_TRUE(ui::EF_LEFT_MOUSE_BUTTON & flags);
+    scoped_ptr<ui::Event> new_event;
+    const ui::MouseEvent* result =
+        RewriteMouseButtonEvent(&rewriter, press, &new_event);
+    EXPECT_TRUE(ui::EF_LEFT_MOUSE_BUTTON & result->flags());
+    EXPECT_EQ(ui::EF_LEFT_MOUSE_BUTTON, result->changed_button_flags());
   }
   {
     ui::ScopedXI2Event xev;
     xev.InitGenericButtonEvent(
         10, ui::ET_MOUSE_RELEASED, gfx::Point(), kLeftAndAltFlag);
     ui::MouseEvent release(xev);
-    int flags = RewriteMouseEvent(&rewriter, release);
-    EXPECT_TRUE((ui::EF_LEFT_MOUSE_BUTTON | ui::EF_ALT_DOWN) & flags);
+    scoped_ptr<ui::Event> new_event;
+    const ui::MouseEvent* result =
+        RewriteMouseButtonEvent(&rewriter, release, &new_event);
+    EXPECT_TRUE((ui::EF_LEFT_MOUSE_BUTTON | ui::EF_ALT_DOWN) & result->flags());
+    EXPECT_EQ(ui::EF_LEFT_MOUSE_BUTTON, result->changed_button_flags());
   }
+#endif
 
   // ALT on different device.
   {
+    ui::MouseEvent press(ui::ET_MOUSE_PRESSED,
+                         gfx::Point(),
+                         gfx::Point(),
+                         kLeftAndAltFlag,
+                         ui::EF_LEFT_MOUSE_BUTTON);
+    ui::EventTestApi test_press(&press);
+    test_press.set_source_device_id(11);
+    scoped_ptr<ui::Event> new_event;
+    const ui::MouseEvent* result =
+        RewriteMouseButtonEvent(&rewriter, press, &new_event);
+    EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & result->flags());
+    EXPECT_FALSE(kLeftAndAltFlag & result->flags());
+    EXPECT_EQ(ui::EF_RIGHT_MOUSE_BUTTON, result->changed_button_flags());
+  }
+  {
+    ui::MouseEvent release(ui::ET_MOUSE_RELEASED,
+                           gfx::Point(),
+                           gfx::Point(),
+                           kLeftAndAltFlag,
+                           ui::EF_LEFT_MOUSE_BUTTON);
+    ui::EventTestApi test_release(&release);
+    test_release.set_source_device_id(10);
+    scoped_ptr<ui::Event> new_event;
+    const ui::MouseEvent* result =
+        RewriteMouseButtonEvent(&rewriter, release, &new_event);
+    EXPECT_TRUE((ui::EF_LEFT_MOUSE_BUTTON | ui::EF_ALT_DOWN) & result->flags());
+    EXPECT_EQ(ui::EF_LEFT_MOUSE_BUTTON, result->changed_button_flags());
+  }
+  {
+    ui::MouseEvent release(ui::ET_MOUSE_RELEASED,
+                           gfx::Point(),
+                           gfx::Point(),
+                           kLeftAndAltFlag,
+                           ui::EF_LEFT_MOUSE_BUTTON);
+    ui::EventTestApi test_release(&release);
+    test_release.set_source_device_id(11);
+    scoped_ptr<ui::Event> new_event;
+    const ui::MouseEvent* result =
+        RewriteMouseButtonEvent(&rewriter, release, &new_event);
+    EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & result->flags());
+    EXPECT_FALSE(kLeftAndAltFlag & result->flags());
+    EXPECT_EQ(ui::EF_RIGHT_MOUSE_BUTTON, result->changed_button_flags());
+  }
+#if defined(USE_X11)
+  // ALT on different device, using XI2 native events.
+  {
     ui::ScopedXI2Event xev;
     xev.InitGenericButtonEvent(
         11, ui::ET_MOUSE_PRESSED, gfx::Point(), kLeftAndAltFlag);
     ui::MouseEvent press(xev);
-    int flags = RewriteMouseEvent(&rewriter, press);
-    EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & flags);
+    scoped_ptr<ui::Event> new_event;
+    const ui::MouseEvent* result =
+        RewriteMouseButtonEvent(&rewriter, press, &new_event);
+    EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & result->flags());
+    EXPECT_FALSE(kLeftAndAltFlag & result->flags());
+    EXPECT_EQ(ui::EF_RIGHT_MOUSE_BUTTON, result->changed_button_flags());
   }
   {
     ui::ScopedXI2Event xev;
     xev.InitGenericButtonEvent(
         10, ui::ET_MOUSE_RELEASED, gfx::Point(), kLeftAndAltFlag);
     ui::MouseEvent release(xev);
-    int flags = RewriteMouseEvent(&rewriter, release);
-    EXPECT_TRUE((ui::EF_LEFT_MOUSE_BUTTON | ui::EF_ALT_DOWN) & flags);
+    scoped_ptr<ui::Event> new_event;
+    const ui::MouseEvent* result =
+        RewriteMouseButtonEvent(&rewriter, release, &new_event);
+    EXPECT_TRUE((ui::EF_LEFT_MOUSE_BUTTON | ui::EF_ALT_DOWN) & result->flags());
+    EXPECT_EQ(ui::EF_LEFT_MOUSE_BUTTON, result->changed_button_flags());
   }
   {
     ui::ScopedXI2Event xev;
     xev.InitGenericButtonEvent(
         11, ui::ET_MOUSE_RELEASED, gfx::Point(), kLeftAndAltFlag);
     ui::MouseEvent release(xev);
-    int flags = RewriteMouseEvent(&rewriter, release);
-    EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & flags);
+    scoped_ptr<ui::Event> new_event;
+    const ui::MouseEvent* result =
+        RewriteMouseButtonEvent(&rewriter, release, &new_event);
+    EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & result->flags());
+    EXPECT_FALSE(kLeftAndAltFlag & result->flags());
+    EXPECT_EQ(ui::EF_RIGHT_MOUSE_BUTTON, result->changed_button_flags());
   }
 #endif
 }
 
 TEST_F(EventRewriterAshTest, StickyKeyEventDispatchImpl) {
   // Test the actual key event dispatch implementation.
   ScopedVector<ui::Event> events;
 
   SendActivateStickyKeyPattern(ui::VKEY_CONTROL);
   PopEvents(&events);
@@ skipping 277 matching lines @@
   EXPECT_FALSE(overlay_->GetModifierVisible(ui::EF_ALTGR_DOWN));
   EXPECT_TRUE(overlay_->GetModifierVisible(ui::EF_MOD3_DOWN));
 
   // Turn off AltGr and Mod3.
   sticky_keys_controller_->SetModifiersEnabled(false, false);
   EXPECT_FALSE(overlay_->GetModifierVisible(ui::EF_ALTGR_DOWN));
   EXPECT_FALSE(overlay_->GetModifierVisible(ui::EF_MOD3_DOWN));
 }
 
 }  // namespace chromeos