| Index: chrome/browser/chromeos/events/event_rewriter_unittest.cc
 | 
| diff --git a/chrome/browser/chromeos/events/event_rewriter_unittest.cc b/chrome/browser/chromeos/events/event_rewriter_unittest.cc
 | 
| index 460d8e61e8e231a91ac2ce026bf2c5ef203045e2..e3998fcc4f85c1d6650de8c065271114de26fb14 100644
 | 
| --- a/chrome/browser/chromeos/events/event_rewriter_unittest.cc
 | 
| +++ b/chrome/browser/chromeos/events/event_rewriter_unittest.cc
 | 
| @@ -2,8 +2,6 @@
 | 
|  // 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/common/wm/window_state.h"
 | 
| @@ -16,6 +14,7 @@
 | 
|  #include "base/macros.h"
 | 
|  #include "base/memory/ptr_util.h"
 | 
|  #include "base/strings/stringprintf.h"
 | 
| +#include "chrome/browser/chromeos/events/event_rewriter_delegate_impl.h"
 | 
|  #include "chrome/browser/chromeos/input_method/input_method_configuration.h"
 | 
|  #include "chrome/browser/chromeos/input_method/mock_input_method_manager_impl.h"
 | 
|  #include "chrome/browser/chromeos/login/users/fake_chrome_user_manager.h"
 | 
| @@ -29,6 +28,8 @@
 | 
|  #include "ui/aura/window.h"
 | 
|  #include "ui/aura/window_tree_host.h"
 | 
|  #include "ui/base/ime/chromeos/fake_ime_keyboard.h"
 | 
| +#include "ui/chromeos/events/event_rewriter_chromeos.h"
 | 
| +#include "ui/chromeos/events/pref_names.h"
 | 
|  #include "ui/events/event.h"
 | 
|  #include "ui/events/event_rewriter.h"
 | 
|  #include "ui/events/event_utils.h"
 | 
| @@ -72,12 +73,13 @@ std::string GetKeyEventAsString(const ui::KeyEvent& keyevent) {
 | 
|                                     keyevent.GetDomKey());
 | 
|  }
 | 
|  
 | 
| -std::string GetRewrittenEventAsString(chromeos::EventRewriter* rewriter,
 | 
| -                                      ui::EventType ui_type,
 | 
| -                                      ui::KeyboardCode ui_keycode,
 | 
| -                                      ui::DomCode code,
 | 
| -                                      int ui_flags,  // ui::EventFlags
 | 
| -                                      ui::DomKey key) {
 | 
| +std::string GetRewrittenEventAsString(
 | 
| +    const std::unique_ptr<ui::EventRewriterChromeOS>& rewriter,
 | 
| +    ui::EventType ui_type,
 | 
| +    ui::KeyboardCode ui_keycode,
 | 
| +    ui::DomCode code,
 | 
| +    int ui_flags,  // ui::EventFlags
 | 
| +    ui::DomKey key) {
 | 
|    const ui::KeyEvent event(ui_type, ui_keycode, code, ui_flags, key,
 | 
|                             ui::EventTimeForNow());
 | 
|    std::unique_ptr<ui::Event> new_event;
 | 
| @@ -105,8 +107,9 @@ std::string GetTestCaseAsString(ui::EventType ui_type,
 | 
|  }
 | 
|  
 | 
|  // Tests a single stateless key rewrite operation.
 | 
| -void CheckKeyTestCase(chromeos::EventRewriter* rewriter,
 | 
| -                      const KeyTestCase& test) {
 | 
| +void CheckKeyTestCase(
 | 
| +    const std::unique_ptr<ui::EventRewriterChromeOS>& rewriter,
 | 
| +    const KeyTestCase& test) {
 | 
|    SCOPED_TRACE("\nSource:    " + GetTestCaseAsString(test.type, test.input));
 | 
|    std::string expected = GetTestCaseAsString(test.type, test.expected);
 | 
|    EXPECT_EQ(expected, GetRewrittenEventAsString(
 | 
| @@ -129,7 +132,10 @@ class EventRewriterTest : public ash::test::AshTestBase {
 | 
|      input_method_manager_mock_ = new input_method::MockInputMethodManagerImpl;
 | 
|      chromeos::input_method::InitializeForTesting(
 | 
|          input_method_manager_mock_);  // pass ownership
 | 
| -
 | 
| +    delegate_ = base::MakeUnique<EventRewriterDelegateImpl>();
 | 
| +    delegate_->set_pref_service_for_testing(prefs());
 | 
| +    rewriter_ =
 | 
| +        base::MakeUnique<ui::EventRewriterChromeOS>(delegate_.get(), nullptr);
 | 
|      AshTestBase::SetUp();
 | 
|    }
 | 
|  
 | 
| @@ -144,25 +150,27 @@ class EventRewriterTest : public ash::test::AshTestBase {
 | 
|    void TestRewriteNumPadKeysOnAppleKeyboard();
 | 
|  
 | 
|    const ui::MouseEvent* RewriteMouseButtonEvent(
 | 
| -      chromeos::EventRewriter* rewriter,
 | 
|        const ui::MouseEvent& event,
 | 
|        std::unique_ptr<ui::Event>* new_event) {
 | 
| -    rewriter->RewriteMouseButtonEventForTesting(event, new_event);
 | 
| +    rewriter_->RewriteMouseButtonEventForTesting(event, new_event);
 | 
|      return *new_event ? new_event->get()->AsMouseEvent() : &event;
 | 
|    }
 | 
|  
 | 
| +  sync_preferences::TestingPrefServiceSyncable* prefs() { return &prefs_; }
 | 
| +
 | 
|    FakeChromeUserManager* fake_user_manager_;  // Not owned.
 | 
|    ScopedUserManagerEnabler user_manager_enabler_;
 | 
|    input_method::MockInputMethodManagerImpl* input_method_manager_mock_;
 | 
| +
 | 
| +  sync_preferences::TestingPrefServiceSyncable prefs_;
 | 
| +  std::unique_ptr<EventRewriterDelegateImpl> delegate_;
 | 
| +  std::unique_ptr<ui::EventRewriterChromeOS> rewriter_;
 | 
|  };
 | 
|  
 | 
|  TEST_F(EventRewriterTest, TestRewriteCommandToControl) {
 | 
|    // First, test with a PC keyboard.
 | 
| -  sync_preferences::TestingPrefServiceSyncable prefs;
 | 
| -  EventRewriter rewriter(NULL);
 | 
| -  rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard");
 | 
| -  rewriter.set_last_keyboard_device_id_for_testing(kKeyboardDeviceId);
 | 
| -  rewriter.set_pref_service_for_testing(&prefs);
 | 
| +  rewriter_->KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard");
 | 
| +  rewriter_->set_last_keyboard_device_id_for_testing(kKeyboardDeviceId);
 | 
|  
 | 
|    KeyTestCase pc_keyboard_tests[] = {
 | 
|        // VKEY_A, Alt modifier.
 | 
| @@ -201,13 +209,12 @@ TEST_F(EventRewriterTest, TestRewriteCommandToControl) {
 | 
|          ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN, ui::DomKey::META}},
 | 
|    };
 | 
|  
 | 
| -  for (const auto& test : pc_keyboard_tests) {
 | 
| -    CheckKeyTestCase(&rewriter, test);
 | 
| -  }
 | 
| +  for (const auto& test : pc_keyboard_tests)
 | 
| +    CheckKeyTestCase(rewriter_, test);
 | 
|  
 | 
|    // An Apple keyboard reusing the ID, zero.
 | 
| -  rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "Apple Keyboard");
 | 
| -  rewriter.set_last_keyboard_device_id_for_testing(kKeyboardDeviceId);
 | 
| +  rewriter_->KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "Apple Keyboard");
 | 
| +  rewriter_->set_last_keyboard_device_id_for_testing(kKeyboardDeviceId);
 | 
|  
 | 
|    KeyTestCase apple_keyboard_tests[] = {
 | 
|        // VKEY_A, Alt modifier.
 | 
| @@ -246,24 +253,20 @@ TEST_F(EventRewriterTest, TestRewriteCommandToControl) {
 | 
|          ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN, ui::DomKey::CONTROL}},
 | 
|    };
 | 
|  
 | 
| -  for (const auto& test : apple_keyboard_tests) {
 | 
| -    CheckKeyTestCase(&rewriter, test);
 | 
| -  }
 | 
| +  for (const auto& test : apple_keyboard_tests)
 | 
| +    CheckKeyTestCase(rewriter_, test);
 | 
|  }
 | 
|  
 | 
|  // For crbug.com/133896.
 | 
|  TEST_F(EventRewriterTest, TestRewriteCommandToControlWithControlRemapped) {
 | 
|    // Remap Control to Alt.
 | 
| -  sync_preferences::TestingPrefServiceSyncable prefs;
 | 
| -  chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
 | 
| +  chromeos::Preferences::RegisterProfilePrefs(prefs()->registry());
 | 
|    IntegerPrefMember control;
 | 
| -  control.Init(prefs::kLanguageRemapControlKeyTo, &prefs);
 | 
| +  control.Init(prefs::kLanguageRemapControlKeyTo, prefs());
 | 
|    control.SetValue(chromeos::input_method::kAltKey);
 | 
|  
 | 
| -  EventRewriter rewriter(NULL);
 | 
| -  rewriter.set_pref_service_for_testing(&prefs);
 | 
| -  rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard");
 | 
| -  rewriter.set_last_keyboard_device_id_for_testing(kKeyboardDeviceId);
 | 
| +  rewriter_->KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard");
 | 
| +  rewriter_->set_last_keyboard_device_id_for_testing(kKeyboardDeviceId);
 | 
|  
 | 
|    KeyTestCase pc_keyboard_tests[] = {
 | 
|        // Control should be remapped to Alt.
 | 
| @@ -274,13 +277,12 @@ TEST_F(EventRewriterTest, TestRewriteCommandToControlWithControlRemapped) {
 | 
|          ui::DomKey::ALT}},
 | 
|    };
 | 
|  
 | 
| -  for (const auto& test : pc_keyboard_tests) {
 | 
| -    CheckKeyTestCase(&rewriter, test);
 | 
| -  }
 | 
| +  for (const auto& test : pc_keyboard_tests)
 | 
| +    CheckKeyTestCase(rewriter_, test);
 | 
|  
 | 
|    // An Apple keyboard reusing the ID, zero.
 | 
| -  rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "Apple Keyboard");
 | 
| -  rewriter.set_last_keyboard_device_id_for_testing(kKeyboardDeviceId);
 | 
| +  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
 | 
| @@ -300,17 +302,13 @@ TEST_F(EventRewriterTest, TestRewriteCommandToControlWithControlRemapped) {
 | 
|          ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN, ui::DomKey::CONTROL}},
 | 
|    };
 | 
|  
 | 
| -  for (const auto& test : apple_keyboard_tests) {
 | 
| -    CheckKeyTestCase(&rewriter, test);
 | 
| -  }
 | 
| +  for (const auto& test : apple_keyboard_tests)
 | 
| +    CheckKeyTestCase(rewriter_, test);
 | 
|  }
 | 
|  
 | 
|  void EventRewriterTest::TestRewriteNumPadKeys() {
 | 
| -  sync_preferences::TestingPrefServiceSyncable prefs;
 | 
| -  EventRewriter rewriter(NULL);
 | 
| -  rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard");
 | 
| -  rewriter.set_last_keyboard_device_id_for_testing(kKeyboardDeviceId);
 | 
| -  rewriter.set_pref_service_for_testing(&prefs);
 | 
| +  rewriter_->KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard");
 | 
| +  rewriter_->set_last_keyboard_device_id_for_testing(kKeyboardDeviceId);
 | 
|  
 | 
|    KeyTestCase tests[] = {
 | 
|        // XK_KP_Insert (= NumPad 0 without Num Lock), no modifier.
 | 
| @@ -477,9 +475,8 @@ void EventRewriterTest::TestRewriteNumPadKeys() {
 | 
|          ui::DomKey::Constant<'9'>::Character}},
 | 
|    };
 | 
|  
 | 
| -  for (const auto& test : tests) {
 | 
| -    CheckKeyTestCase(&rewriter, test);
 | 
| -  }
 | 
| +  for (const auto& test : tests)
 | 
| +    CheckKeyTestCase(rewriter_, test);
 | 
|  }
 | 
|  
 | 
|  TEST_F(EventRewriterTest, TestRewriteNumPadKeys) {
 | 
| @@ -495,11 +492,8 @@ TEST_F(EventRewriterTest, TestRewriteNumPadKeysWithDiamondKeyFlag) {
 | 
|  
 | 
|  // Tests if the rewriter can handle a Command + Num Pad event.
 | 
|  void EventRewriterTest::TestRewriteNumPadKeysOnAppleKeyboard() {
 | 
| -  sync_preferences::TestingPrefServiceSyncable prefs;
 | 
| -  EventRewriter rewriter(NULL);
 | 
| -  rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "Apple Keyboard");
 | 
| -  rewriter.set_last_keyboard_device_id_for_testing(kKeyboardDeviceId);
 | 
| -  rewriter.set_pref_service_for_testing(&prefs);
 | 
| +  rewriter_->KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "Apple Keyboard");
 | 
| +  rewriter_->set_last_keyboard_device_id_for_testing(kKeyboardDeviceId);
 | 
|  
 | 
|    KeyTestCase tests[] = {
 | 
|        // XK_KP_End (= NumPad 1 without Num Lock), Win modifier.
 | 
| @@ -519,9 +513,8 @@ void EventRewriterTest::TestRewriteNumPadKeysOnAppleKeyboard() {
 | 
|         {ui::VKEY_NUMPAD1, ui::DomCode::NUMPAD1, ui::EF_CONTROL_DOWN,
 | 
|          ui::DomKey::Constant<'1'>::Character}}};
 | 
|  
 | 
| -  for (const auto& test : tests) {
 | 
| -    CheckKeyTestCase(&rewriter, test);
 | 
| -  }
 | 
| +  for (const auto& test : tests)
 | 
| +    CheckKeyTestCase(rewriter_, test);
 | 
|  }
 | 
|  
 | 
|  TEST_F(EventRewriterTest, TestRewriteNumPadKeysOnAppleKeyboard) {
 | 
| @@ -540,10 +533,7 @@ TEST_F(EventRewriterTest,
 | 
|  }
 | 
|  
 | 
|  TEST_F(EventRewriterTest, TestRewriteModifiersNoRemap) {
 | 
| -  sync_preferences::TestingPrefServiceSyncable prefs;
 | 
| -  EventRewriter rewriter(NULL);
 | 
| -  rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard");
 | 
| -  rewriter.set_pref_service_for_testing(&prefs);
 | 
| +  rewriter_->KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard");
 | 
|  
 | 
|    KeyTestCase tests[] = {
 | 
|        // Press Search. Confirm the event is not rewritten.
 | 
| @@ -585,16 +575,12 @@ TEST_F(EventRewriterTest, TestRewriteModifiersNoRemap) {
 | 
|         {ui::VKEY_LWIN, ui::DomCode::META_LEFT, ui::EF_NONE, ui::DomKey::META}},
 | 
|    };
 | 
|  
 | 
| -  for (const auto& test : tests) {
 | 
| -    CheckKeyTestCase(&rewriter, test);
 | 
| -  }
 | 
| +  for (const auto& test : tests)
 | 
| +    CheckKeyTestCase(rewriter_, test);
 | 
|  }
 | 
|  
 | 
|  TEST_F(EventRewriterTest, TestRewriteModifiersNoRemapMultipleKeys) {
 | 
| -  sync_preferences::TestingPrefServiceSyncable prefs;
 | 
| -  EventRewriter rewriter(NULL);
 | 
| -  rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard");
 | 
| -  rewriter.set_pref_service_for_testing(&prefs);
 | 
| +  rewriter_->KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard");
 | 
|  
 | 
|    KeyTestCase tests[] = {
 | 
|        // Press Alt with Shift. Confirm the event is not rewritten.
 | 
| @@ -648,28 +634,24 @@ TEST_F(EventRewriterTest, TestRewriteModifiersNoRemapMultipleKeys) {
 | 
|          ui::DomKey::Constant<'B'>::Character}},
 | 
|    };
 | 
|  
 | 
| -  for (const auto& test : tests) {
 | 
| -    CheckKeyTestCase(&rewriter, test);
 | 
| -  }
 | 
| +  for (const auto& test : tests)
 | 
| +    CheckKeyTestCase(rewriter_, test);
 | 
|  }
 | 
|  
 | 
|  TEST_F(EventRewriterTest, TestRewriteModifiersDisableSome) {
 | 
|    // Disable Search, Control and Escape keys.
 | 
| -  sync_preferences::TestingPrefServiceSyncable prefs;
 | 
| -  chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
 | 
| +  chromeos::Preferences::RegisterProfilePrefs(prefs()->registry());
 | 
|    IntegerPrefMember search;
 | 
| -  search.Init(prefs::kLanguageRemapSearchKeyTo, &prefs);
 | 
| +  search.Init(prefs::kLanguageRemapSearchKeyTo, prefs());
 | 
|    search.SetValue(chromeos::input_method::kVoidKey);
 | 
|    IntegerPrefMember control;
 | 
| -  control.Init(prefs::kLanguageRemapControlKeyTo, &prefs);
 | 
| +  control.Init(prefs::kLanguageRemapControlKeyTo, prefs());
 | 
|    control.SetValue(chromeos::input_method::kVoidKey);
 | 
|    IntegerPrefMember escape;
 | 
| -  escape.Init(prefs::kLanguageRemapEscapeKeyTo, &prefs);
 | 
| +  escape.Init(prefs::kLanguageRemapEscapeKeyTo, prefs());
 | 
|    escape.SetValue(chromeos::input_method::kVoidKey);
 | 
|  
 | 
| -  EventRewriter rewriter(NULL);
 | 
| -  rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard");
 | 
| -  rewriter.set_pref_service_for_testing(&prefs);
 | 
| +  rewriter_->KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard");
 | 
|  
 | 
|    KeyTestCase disabled_modifier_tests[] = {
 | 
|        // Press Alt with Shift. This key press shouldn't be affected by the
 | 
| @@ -724,13 +706,12 @@ TEST_F(EventRewriterTest, TestRewriteModifiersDisableSome) {
 | 
|          ui::DomKey::Constant<'a'>::Character}},
 | 
|    };
 | 
|  
 | 
| -  for (const auto& test : disabled_modifier_tests) {
 | 
| -    CheckKeyTestCase(&rewriter, test);
 | 
| -  }
 | 
| +  for (const auto& test : disabled_modifier_tests)
 | 
| +    CheckKeyTestCase(rewriter_, test);
 | 
|  
 | 
|    // Remap Alt to Control.
 | 
|    IntegerPrefMember alt;
 | 
| -  alt.Init(prefs::kLanguageRemapAltKeyTo, &prefs);
 | 
| +  alt.Init(prefs::kLanguageRemapAltKeyTo, prefs());
 | 
|    alt.SetValue(chromeos::input_method::kControlKey);
 | 
|  
 | 
|    KeyTestCase tests[] = {
 | 
| @@ -750,22 +731,18 @@ TEST_F(EventRewriterTest, TestRewriteModifiersDisableSome) {
 | 
|          ui::DomKey::Constant<'a'>::Character}},
 | 
|    };
 | 
|  
 | 
| -  for (const auto& test : tests) {
 | 
| -    CheckKeyTestCase(&rewriter, test);
 | 
| -  }
 | 
| +  for (const auto& test : tests)
 | 
| +    CheckKeyTestCase(rewriter_, test);
 | 
|  }
 | 
|  
 | 
|  TEST_F(EventRewriterTest, TestRewriteModifiersRemapToControl) {
 | 
|    // Remap Search to Control.
 | 
| -  sync_preferences::TestingPrefServiceSyncable prefs;
 | 
| -  chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
 | 
| +  chromeos::Preferences::RegisterProfilePrefs(prefs()->registry());
 | 
|    IntegerPrefMember search;
 | 
| -  search.Init(prefs::kLanguageRemapSearchKeyTo, &prefs);
 | 
| +  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);
 | 
| +  rewriter_->KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard");
 | 
|  
 | 
|    KeyTestCase s_tests[] = {
 | 
|        // Press Search. Confirm the event is now VKEY_CONTROL.
 | 
| @@ -776,13 +753,12 @@ TEST_F(EventRewriterTest, TestRewriteModifiersRemapToControl) {
 | 
|          ui::DomKey::CONTROL}},
 | 
|    };
 | 
|  
 | 
| -  for (const auto& test : s_tests) {
 | 
| -    CheckKeyTestCase(&rewriter, test);
 | 
| -  }
 | 
| +  for (const auto& test : s_tests)
 | 
| +    CheckKeyTestCase(rewriter_, test);
 | 
|  
 | 
|    // Remap Alt to Control too.
 | 
|    IntegerPrefMember alt;
 | 
| -  alt.Init(prefs::kLanguageRemapAltKeyTo, &prefs);
 | 
| +  alt.Init(prefs::kLanguageRemapAltKeyTo, prefs());
 | 
|    alt.SetValue(chromeos::input_method::kControlKey);
 | 
|  
 | 
|    KeyTestCase sa_tests[] = {
 | 
| @@ -828,22 +804,18 @@ TEST_F(EventRewriterTest, TestRewriteModifiersRemapToControl) {
 | 
|          ui::DomKey::Constant<'B'>::Character}},
 | 
|    };
 | 
|  
 | 
| -  for (const auto& test : sa_tests) {
 | 
| -    CheckKeyTestCase(&rewriter, test);
 | 
| -  }
 | 
| +  for (const auto& test : sa_tests)
 | 
| +    CheckKeyTestCase(rewriter_, test);
 | 
|  }
 | 
|  
 | 
|  TEST_F(EventRewriterTest, TestRewriteModifiersRemapToEscape) {
 | 
|    // Remap Search to Escape.
 | 
| -  sync_preferences::TestingPrefServiceSyncable prefs;
 | 
| -  chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
 | 
| +  chromeos::Preferences::RegisterProfilePrefs(prefs()->registry());
 | 
|    IntegerPrefMember search;
 | 
| -  search.Init(prefs::kLanguageRemapSearchKeyTo, &prefs);
 | 
| +  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);
 | 
| +  rewriter_->KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard");
 | 
|  
 | 
|    KeyTestCase tests[] = {
 | 
|        // Press Search. Confirm the event is now VKEY_ESCAPE.
 | 
| @@ -853,22 +825,18 @@ TEST_F(EventRewriterTest, TestRewriteModifiersRemapToEscape) {
 | 
|         {ui::VKEY_ESCAPE, ui::DomCode::ESCAPE, ui::EF_NONE, ui::DomKey::ESCAPE}},
 | 
|    };
 | 
|  
 | 
| -  for (const auto& test : tests) {
 | 
| -    CheckKeyTestCase(&rewriter, test);
 | 
| -  }
 | 
| +  for (const auto& test : tests)
 | 
| +    CheckKeyTestCase(rewriter_, test);
 | 
|  }
 | 
|  
 | 
|  TEST_F(EventRewriterTest, TestRewriteModifiersRemapMany) {
 | 
|    // Remap Escape to Alt.
 | 
| -  sync_preferences::TestingPrefServiceSyncable prefs;
 | 
| -  chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
 | 
| +  chromeos::Preferences::RegisterProfilePrefs(prefs()->registry());
 | 
|    IntegerPrefMember escape;
 | 
| -  escape.Init(prefs::kLanguageRemapEscapeKeyTo, &prefs);
 | 
| +  escape.Init(prefs::kLanguageRemapEscapeKeyTo, prefs());
 | 
|    escape.SetValue(chromeos::input_method::kAltKey);
 | 
|  
 | 
| -  EventRewriter rewriter(NULL);
 | 
| -  rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard");
 | 
| -  rewriter.set_pref_service_for_testing(&prefs);
 | 
| +  rewriter_->KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard");
 | 
|  
 | 
|    KeyTestCase e2a_tests[] = {
 | 
|        // Press Escape. Confirm the event is now VKEY_MENU.
 | 
| @@ -882,13 +850,12 @@ TEST_F(EventRewriterTest, TestRewriteModifiersRemapMany) {
 | 
|         {ui::VKEY_MENU, ui::DomCode::ALT_LEFT, ui::EF_NONE, ui::DomKey::ALT}},
 | 
|    };
 | 
|  
 | 
| -  for (const auto& test : e2a_tests) {
 | 
| -    CheckKeyTestCase(&rewriter, test);
 | 
| -  }
 | 
| +  for (const auto& test : e2a_tests)
 | 
| +    CheckKeyTestCase(rewriter_, test);
 | 
|  
 | 
|    // Remap Alt to Control.
 | 
|    IntegerPrefMember alt;
 | 
| -  alt.Init(prefs::kLanguageRemapAltKeyTo, &prefs);
 | 
| +  alt.Init(prefs::kLanguageRemapAltKeyTo, prefs());
 | 
|    alt.SetValue(chromeos::input_method::kControlKey);
 | 
|  
 | 
|    KeyTestCase a2c_tests[] = {
 | 
| @@ -913,13 +880,12 @@ TEST_F(EventRewriterTest, TestRewriteModifiersRemapMany) {
 | 
|          ui::DomKey::Constant<'('>::Character}},
 | 
|    };
 | 
|  
 | 
| -  for (const auto& test : a2c_tests) {
 | 
| -    CheckKeyTestCase(&rewriter, test);
 | 
| -  }
 | 
| +  for (const auto& test : a2c_tests)
 | 
| +    CheckKeyTestCase(rewriter_, test);
 | 
|  
 | 
|    // Remap Control to Search.
 | 
|    IntegerPrefMember control;
 | 
| -  control.Init(prefs::kLanguageRemapControlKeyTo, &prefs);
 | 
| +  control.Init(prefs::kLanguageRemapControlKeyTo, prefs());
 | 
|    control.SetValue(chromeos::input_method::kSearchKey);
 | 
|  
 | 
|    KeyTestCase c2s_tests[] = {
 | 
| @@ -959,13 +925,12 @@ TEST_F(EventRewriterTest, TestRewriteModifiersRemapMany) {
 | 
|          ui::DomKey::Constant<'B'>::Character}},
 | 
|    };
 | 
|  
 | 
| -  for (const auto& test : c2s_tests) {
 | 
| -    CheckKeyTestCase(&rewriter, test);
 | 
| -  }
 | 
| +  for (const auto& test : c2s_tests)
 | 
| +    CheckKeyTestCase(rewriter_, test);
 | 
|  
 | 
|    // Remap Search to Backspace.
 | 
|    IntegerPrefMember search;
 | 
| -  search.Init(prefs::kLanguageRemapSearchKeyTo, &prefs);
 | 
| +  search.Init(prefs::kLanguageRemapSearchKeyTo, prefs());
 | 
|    search.SetValue(chromeos::input_method::kBackspaceKey);
 | 
|  
 | 
|    KeyTestCase s2b_tests[] = {
 | 
| @@ -987,13 +952,12 @@ TEST_F(EventRewriterTest, TestRewriteModifiersRemapMany) {
 | 
|          ui::DomKey::BACKSPACE}},
 | 
|    };
 | 
|  
 | 
| -  for (const auto& test : s2b_tests) {
 | 
| -    CheckKeyTestCase(&rewriter, test);
 | 
| -  }
 | 
| +  for (const auto& test : s2b_tests)
 | 
| +    CheckKeyTestCase(rewriter_, test);
 | 
|  
 | 
|    // Remap Backspace to Escape.
 | 
|    IntegerPrefMember backspace;
 | 
| -  backspace.Init(prefs::kLanguageRemapBackspaceKeyTo, &prefs);
 | 
| +  backspace.Init(prefs::kLanguageRemapBackspaceKeyTo, prefs());
 | 
|    backspace.SetValue(chromeos::input_method::kEscapeKey);
 | 
|  
 | 
|    KeyTestCase b2e_tests[] = {
 | 
| @@ -1004,31 +968,27 @@ TEST_F(EventRewriterTest, TestRewriteModifiersRemapMany) {
 | 
|         {ui::VKEY_ESCAPE, ui::DomCode::ESCAPE, ui::EF_NONE, ui::DomKey::ESCAPE}},
 | 
|    };
 | 
|  
 | 
| -  for (const auto& test : b2e_tests) {
 | 
| -    CheckKeyTestCase(&rewriter, test);
 | 
| -  }
 | 
| +  for (const auto& test : b2e_tests)
 | 
| +    CheckKeyTestCase(rewriter_, test);
 | 
|  }
 | 
|  
 | 
|  TEST_F(EventRewriterTest, TestRewriteModifiersRemapToCapsLock) {
 | 
|    // Remap Search to Caps Lock.
 | 
| -  sync_preferences::TestingPrefServiceSyncable prefs;
 | 
| -  chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
 | 
| +  chromeos::Preferences::RegisterProfilePrefs(prefs()->registry());
 | 
|    IntegerPrefMember search;
 | 
| -  search.Init(prefs::kLanguageRemapSearchKeyTo, &prefs);
 | 
| +  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);
 | 
| +  rewriter_->KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard");
 | 
| +  rewriter_->set_ime_keyboard_for_testing(&ime_keyboard);
 | 
|    EXPECT_FALSE(ime_keyboard.caps_lock_is_enabled_);
 | 
|  
 | 
|    // Press Search.
 | 
|    EXPECT_EQ(GetExpectedResultAsString(
 | 
|                  ui::ET_KEY_PRESSED, ui::VKEY_CAPITAL, ui::DomCode::CAPS_LOCK,
 | 
|                  ui::EF_MOD3_DOWN | ui::EF_CAPS_LOCK_ON, ui::DomKey::CAPS_LOCK),
 | 
| -            GetRewrittenEventAsString(&rewriter, ui::ET_KEY_PRESSED,
 | 
| +            GetRewrittenEventAsString(rewriter_, ui::ET_KEY_PRESSED,
 | 
|                                        ui::VKEY_LWIN, ui::DomCode::META_LEFT,
 | 
|                                        ui::EF_COMMAND_DOWN, ui::DomKey::META));
 | 
|    // Confirm that the Caps Lock status is changed.
 | 
| @@ -1038,7 +998,7 @@ TEST_F(EventRewriterTest, TestRewriteModifiersRemapToCapsLock) {
 | 
|    EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_RELEASED, ui::VKEY_CAPITAL,
 | 
|                                        ui::DomCode::CAPS_LOCK, ui::EF_NONE,
 | 
|                                        ui::DomKey::CAPS_LOCK),
 | 
| -            GetRewrittenEventAsString(&rewriter, ui::ET_KEY_RELEASED,
 | 
| +            GetRewrittenEventAsString(rewriter_, ui::ET_KEY_RELEASED,
 | 
|                                        ui::VKEY_LWIN, ui::DomCode::META_LEFT,
 | 
|                                        ui::EF_NONE, ui::DomKey::META));
 | 
|    // Confirm that the Caps Lock status is not changed.
 | 
| @@ -1048,7 +1008,7 @@ TEST_F(EventRewriterTest, TestRewriteModifiersRemapToCapsLock) {
 | 
|    EXPECT_EQ(GetExpectedResultAsString(
 | 
|                  ui::ET_KEY_PRESSED, ui::VKEY_CAPITAL, ui::DomCode::CAPS_LOCK,
 | 
|                  ui::EF_CAPS_LOCK_ON | ui::EF_MOD3_DOWN, ui::DomKey::CAPS_LOCK),
 | 
| -            GetRewrittenEventAsString(&rewriter, ui::ET_KEY_PRESSED,
 | 
| +            GetRewrittenEventAsString(rewriter_, ui::ET_KEY_PRESSED,
 | 
|                                        ui::VKEY_LWIN, ui::DomCode::META_LEFT,
 | 
|                                        ui::EF_COMMAND_DOWN | ui::EF_CAPS_LOCK_ON,
 | 
|                                        ui::DomKey::META));
 | 
| @@ -1059,7 +1019,7 @@ TEST_F(EventRewriterTest, TestRewriteModifiersRemapToCapsLock) {
 | 
|    EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_RELEASED, ui::VKEY_CAPITAL,
 | 
|                                        ui::DomCode::CAPS_LOCK, ui::EF_NONE,
 | 
|                                        ui::DomKey::CAPS_LOCK),
 | 
| -            GetRewrittenEventAsString(&rewriter, ui::ET_KEY_RELEASED,
 | 
| +            GetRewrittenEventAsString(rewriter_, ui::ET_KEY_RELEASED,
 | 
|                                        ui::VKEY_LWIN, ui::DomCode::META_LEFT,
 | 
|                                        ui::EF_NONE, ui::DomKey::META));
 | 
|    // Confirm that the Caps Lock status is not changed.
 | 
| @@ -1069,7 +1029,7 @@ TEST_F(EventRewriterTest, TestRewriteModifiersRemapToCapsLock) {
 | 
|    EXPECT_EQ(GetExpectedResultAsString(
 | 
|                  ui::ET_KEY_PRESSED, ui::VKEY_CAPITAL, ui::DomCode::CAPS_LOCK,
 | 
|                  ui::EF_CAPS_LOCK_ON | ui::EF_MOD3_DOWN, ui::DomKey::CAPS_LOCK),
 | 
| -            GetRewrittenEventAsString(&rewriter, ui::ET_KEY_PRESSED,
 | 
| +            GetRewrittenEventAsString(rewriter_, ui::ET_KEY_PRESSED,
 | 
|                                        ui::VKEY_CAPITAL, ui::DomCode::CAPS_LOCK,
 | 
|                                        ui::EF_CAPS_LOCK_ON | ui::EF_MOD3_DOWN,
 | 
|                                        ui::DomKey::CAPS_LOCK));
 | 
| @@ -1090,7 +1050,7 @@ TEST_F(EventRewriterTest, TestRewriteModifiersRemapToCapsLock) {
 | 
|    EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_RELEASED, ui::VKEY_CAPITAL,
 | 
|                                        ui::DomCode::CAPS_LOCK, ui::EF_NONE,
 | 
|                                        ui::DomKey::CAPS_LOCK),
 | 
| -            GetRewrittenEventAsString(&rewriter, ui::ET_KEY_RELEASED,
 | 
| +            GetRewrittenEventAsString(rewriter_, ui::ET_KEY_RELEASED,
 | 
|                                        ui::VKEY_CAPITAL, ui::DomCode::CAPS_LOCK,
 | 
|                                        ui::EF_NONE, ui::DomKey::CAPS_LOCK));
 | 
|  #if defined(USE_X11)
 | 
| @@ -1101,35 +1061,29 @@ TEST_F(EventRewriterTest, TestRewriteModifiersRemapToCapsLock) {
 | 
|  }
 | 
|  
 | 
|  TEST_F(EventRewriterTest, TestRewriteCapsLock) {
 | 
| -  sync_preferences::TestingPrefServiceSyncable prefs;
 | 
| -  chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
 | 
| +  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);
 | 
| +  rewriter_->KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard");
 | 
| +  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::ET_KEY_PRESSED, ui::VKEY_CAPITAL, ui::DomCode::CAPS_LOCK,
 | 
|                  ui::EF_CAPS_LOCK_ON | ui::EF_MOD3_DOWN, ui::DomKey::CAPS_LOCK),
 | 
| -            GetRewrittenEventAsString(&rewriter, ui::ET_KEY_PRESSED,
 | 
| +            GetRewrittenEventAsString(rewriter_, ui::ET_KEY_PRESSED,
 | 
|                                        ui::VKEY_F16, ui::DomCode::F16,
 | 
|                                        ui::EF_MOD3_DOWN, ui::DomKey::F16));
 | 
|    EXPECT_TRUE(ime_keyboard.caps_lock_is_enabled_);
 | 
|  }
 | 
|  
 | 
|  TEST_F(EventRewriterTest, TestRewriteDiamondKey) {
 | 
| -  sync_preferences::TestingPrefServiceSyncable prefs;
 | 
| -  chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
 | 
| +  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);
 | 
| +  rewriter_->KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard");
 | 
| +  rewriter_->set_ime_keyboard_for_testing(&ime_keyboard);
 | 
|  
 | 
|    KeyTestCase tests[] = {
 | 
|        // F15 should work as Ctrl when --has-chromeos-diamond-key is not
 | 
| @@ -1153,9 +1107,8 @@ TEST_F(EventRewriterTest, TestRewriteDiamondKey) {
 | 
|          ui::DomKey::Constant<'a'>::Character}},
 | 
|    };
 | 
|  
 | 
| -  for (const auto& test : tests) {
 | 
| -    CheckKeyTestCase(&rewriter, test);
 | 
| -  }
 | 
| +  for (const auto& test : tests)
 | 
| +    CheckKeyTestCase(rewriter_, test);
 | 
|  }
 | 
|  
 | 
|  TEST_F(EventRewriterTest, TestRewriteDiamondKeyWithFlag) {
 | 
| @@ -1163,59 +1116,56 @@ TEST_F(EventRewriterTest, TestRewriteDiamondKeyWithFlag) {
 | 
|    base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
 | 
|        chromeos::switches::kHasChromeOSDiamondKey, "");
 | 
|  
 | 
| -  sync_preferences::TestingPrefServiceSyncable prefs;
 | 
| -  chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
 | 
| +  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);
 | 
| +  rewriter_->KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard");
 | 
| +  rewriter_->set_ime_keyboard_for_testing(&ime_keyboard);
 | 
|  
 | 
|    // By default, F15 should work as Control.
 | 
|    EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_PRESSED, ui::VKEY_CONTROL,
 | 
|                                        ui::DomCode::CONTROL_LEFT,
 | 
|                                        ui::EF_CONTROL_DOWN, ui::DomKey::CONTROL),
 | 
| -            GetRewrittenEventAsString(&rewriter, ui::ET_KEY_PRESSED,
 | 
| +            GetRewrittenEventAsString(rewriter_, ui::ET_KEY_PRESSED,
 | 
|                                        ui::VKEY_F15, ui::DomCode::F15,
 | 
|                                        ui::EF_NONE, ui::DomKey::F15));
 | 
|    // Check that Control is applied to a subsequent key press.
 | 
|    EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_PRESSED, ui::VKEY_A,
 | 
|                                        ui::DomCode::US_A, ui::EF_CONTROL_DOWN,
 | 
|                                        ui::DomKey::Constant<'a'>::Character),
 | 
| -            GetRewrittenEventAsString(&rewriter, ui::ET_KEY_PRESSED, ui::VKEY_A,
 | 
| +            GetRewrittenEventAsString(rewriter_, ui::ET_KEY_PRESSED, ui::VKEY_A,
 | 
|                                        ui::DomCode::US_A, ui::EF_NONE,
 | 
|                                        ui::DomKey::Constant<'a'>::Character));
 | 
|    // Release F15
 | 
|    EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_RELEASED, ui::VKEY_CONTROL,
 | 
|                                        ui::DomCode::CONTROL_LEFT, ui::EF_NONE,
 | 
|                                        ui::DomKey::CONTROL),
 | 
| -            GetRewrittenEventAsString(&rewriter, ui::ET_KEY_RELEASED,
 | 
| +            GetRewrittenEventAsString(rewriter_, ui::ET_KEY_RELEASED,
 | 
|                                        ui::VKEY_F15, ui::DomCode::F15,
 | 
|                                        ui::EF_NONE, ui::DomKey::F15));
 | 
|    // Check that Control is no longer applied to a subsequent key press.
 | 
|    EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_PRESSED, ui::VKEY_A,
 | 
|                                        ui::DomCode::US_A, ui::EF_NONE,
 | 
|                                        ui::DomKey::Constant<'a'>::Character),
 | 
| -            GetRewrittenEventAsString(&rewriter, ui::ET_KEY_PRESSED, ui::VKEY_A,
 | 
| +            GetRewrittenEventAsString(rewriter_, ui::ET_KEY_PRESSED, ui::VKEY_A,
 | 
|                                        ui::DomCode::US_A, ui::EF_NONE,
 | 
|                                        ui::DomKey::Constant<'a'>::Character));
 | 
|  
 | 
|    IntegerPrefMember diamond;
 | 
| -  diamond.Init(prefs::kLanguageRemapDiamondKeyTo, &prefs);
 | 
| +  diamond.Init(prefs::kLanguageRemapDiamondKeyTo, prefs());
 | 
|    diamond.SetValue(chromeos::input_method::kVoidKey);
 | 
|  
 | 
|    EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_PRESSED, ui::VKEY_UNKNOWN,
 | 
|                                        ui::DomCode::NONE, ui::EF_NONE,
 | 
|                                        ui::DomKey::UNIDENTIFIED),
 | 
| -            GetRewrittenEventAsString(&rewriter, ui::ET_KEY_PRESSED,
 | 
| +            GetRewrittenEventAsString(rewriter_, ui::ET_KEY_PRESSED,
 | 
|                                        ui::VKEY_F15, ui::DomCode::F15,
 | 
|                                        ui::EF_NONE, ui::DomKey::F15));
 | 
|    // Check that no modifier is applied to another key.
 | 
|    EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_PRESSED, ui::VKEY_A,
 | 
|                                        ui::DomCode::US_A, ui::EF_NONE,
 | 
|                                        ui::DomKey::Constant<'a'>::Character),
 | 
| -            GetRewrittenEventAsString(&rewriter, ui::ET_KEY_PRESSED, ui::VKEY_A,
 | 
| +            GetRewrittenEventAsString(rewriter_, ui::ET_KEY_PRESSED, ui::VKEY_A,
 | 
|                                        ui::DomCode::US_A, ui::EF_NONE,
 | 
|                                        ui::DomKey::Constant<'a'>::Character));
 | 
|  
 | 
| @@ -1224,28 +1174,28 @@ TEST_F(EventRewriterTest, TestRewriteDiamondKeyWithFlag) {
 | 
|    EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_PRESSED, ui::VKEY_CONTROL,
 | 
|                                        ui::DomCode::CONTROL_LEFT,
 | 
|                                        ui::EF_CONTROL_DOWN, ui::DomKey::CONTROL),
 | 
| -            GetRewrittenEventAsString(&rewriter, ui::ET_KEY_PRESSED,
 | 
| +            GetRewrittenEventAsString(rewriter_, ui::ET_KEY_PRESSED,
 | 
|                                        ui::VKEY_F15, ui::DomCode::F15,
 | 
|                                        ui::EF_NONE, ui::DomKey::F15));
 | 
|    // Check that Control is applied to a subsequent key press.
 | 
|    EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_PRESSED, ui::VKEY_A,
 | 
|                                        ui::DomCode::US_A, ui::EF_CONTROL_DOWN,
 | 
|                                        ui::DomKey::Constant<'a'>::Character),
 | 
| -            GetRewrittenEventAsString(&rewriter, ui::ET_KEY_PRESSED, ui::VKEY_A,
 | 
| +            GetRewrittenEventAsString(rewriter_, ui::ET_KEY_PRESSED, ui::VKEY_A,
 | 
|                                        ui::DomCode::US_A, ui::EF_NONE,
 | 
|                                        ui::DomKey::Constant<'a'>::Character));
 | 
|    // Release F15
 | 
|    EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_RELEASED, ui::VKEY_CONTROL,
 | 
|                                        ui::DomCode::CONTROL_LEFT, ui::EF_NONE,
 | 
|                                        ui::DomKey::CONTROL),
 | 
| -            GetRewrittenEventAsString(&rewriter, ui::ET_KEY_RELEASED,
 | 
| +            GetRewrittenEventAsString(rewriter_, ui::ET_KEY_RELEASED,
 | 
|                                        ui::VKEY_F15, ui::DomCode::F15,
 | 
|                                        ui::EF_NONE, ui::DomKey::F15));
 | 
|    // Check that Control is no longer applied to a subsequent key press.
 | 
|    EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_PRESSED, ui::VKEY_A,
 | 
|                                        ui::DomCode::US_A, ui::EF_NONE,
 | 
|                                        ui::DomKey::Constant<'a'>::Character),
 | 
| -            GetRewrittenEventAsString(&rewriter, ui::ET_KEY_PRESSED, ui::VKEY_A,
 | 
| +            GetRewrittenEventAsString(rewriter_, ui::ET_KEY_PRESSED, ui::VKEY_A,
 | 
|                                        ui::DomCode::US_A, ui::EF_NONE,
 | 
|                                        ui::DomKey::Constant<'a'>::Character));
 | 
|  
 | 
| @@ -1254,28 +1204,28 @@ TEST_F(EventRewriterTest, TestRewriteDiamondKeyWithFlag) {
 | 
|    EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_PRESSED, ui::VKEY_MENU,
 | 
|                                        ui::DomCode::ALT_LEFT, ui::EF_ALT_DOWN,
 | 
|                                        ui::DomKey::ALT),
 | 
| -            GetRewrittenEventAsString(&rewriter, ui::ET_KEY_PRESSED,
 | 
| +            GetRewrittenEventAsString(rewriter_, ui::ET_KEY_PRESSED,
 | 
|                                        ui::VKEY_F15, ui::DomCode::F15,
 | 
|                                        ui::EF_NONE, ui::DomKey::F15));
 | 
|    // Check that Alt is applied to a subsequent key press.
 | 
|    EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_PRESSED, ui::VKEY_A,
 | 
|                                        ui::DomCode::US_A, ui::EF_ALT_DOWN,
 | 
|                                        ui::DomKey::Constant<'a'>::Character),
 | 
| -            GetRewrittenEventAsString(&rewriter, ui::ET_KEY_PRESSED, ui::VKEY_A,
 | 
| +            GetRewrittenEventAsString(rewriter_, ui::ET_KEY_PRESSED, ui::VKEY_A,
 | 
|                                        ui::DomCode::US_A, ui::EF_NONE,
 | 
|                                        ui::DomKey::Constant<'a'>::Character));
 | 
|    // Release F15
 | 
|    EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_RELEASED, ui::VKEY_MENU,
 | 
|                                        ui::DomCode::ALT_LEFT, ui::EF_NONE,
 | 
|                                        ui::DomKey::ALT),
 | 
| -            GetRewrittenEventAsString(&rewriter, ui::ET_KEY_RELEASED,
 | 
| +            GetRewrittenEventAsString(rewriter_, ui::ET_KEY_RELEASED,
 | 
|                                        ui::VKEY_F15, ui::DomCode::F15,
 | 
|                                        ui::EF_NONE, ui::DomKey::F15));
 | 
|    // Check that Alt is no longer applied to a subsequent key press.
 | 
|    EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_PRESSED, ui::VKEY_A,
 | 
|                                        ui::DomCode::US_A, ui::EF_NONE,
 | 
|                                        ui::DomKey::Constant<'a'>::Character),
 | 
| -            GetRewrittenEventAsString(&rewriter, ui::ET_KEY_PRESSED, ui::VKEY_A,
 | 
| +            GetRewrittenEventAsString(rewriter_, ui::ET_KEY_PRESSED, ui::VKEY_A,
 | 
|                                        ui::DomCode::US_A, ui::EF_NONE,
 | 
|                                        ui::DomKey::Constant<'a'>::Character));
 | 
|  
 | 
| @@ -1284,7 +1234,7 @@ TEST_F(EventRewriterTest, TestRewriteDiamondKeyWithFlag) {
 | 
|    EXPECT_EQ(GetExpectedResultAsString(
 | 
|                  ui::ET_KEY_PRESSED, ui::VKEY_CAPITAL, ui::DomCode::CAPS_LOCK,
 | 
|                  ui::EF_CAPS_LOCK_ON | ui::EF_MOD3_DOWN, ui::DomKey::CAPS_LOCK),
 | 
| -            GetRewrittenEventAsString(&rewriter, ui::ET_KEY_PRESSED,
 | 
| +            GetRewrittenEventAsString(rewriter_, ui::ET_KEY_PRESSED,
 | 
|                                        ui::VKEY_F15, ui::DomCode::F15,
 | 
|                                        ui::EF_NONE, ui::DomKey::F15));
 | 
|    // Check that Caps is applied to a subsequent key press.
 | 
| @@ -1292,21 +1242,21 @@ TEST_F(EventRewriterTest, TestRewriteDiamondKeyWithFlag) {
 | 
|                                        ui::DomCode::US_A,
 | 
|                                        ui::EF_CAPS_LOCK_ON | ui::EF_MOD3_DOWN,
 | 
|                                        ui::DomKey::Constant<'A'>::Character),
 | 
| -            GetRewrittenEventAsString(&rewriter, ui::ET_KEY_PRESSED, ui::VKEY_A,
 | 
| +            GetRewrittenEventAsString(rewriter_, ui::ET_KEY_PRESSED, ui::VKEY_A,
 | 
|                                        ui::DomCode::US_A, ui::EF_NONE,
 | 
|                                        ui::DomKey::Constant<'a'>::Character));
 | 
|    // Release F15
 | 
|    EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_RELEASED, ui::VKEY_CAPITAL,
 | 
|                                        ui::DomCode::CAPS_LOCK, ui::EF_NONE,
 | 
|                                        ui::DomKey::CAPS_LOCK),
 | 
| -            GetRewrittenEventAsString(&rewriter, ui::ET_KEY_RELEASED,
 | 
| +            GetRewrittenEventAsString(rewriter_, ui::ET_KEY_RELEASED,
 | 
|                                        ui::VKEY_F15, ui::DomCode::F15,
 | 
|                                        ui::EF_NONE, ui::DomKey::F15));
 | 
|    // Check that Control is no longer applied to a subsequent key press.
 | 
|    EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_PRESSED, ui::VKEY_A,
 | 
|                                        ui::DomCode::US_A, ui::EF_NONE,
 | 
|                                        ui::DomKey::Constant<'a'>::Character),
 | 
| -            GetRewrittenEventAsString(&rewriter, ui::ET_KEY_PRESSED, ui::VKEY_A,
 | 
| +            GetRewrittenEventAsString(rewriter_, ui::ET_KEY_PRESSED, ui::VKEY_A,
 | 
|                                        ui::DomCode::US_A, ui::EF_NONE,
 | 
|                                        ui::DomKey::Constant<'a'>::Character));
 | 
|  
 | 
| @@ -1315,15 +1265,12 @@ TEST_F(EventRewriterTest, TestRewriteDiamondKeyWithFlag) {
 | 
|  
 | 
|  TEST_F(EventRewriterTest, TestRewriteCapsLockToControl) {
 | 
|    // Remap CapsLock to Control.
 | 
| -  sync_preferences::TestingPrefServiceSyncable prefs;
 | 
| -  chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
 | 
| +  chromeos::Preferences::RegisterProfilePrefs(prefs()->registry());
 | 
|    IntegerPrefMember control;
 | 
| -  control.Init(prefs::kLanguageRemapCapsLockKeyTo, &prefs);
 | 
| +  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);
 | 
| +  rewriter_->KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard");
 | 
|  
 | 
|    KeyTestCase tests[] = {
 | 
|        // Press CapsLock+a. Confirm that Mod3Mask is rewritten to ControlMask.
 | 
| @@ -1351,22 +1298,18 @@ TEST_F(EventRewriterTest, TestRewriteCapsLockToControl) {
 | 
|          ui::DomKey::Constant<'a'>::Character}},
 | 
|    };
 | 
|  
 | 
| -  for (const auto& test : tests) {
 | 
| -    CheckKeyTestCase(&rewriter, test);
 | 
| -  }
 | 
| +  for (const auto& test : tests)
 | 
| +    CheckKeyTestCase(rewriter_, test);
 | 
|  }
 | 
|  
 | 
|  TEST_F(EventRewriterTest, TestRewriteCapsLockMod3InUse) {
 | 
|    // Remap CapsLock to Control.
 | 
| -  sync_preferences::TestingPrefServiceSyncable prefs;
 | 
| -  chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
 | 
| +  chromeos::Preferences::RegisterProfilePrefs(prefs()->registry());
 | 
|    IntegerPrefMember control;
 | 
| -  control.Init(prefs::kLanguageRemapCapsLockKeyTo, &prefs);
 | 
| +  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);
 | 
| +  rewriter_->KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard");
 | 
|    input_method_manager_mock_->set_mod3_used(true);
 | 
|  
 | 
|    // Press CapsLock+a. Confirm that Mod3Mask is NOT rewritten to ControlMask
 | 
| @@ -1374,7 +1317,7 @@ TEST_F(EventRewriterTest, TestRewriteCapsLockMod3InUse) {
 | 
|    EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_PRESSED, ui::VKEY_A,
 | 
|                                        ui::DomCode::US_A, ui::EF_NONE,
 | 
|                                        ui::DomKey::Constant<'a'>::Character),
 | 
| -            GetRewrittenEventAsString(&rewriter, ui::ET_KEY_PRESSED, ui::VKEY_A,
 | 
| +            GetRewrittenEventAsString(rewriter_, ui::ET_KEY_PRESSED, ui::VKEY_A,
 | 
|                                        ui::DomCode::US_A, ui::EF_NONE,
 | 
|                                        ui::DomKey::Constant<'a'>::Character));
 | 
|  
 | 
| @@ -1382,12 +1325,9 @@ TEST_F(EventRewriterTest, TestRewriteCapsLockMod3InUse) {
 | 
|  }
 | 
|  
 | 
|  TEST_F(EventRewriterTest, TestRewriteExtendedKeys) {
 | 
| -  sync_preferences::TestingPrefServiceSyncable prefs;
 | 
| -  chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
 | 
| -  EventRewriter rewriter(NULL);
 | 
| -  rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard");
 | 
| -  rewriter.set_last_keyboard_device_id_for_testing(kKeyboardDeviceId);
 | 
| -  rewriter.set_pref_service_for_testing(&prefs);
 | 
| +  chromeos::Preferences::RegisterProfilePrefs(prefs()->registry());
 | 
| +  rewriter_->KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard");
 | 
| +  rewriter_->set_last_keyboard_device_id_for_testing(kKeyboardDeviceId);
 | 
|  
 | 
|    KeyTestCase tests[] = {
 | 
|        // Alt+Backspace -> Delete
 | 
| @@ -1522,17 +1462,13 @@ TEST_F(EventRewriterTest, TestRewriteExtendedKeys) {
 | 
|         {ui::VKEY_INSERT, ui::DomCode::INSERT, ui::EF_CONTROL_DOWN,
 | 
|          ui::DomKey::INSERT}}};
 | 
|  
 | 
| -  for (const auto& test : tests) {
 | 
| -    CheckKeyTestCase(&rewriter, test);
 | 
| -  }
 | 
| +  for (const auto& test : tests)
 | 
| +    CheckKeyTestCase(rewriter_, test);
 | 
|  }
 | 
|  
 | 
|  TEST_F(EventRewriterTest, TestRewriteFunctionKeys) {
 | 
| -  sync_preferences::TestingPrefServiceSyncable prefs;
 | 
| -  chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
 | 
| -  EventRewriter rewriter(NULL);
 | 
| -  rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard");
 | 
| -  rewriter.set_pref_service_for_testing(&prefs);
 | 
| +  chromeos::Preferences::RegisterProfilePrefs(prefs()->registry());
 | 
| +  rewriter_->KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard");
 | 
|  
 | 
|    KeyTestCase tests[] = {
 | 
|        // F1 -> Back
 | 
| @@ -1837,22 +1773,18 @@ TEST_F(EventRewriterTest, TestRewriteFunctionKeys) {
 | 
|         {ui::VKEY_F12, ui::DomCode::F12, ui::EF_COMMAND_DOWN, ui::DomKey::F12},
 | 
|         {ui::VKEY_F12, ui::DomCode::F12, ui::EF_NONE, ui::DomKey::F12}}};
 | 
|  
 | 
| -  for (const auto& test : tests) {
 | 
| -    CheckKeyTestCase(&rewriter, test);
 | 
| -  }
 | 
| +  for (const auto& test : tests)
 | 
| +    CheckKeyTestCase(rewriter_, test);
 | 
|  }
 | 
|  
 | 
|  TEST_F(EventRewriterTest, TestRewriteExtendedKeysWithSearchRemapped) {
 | 
|    // Remap Search to Control.
 | 
| -  sync_preferences::TestingPrefServiceSyncable prefs;
 | 
| -  chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
 | 
| +  chromeos::Preferences::RegisterProfilePrefs(prefs()->registry());
 | 
|    IntegerPrefMember search;
 | 
| -  search.Init(prefs::kLanguageRemapSearchKeyTo, &prefs);
 | 
| +  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);
 | 
| +  rewriter_->KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard");
 | 
|  
 | 
|    KeyTestCase tests[] = {
 | 
|        // Alt+Search+Down -> End
 | 
| @@ -1869,22 +1801,18 @@ TEST_F(EventRewriterTest, TestRewriteExtendedKeysWithSearchRemapped) {
 | 
|         {ui::VKEY_END, ui::DomCode::END, ui::EF_SHIFT_DOWN, ui::DomKey::END}},
 | 
|    };
 | 
|  
 | 
| -  for (const auto& test : tests) {
 | 
| -    CheckKeyTestCase(&rewriter, test);
 | 
| -  }
 | 
| +  for (const auto& test : tests)
 | 
| +    CheckKeyTestCase(rewriter_, test);
 | 
|  }
 | 
|  
 | 
|  TEST_F(EventRewriterTest, TestRewriteKeyEventSentByXSendEvent) {
 | 
|    // Remap Control to Alt.
 | 
| -  sync_preferences::TestingPrefServiceSyncable prefs;
 | 
| -  chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
 | 
| +  chromeos::Preferences::RegisterProfilePrefs(prefs()->registry());
 | 
|    IntegerPrefMember control;
 | 
| -  control.Init(prefs::kLanguageRemapControlKeyTo, &prefs);
 | 
| +  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);
 | 
| +  rewriter_->KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard");
 | 
|  
 | 
|    // Send left control press.
 | 
|    {
 | 
| @@ -1894,7 +1822,7 @@ TEST_F(EventRewriterTest, TestRewriteKeyEventSentByXSendEvent) {
 | 
|      std::unique_ptr<ui::Event> new_event;
 | 
|      // Control should NOT be remapped to Alt if EF_FINAL is set.
 | 
|      EXPECT_EQ(ui::EVENT_REWRITE_CONTINUE,
 | 
| -              rewriter.RewriteEvent(keyevent, &new_event));
 | 
| +              rewriter_->RewriteEvent(keyevent, &new_event));
 | 
|      EXPECT_FALSE(new_event);
 | 
|    }
 | 
|  #if defined(USE_X11)
 | 
| @@ -1910,7 +1838,7 @@ TEST_F(EventRewriterTest, TestRewriteKeyEventSentByXSendEvent) {
 | 
|      // Control should NOT be remapped to Alt if send_event
 | 
|      // flag in the event is True.
 | 
|      EXPECT_EQ(ui::EVENT_REWRITE_CONTINUE,
 | 
| -              rewriter.RewriteEvent(keyevent, &new_event));
 | 
| +              rewriter_->RewriteEvent(keyevent, &new_event));
 | 
|      EXPECT_FALSE(new_event);
 | 
|    }
 | 
|  #endif
 | 
| @@ -1918,15 +1846,12 @@ TEST_F(EventRewriterTest, TestRewriteKeyEventSentByXSendEvent) {
 | 
|  
 | 
|  TEST_F(EventRewriterTest, TestRewriteNonNativeEvent) {
 | 
|    // Remap Control to Alt.
 | 
| -  sync_preferences::TestingPrefServiceSyncable prefs;
 | 
| -  chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
 | 
| +  chromeos::Preferences::RegisterProfilePrefs(prefs()->registry());
 | 
|    IntegerPrefMember control;
 | 
| -  control.Init(prefs::kLanguageRemapControlKeyTo, &prefs);
 | 
| +  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);
 | 
| +  rewriter_->KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard");
 | 
|  
 | 
|    const int kTouchId = 2;
 | 
|    gfx::Point location(0, 0);
 | 
| @@ -1938,7 +1863,7 @@ TEST_F(EventRewriterTest, TestRewriteNonNativeEvent) {
 | 
|  #endif
 | 
|  
 | 
|    std::unique_ptr<ui::Event> new_event;
 | 
| -  rewriter.RewriteEvent(press, &new_event);
 | 
| +  rewriter_->RewriteEvent(press, &new_event);
 | 
|    EXPECT_TRUE(new_event);
 | 
|    // Control should be remapped to Alt.
 | 
|    EXPECT_EQ(ui::EF_ALT_DOWN,
 | 
| @@ -2028,9 +1953,11 @@ class EventRewriterAshTest : public ash::test::AshTestBase {
 | 
|      AshTestBase::SetUp();
 | 
|      sticky_keys_controller_ =
 | 
|          ash::Shell::GetInstance()->sticky_keys_controller();
 | 
| -    rewriter_.reset(new EventRewriter(sticky_keys_controller_));
 | 
| +    delegate_ = base::MakeUnique<EventRewriterDelegateImpl>();
 | 
| +    delegate_->set_pref_service_for_testing(prefs());
 | 
| +    rewriter_ = base::MakeUnique<ui::EventRewriterChromeOS>(
 | 
| +        delegate_.get(), sticky_keys_controller_);
 | 
|      chromeos::Preferences::RegisterProfilePrefs(prefs_.registry());
 | 
| -    rewriter_->set_pref_service_for_testing(&prefs_);
 | 
|  #if defined(USE_X11)
 | 
|      ui::SetUpTouchPadForTest(kTouchPadDeviceId);
 | 
|  #endif
 | 
| @@ -2047,7 +1974,8 @@ class EventRewriterAshTest : public ash::test::AshTestBase {
 | 
|    ash::StickyKeysController* sticky_keys_controller_;
 | 
|  
 | 
|   private:
 | 
| -  std::unique_ptr<EventRewriter> rewriter_;
 | 
| +  std::unique_ptr<EventRewriterDelegateImpl> delegate_;
 | 
| +  std::unique_ptr<ui::EventRewriterChromeOS> rewriter_;
 | 
|  
 | 
|    EventBuffer buffer_;
 | 
|    TestEventSource source_;
 | 
| @@ -2103,15 +2031,12 @@ TEST_F(EventRewriterTest, TestRewrittenModifierClick) {
 | 
|    ui::TouchFactory::GetInstance()->SetPointerDeviceForTest(device_list);
 | 
|  
 | 
|    // Remap Control to Alt.
 | 
| -  sync_preferences::TestingPrefServiceSyncable prefs;
 | 
| -  chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
 | 
| +  chromeos::Preferences::RegisterProfilePrefs(prefs()->registry());
 | 
|    IntegerPrefMember control;
 | 
| -  control.Init(prefs::kLanguageRemapControlKeyTo, &prefs);
 | 
| +  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);
 | 
| +  rewriter_->KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard");
 | 
|  
 | 
|    // Check that Control + Left Button is converted (via Alt + Left Button)
 | 
|    // to Right Button.
 | 
| @@ -2123,8 +2048,7 @@ TEST_F(EventRewriterTest, TestRewrittenModifierClick) {
 | 
|    EXPECT_EQ(ui::ET_MOUSE_PRESSED, press.type());
 | 
|    EXPECT_EQ(ui::EF_LEFT_MOUSE_BUTTON | ui::EF_CONTROL_DOWN, press.flags());
 | 
|    std::unique_ptr<ui::Event> new_event;
 | 
| -  const ui::MouseEvent* result =
 | 
| -      RewriteMouseButtonEvent(&rewriter, press, &new_event);
 | 
| +  const ui::MouseEvent* result = RewriteMouseButtonEvent(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());
 | 
| @@ -2135,16 +2059,13 @@ TEST_F(EventRewriterTest, TestRewrittenModifierClick) {
 | 
|  
 | 
|  TEST_F(EventRewriterTest, DontRewriteIfNotRewritten) {
 | 
|  // TODO(kpschoedel): pending changes for crbug.com/360377
 | 
| -// to |chromeos::EventRewriter::RewriteLocatedEvent()
 | 
| +// to |ui::EventRewriterChromeOS::RewriteLocatedEvent()
 | 
|  #if defined(USE_X11)
 | 
|    std::vector<int> device_list;
 | 
|    device_list.push_back(10);
 | 
|    device_list.push_back(11);
 | 
|    ui::TouchFactory::GetInstance()->SetPointerDeviceForTest(device_list);
 | 
|  #endif
 | 
| -  sync_preferences::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.
 | 
| @@ -2158,8 +2079,7 @@ TEST_F(EventRewriterTest, DontRewriteIfNotRewritten) {
 | 
|      EXPECT_EQ(ui::ET_MOUSE_PRESSED, press.type());
 | 
|      EXPECT_EQ(kLeftAndAltFlag, press.flags());
 | 
|      std::unique_ptr<ui::Event> new_event;
 | 
| -    const ui::MouseEvent* result =
 | 
| -        RewriteMouseButtonEvent(&rewriter, press, &new_event);
 | 
| +    const ui::MouseEvent* result = RewriteMouseButtonEvent(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());
 | 
| @@ -2171,8 +2091,7 @@ TEST_F(EventRewriterTest, DontRewriteIfNotRewritten) {
 | 
|      ui::EventTestApi test_release(&release);
 | 
|      test_release.set_source_device_id(10);
 | 
|      std::unique_ptr<ui::Event> new_event;
 | 
| -    const ui::MouseEvent* result =
 | 
| -        RewriteMouseButtonEvent(&rewriter, release, &new_event);
 | 
| +    const ui::MouseEvent* result = RewriteMouseButtonEvent(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());
 | 
| @@ -2188,8 +2107,7 @@ TEST_F(EventRewriterTest, DontRewriteIfNotRewritten) {
 | 
|      EXPECT_EQ(ui::ET_MOUSE_PRESSED, press.type());
 | 
|      EXPECT_EQ(kLeftAndAltFlag, press.flags());
 | 
|      std::unique_ptr<ui::Event> new_event;
 | 
| -    const ui::MouseEvent* result =
 | 
| -        RewriteMouseButtonEvent(&rewriter, press, &new_event);
 | 
| +    const ui::MouseEvent* result = RewriteMouseButtonEvent(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());
 | 
| @@ -2200,8 +2118,7 @@ TEST_F(EventRewriterTest, DontRewriteIfNotRewritten) {
 | 
|                                 kLeftAndAltFlag);
 | 
|      ui::MouseEvent release(xev);
 | 
|      std::unique_ptr<ui::Event> new_event;
 | 
| -    const ui::MouseEvent* result =
 | 
| -        RewriteMouseButtonEvent(&rewriter, release, &new_event);
 | 
| +    const ui::MouseEvent* result = RewriteMouseButtonEvent(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());
 | 
| @@ -2216,8 +2133,7 @@ TEST_F(EventRewriterTest, DontRewriteIfNotRewritten) {
 | 
|      ui::EventTestApi test_press(&press);
 | 
|      test_press.set_source_device_id(10);
 | 
|      std::unique_ptr<ui::Event> new_event;
 | 
| -    const ui::MouseEvent* result =
 | 
| -        RewriteMouseButtonEvent(&rewriter, press, &new_event);
 | 
| +    const ui::MouseEvent* result = RewriteMouseButtonEvent(press, &new_event);
 | 
|      EXPECT_TRUE(ui::EF_LEFT_MOUSE_BUTTON & result->flags());
 | 
|      EXPECT_EQ(ui::EF_LEFT_MOUSE_BUTTON, result->changed_button_flags());
 | 
|    }
 | 
| @@ -2228,8 +2144,7 @@ TEST_F(EventRewriterTest, DontRewriteIfNotRewritten) {
 | 
|      ui::EventTestApi test_release(&release);
 | 
|      test_release.set_source_device_id(10);
 | 
|      std::unique_ptr<ui::Event> new_event;
 | 
| -    const ui::MouseEvent* result =
 | 
| -        RewriteMouseButtonEvent(&rewriter, release, &new_event);
 | 
| +    const ui::MouseEvent* result = RewriteMouseButtonEvent(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());
 | 
|    }
 | 
| @@ -2241,8 +2156,7 @@ TEST_F(EventRewriterTest, DontRewriteIfNotRewritten) {
 | 
|                                 ui::EF_LEFT_MOUSE_BUTTON);
 | 
|      ui::MouseEvent press(xev);
 | 
|      std::unique_ptr<ui::Event> new_event;
 | 
| -    const ui::MouseEvent* result =
 | 
| -        RewriteMouseButtonEvent(&rewriter, press, &new_event);
 | 
| +    const ui::MouseEvent* result = RewriteMouseButtonEvent(press, &new_event);
 | 
|      EXPECT_TRUE(ui::EF_LEFT_MOUSE_BUTTON & result->flags());
 | 
|      EXPECT_EQ(ui::EF_LEFT_MOUSE_BUTTON, result->changed_button_flags());
 | 
|    }
 | 
| @@ -2252,8 +2166,7 @@ TEST_F(EventRewriterTest, DontRewriteIfNotRewritten) {
 | 
|                                 kLeftAndAltFlag);
 | 
|      ui::MouseEvent release(xev);
 | 
|      std::unique_ptr<ui::Event> new_event;
 | 
| -    const ui::MouseEvent* result =
 | 
| -        RewriteMouseButtonEvent(&rewriter, release, &new_event);
 | 
| +    const ui::MouseEvent* result = RewriteMouseButtonEvent(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());
 | 
|    }
 | 
| @@ -2267,8 +2180,7 @@ TEST_F(EventRewriterTest, DontRewriteIfNotRewritten) {
 | 
|      ui::EventTestApi test_press(&press);
 | 
|      test_press.set_source_device_id(11);
 | 
|      std::unique_ptr<ui::Event> new_event;
 | 
| -    const ui::MouseEvent* result =
 | 
| -        RewriteMouseButtonEvent(&rewriter, press, &new_event);
 | 
| +    const ui::MouseEvent* result = RewriteMouseButtonEvent(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());
 | 
| @@ -2280,8 +2192,7 @@ TEST_F(EventRewriterTest, DontRewriteIfNotRewritten) {
 | 
|      ui::EventTestApi test_release(&release);
 | 
|      test_release.set_source_device_id(10);
 | 
|      std::unique_ptr<ui::Event> new_event;
 | 
| -    const ui::MouseEvent* result =
 | 
| -        RewriteMouseButtonEvent(&rewriter, release, &new_event);
 | 
| +    const ui::MouseEvent* result = RewriteMouseButtonEvent(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());
 | 
|    }
 | 
| @@ -2292,8 +2203,7 @@ TEST_F(EventRewriterTest, DontRewriteIfNotRewritten) {
 | 
|      ui::EventTestApi test_release(&release);
 | 
|      test_release.set_source_device_id(11);
 | 
|      std::unique_ptr<ui::Event> new_event;
 | 
| -    const ui::MouseEvent* result =
 | 
| -        RewriteMouseButtonEvent(&rewriter, release, &new_event);
 | 
| +    const ui::MouseEvent* result = RewriteMouseButtonEvent(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());
 | 
| @@ -2306,8 +2216,7 @@ TEST_F(EventRewriterTest, DontRewriteIfNotRewritten) {
 | 
|                                 kLeftAndAltFlag);
 | 
|      ui::MouseEvent press(xev);
 | 
|      std::unique_ptr<ui::Event> new_event;
 | 
| -    const ui::MouseEvent* result =
 | 
| -        RewriteMouseButtonEvent(&rewriter, press, &new_event);
 | 
| +    const ui::MouseEvent* result = RewriteMouseButtonEvent(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());
 | 
| @@ -2318,8 +2227,7 @@ TEST_F(EventRewriterTest, DontRewriteIfNotRewritten) {
 | 
|                                 kLeftAndAltFlag);
 | 
|      ui::MouseEvent release(xev);
 | 
|      std::unique_ptr<ui::Event> new_event;
 | 
| -    const ui::MouseEvent* result =
 | 
| -        RewriteMouseButtonEvent(&rewriter, release, &new_event);
 | 
| +    const ui::MouseEvent* result = RewriteMouseButtonEvent(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());
 | 
|    }
 | 
| @@ -2329,8 +2237,7 @@ TEST_F(EventRewriterTest, DontRewriteIfNotRewritten) {
 | 
|                                 kLeftAndAltFlag);
 | 
|      ui::MouseEvent release(xev);
 | 
|      std::unique_ptr<ui::Event> new_event;
 | 
| -    const ui::MouseEvent* result =
 | 
| -        RewriteMouseButtonEvent(&rewriter, release, &new_event);
 | 
| +    const ui::MouseEvent* result = RewriteMouseButtonEvent(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());
 | 
| 
 |