Move chromeos::EventRewriter to //ui/chromeos/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/common/wm/window_state.h"
 #include "ash/shell.h"
 #include "ash/sticky_keys/sticky_keys_controller.h"
 #include "ash/sticky_keys/sticky_keys_overlay.h"
 #include "ash/test/ash_test_base.h"
 #include "ash/wm/window_state_aura.h"
 #include "base/command_line.h"
 #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"
 #include "chrome/browser/chromeos/login/users/scoped_user_manager_enabler.h"
 #include "chrome/browser/chromeos/preferences.h"
 #include "chrome/common/pref_names.h"
 #include "chromeos/chromeos_switches.h"
 #include "components/prefs/pref_member.h"
 #include "components/sync_preferences/testing_pref_service_syncable.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #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.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"
 #include "ui/events/keycodes/dom/dom_code.h"
 #include "ui/events/keycodes/dom/dom_key.h"
 #include "ui/events/keycodes/dom/keycode_converter.h"
 #include "ui/events/test/events_test_utils.h"
 #include "ui/events/test/test_event_processor.h"
 
 #if defined(USE_X11)
@@ skipping 23 matching lines @@
       static_cast<unsigned int>(code), ui_flags & ~ui::EF_IS_REPEAT, ui_keycode,
       static_cast<unsigned int>(key));
 }
 
 std::string GetKeyEventAsString(const ui::KeyEvent& keyevent) {
   return GetExpectedResultAsString(keyevent.type(), keyevent.key_code(),
                                    keyevent.code(), keyevent.flags(),
                                    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::chromeos::EventRewriter>& 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;
   rewriter->RewriteEvent(event, &new_event);
   if (new_event)
     return GetKeyEventAsString(*new_event->AsKeyEvent());
   return GetKeyEventAsString(event);
 }
 
 // Table entry for simple single key event rewriting tests.
 struct KeyTestCase {
   ui::EventType type;
   struct Event {
     ui::KeyboardCode key_code;
     ui::DomCode code;
     int flags;  // ui::EventFlags
     ui::DomKey::Base key;
   } input, expected;
 };
 
 std::string GetTestCaseAsString(ui::EventType ui_type,
                                 const KeyTestCase::Event& test) {
   return GetExpectedResultAsString(ui_type, test.key_code, test.code,
                                    test.flags, test.key);
 }
 
 // Tests a single stateless key rewrite operation.
-void CheckKeyTestCase(chromeos::EventRewriter* rewriter,
-                      const KeyTestCase& test) {
+void CheckKeyTestCase(
+    const std::unique_ptr<ui::chromeos::EventRewriter>& rewriter,
+    const KeyTestCase& test) {
   SCOPED_TRACE("\nSource:    " + GetTestCaseAsString(test.type, test.input));
   std::string expected = GetTestCaseAsString(test.type, test.expected);
   EXPECT_EQ(expected, GetRewrittenEventAsString(
                           rewriter, test.type, test.input.key_code,
                           test.input.code, test.input.flags, test.input.key));
 }
 
 }  // namespace
 
 namespace chromeos {
 
 class EventRewriterTest : public ash::test::AshTestBase {
  public:
   EventRewriterTest()
       : fake_user_manager_(new chromeos::FakeChromeUserManager),
         user_manager_enabler_(fake_user_manager_) {}
   ~EventRewriterTest() override {}
 
   void SetUp() override {
     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::chromeos::EventRewriter>(delegate_.get(), nullptr);
     AshTestBase::SetUp();
   }
 
   void TearDown() override {
     AshTestBase::TearDown();
     // Shutdown() deletes the IME mock object.
     chromeos::input_method::Shutdown();
   }
 
  protected:
   void TestRewriteNumPadKeys();
   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::chromeos::EventRewriter> 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.
       {ui::ET_KEY_PRESSED,
        {ui::VKEY_A, ui::DomCode::US_A, ui::EF_ALT_DOWN,
         ui::DomKey::UNIDENTIFIED},
        {ui::VKEY_A, ui::DomCode::US_A, ui::EF_ALT_DOWN,
         ui::DomKey::UNIDENTIFIED}},
 
       // VKEY_A, Win modifier.
@@ skipping 18 matching lines @@
         ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN, ui::DomKey::META}},
 
       // VKEY_RWIN (right Windows key), Alt modifier.
       {ui::ET_KEY_PRESSED,
        {ui::VKEY_RWIN, ui::DomCode::META_RIGHT,
         ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN, ui::DomKey::META},
        {ui::VKEY_RWIN, ui::DomCode::META_RIGHT,
         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.
       {ui::ET_KEY_PRESSED,
        {ui::VKEY_A, ui::DomCode::US_A, ui::EF_ALT_DOWN,
         ui::DomKey::UNIDENTIFIED},
        {ui::VKEY_A, ui::DomCode::US_A, ui::EF_ALT_DOWN,
         ui::DomKey::UNIDENTIFIED}},
 
       // VKEY_A, Win modifier.
@@ skipping 18 matching lines @@
         ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN, ui::DomKey::CONTROL}},
 
       // VKEY_RWIN (right Windows key), Alt modifier.
       {ui::ET_KEY_PRESSED,
        {ui::VKEY_RWIN, ui::DomCode::META_RIGHT,
         ui::EF_COMMAND_DOWN | ui::EF_ALT_DOWN, ui::DomKey::META},
        {ui::VKEY_CONTROL, ui::DomCode::CONTROL_RIGHT,
         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.
       {ui::ET_KEY_PRESSED,
        {ui::VKEY_CONTROL, ui::DomCode::CONTROL_LEFT, ui::EF_CONTROL_DOWN,
         ui::DomKey::CONTROL},
        {ui::VKEY_MENU, ui::DomCode::ALT_LEFT, ui::EF_ALT_DOWN,
         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
       // key should never be re-remapped to Alt.
       {ui::ET_KEY_PRESSED,
        {ui::VKEY_LWIN, ui::DomCode::META_LEFT,
         ui::EF_COMMAND_DOWN | ui::EF_ALT_DOWN, ui::DomKey::META},
        {ui::VKEY_CONTROL, ui::DomCode::CONTROL_LEFT,
         ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN, ui::DomKey::CONTROL}},
 
       // VKEY_RWIN (right Command key) with  Alt modifier. The remapped Command
       // key should never be re-remapped to Alt.
       {ui::ET_KEY_PRESSED,
        {ui::VKEY_RWIN, ui::DomCode::META_RIGHT,
         ui::EF_COMMAND_DOWN | ui::EF_ALT_DOWN, ui::DomKey::META},
        {ui::VKEY_CONTROL, ui::DomCode::CONTROL_RIGHT,
         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.
       {ui::ET_KEY_PRESSED,
        {ui::VKEY_INSERT, ui::DomCode::NUMPAD0, ui::EF_NONE, ui::DomKey::INSERT},
        {ui::VKEY_NUMPAD0, ui::DomCode::NUMPAD0, ui::EF_NONE,
         ui::DomKey::Constant<'0'>::Character}},
 
       // XK_KP_Insert (= NumPad 0 without Num Lock), Alt modifier.
       {ui::ET_KEY_PRESSED,
@@ skipping 146 matching lines @@
 
       // XK_KP_9 (= NumPad 9 with Num Lock), Num Lock
       // modifier.
       {ui::ET_KEY_PRESSED,
        {ui::VKEY_NUMPAD9, ui::DomCode::NUMPAD9, ui::EF_NONE,
         ui::DomKey::Constant<'9'>::Character},
        {ui::VKEY_NUMPAD9, ui::DomCode::NUMPAD9, ui::EF_NONE,
         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) {
   TestRewriteNumPadKeys();
 }
 
 TEST_F(EventRewriterTest, TestRewriteNumPadKeysWithDiamondKeyFlag) {
   // Make sure the num lock works correctly even when Diamond key exists.
   base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
       chromeos::switches::kHasChromeOSDiamondKey, "");
   TestRewriteNumPadKeys();
 }
 
 // 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.
       // The result should be "Num Pad 1 with Control + Num Lock modifiers".
       {ui::ET_KEY_PRESSED,
        {ui::VKEY_END, ui::DomCode::NUMPAD1, ui::EF_COMMAND_DOWN,
         ui::DomKey::END},
        {ui::VKEY_NUMPAD1, ui::DomCode::NUMPAD1, ui::EF_CONTROL_DOWN,
         ui::DomKey::Constant<'1'>::Character}},
 
       // XK_KP_1 (= NumPad 1 with Num Lock), Win modifier.
       // The result should also be "Num Pad 1 with Control + Num Lock
       // modifiers".
       {ui::ET_KEY_PRESSED,
        {ui::VKEY_NUMPAD1, ui::DomCode::NUMPAD1, ui::EF_COMMAND_DOWN,
         ui::DomKey::Constant<'1'>::Character},
        {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) {
   TestRewriteNumPadKeysOnAppleKeyboard();
 }
 
 TEST_F(EventRewriterTest,
        TestRewriteNumPadKeysOnAppleKeyboardWithDiamondKeyFlag) {
   // Makes sure the num lock works correctly even when Diamond key exists.
   const base::CommandLine original_cl(*base::CommandLine::ForCurrentProcess());
   base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
       chromeos::switches::kHasChromeOSDiamondKey, "");
 
   TestRewriteNumPadKeysOnAppleKeyboard();
   *base::CommandLine::ForCurrentProcess() = original_cl;
 }
 
 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.
       {ui::ET_KEY_PRESSED,
        {ui::VKEY_LWIN, ui::DomCode::META_LEFT, ui::EF_NONE, ui::DomKey::META},
        {ui::VKEY_LWIN, ui::DomCode::META_LEFT, ui::EF_COMMAND_DOWN,
         ui::DomKey::META}},
 
       // Press left Control. Confirm the event is not rewritten.
       {ui::ET_KEY_PRESSED,
@@ skipping 21 matching lines @@
        {ui::VKEY_MENU, ui::DomCode::ALT_LEFT, ui::EF_ALT_DOWN,
         ui::DomKey::ALT}},
 
       // Test KeyRelease event, just in case.
       // Release Search. Confirm the release event is not rewritten.
       {ui::ET_KEY_RELEASED,
        {ui::VKEY_LWIN, ui::DomCode::META_LEFT, ui::EF_NONE, ui::DomKey::META},
        {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.
       {ui::ET_KEY_PRESSED,
        {ui::VKEY_MENU, ui::DomCode::ALT_LEFT,
         ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN, ui::DomKey::ALT},
        {ui::VKEY_MENU, ui::DomCode::ALT_LEFT,
         ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN, ui::DomKey::ALT}},
 
       // Press Escape with Alt and Shift. Confirm the event is not rewritten.
@@ skipping 33 matching lines @@
        {ui::VKEY_B, ui::DomCode::US_B,
         ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN |
             ui::EF_COMMAND_DOWN,
         ui::DomKey::Constant<'B'>::Character},
        {ui::VKEY_B, ui::DomCode::US_B,
         ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN |
             ui::EF_COMMAND_DOWN,
         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
       // pref. Confirm the event is not rewritten.
       {ui::ET_KEY_PRESSED,
        {ui::VKEY_MENU, ui::DomCode::ALT_LEFT,
         ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN, ui::DomKey::ALT},
        {ui::VKEY_MENU, ui::DomCode::ALT_LEFT,
         ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN, ui::DomKey::ALT}},
 
@@ skipping 34 matching lines @@
 
       // Press Control+Search+Alt+a. Confirm the event is now VKEY_A only with
       // the Alt modifier.
       {ui::ET_KEY_PRESSED,
        {ui::VKEY_A, ui::DomCode::US_A, ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN,
         ui::DomKey::Constant<'a'>::Character},
        {ui::VKEY_A, ui::DomCode::US_A, ui::EF_ALT_DOWN,
         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[] = {
       // Press left Alt. Confirm the event is now VKEY_CONTROL
       // even though the Control key itself is disabled.
       {ui::ET_KEY_PRESSED,
        {ui::VKEY_MENU, ui::DomCode::ALT_LEFT, ui::EF_ALT_DOWN, ui::DomKey::ALT},
        {ui::VKEY_CONTROL, ui::DomCode::CONTROL_LEFT, ui::EF_CONTROL_DOWN,
         ui::DomKey::CONTROL}},
 
       // Press Alt+a. Confirm the event is now Control+a even though the Control
       // key itself is disabled.
       {ui::ET_KEY_PRESSED,
        {ui::VKEY_A, ui::DomCode::US_A, ui::EF_ALT_DOWN,
         ui::DomKey::Constant<'a'>::Character},
        {ui::VKEY_A, ui::DomCode::US_A, ui::EF_CONTROL_DOWN,
         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.
       {ui::ET_KEY_PRESSED,
        {ui::VKEY_LWIN, ui::DomCode::META_LEFT, ui::EF_COMMAND_DOWN,
         ui::DomKey::META},
        {ui::VKEY_CONTROL, ui::DomCode::CONTROL_LEFT, ui::EF_CONTROL_DOWN,
         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[] = {
       // Press Alt. Confirm the event is now VKEY_CONTROL.
       {ui::ET_KEY_PRESSED,
        {ui::VKEY_MENU, ui::DomCode::ALT_LEFT, ui::EF_ALT_DOWN, ui::DomKey::ALT},
        {ui::VKEY_CONTROL, ui::DomCode::CONTROL_LEFT, ui::EF_CONTROL_DOWN,
         ui::DomKey::CONTROL}},
 
       // Press Alt+Search. Confirm the event is now VKEY_CONTROL.
@@ skipping 25 matching lines @@
       // and Control modifiers.
       {ui::ET_KEY_PRESSED,
        {ui::VKEY_B, ui::DomCode::US_B,
         ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN |
             ui::EF_COMMAND_DOWN,
         ui::DomKey::Constant<'B'>::Character},
        {ui::VKEY_B, ui::DomCode::US_B, ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN,
         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.
       {ui::ET_KEY_PRESSED,
        {ui::VKEY_LWIN, ui::DomCode::META_LEFT, ui::EF_COMMAND_DOWN,
         ui::DomKey::META},
        {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.
       {ui::ET_KEY_PRESSED,
        {ui::VKEY_ESCAPE, ui::DomCode::ESCAPE, ui::EF_NONE, ui::DomKey::ESCAPE},
        {ui::VKEY_MENU, ui::DomCode::ALT_LEFT, ui::EF_ALT_DOWN,
         ui::DomKey::ALT}},
       // Release Escape to clear flags.
       {ui::ET_KEY_RELEASED,
        {ui::VKEY_ESCAPE, ui::DomCode::ESCAPE, ui::EF_NONE, ui::DomKey::ESCAPE},
        {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[] = {
       // Press left Alt. Confirm the event is now VKEY_CONTROL.
       {ui::ET_KEY_PRESSED,
        {ui::VKEY_MENU, ui::DomCode::ALT_LEFT, ui::EF_ALT_DOWN, ui::DomKey::ALT},
        {ui::VKEY_CONTROL, ui::DomCode::CONTROL_LEFT, ui::EF_CONTROL_DOWN,
         ui::DomKey::CONTROL}},
       // Press Shift+comma. Verify that only the flags are changed.
       {ui::ET_KEY_PRESSED,
        {ui::VKEY_OEM_COMMA, ui::DomCode::COMMA,
         ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN, ui::DomKey::UNIDENTIFIED},
        {ui::VKEY_OEM_COMMA, ui::DomCode::COMMA,
         ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN,
         ui::DomKey::Constant<'<'>::Character}},
       // Press Shift+9. Verify that only the flags are changed.
       {ui::ET_KEY_PRESSED,
        {ui::VKEY_9, ui::DomCode::DIGIT9, ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN,
         ui::DomKey::UNIDENTIFIED},
        {ui::VKEY_9, ui::DomCode::DIGIT9,
         ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN,
         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[] = {
       // Press left Control. Confirm the event is now VKEY_LWIN.
       {ui::ET_KEY_PRESSED,
        {ui::VKEY_CONTROL, ui::DomCode::CONTROL_LEFT, ui::EF_CONTROL_DOWN,
         ui::DomKey::CONTROL},
        {ui::VKEY_LWIN, ui::DomCode::META_LEFT, ui::EF_COMMAND_DOWN,
         ui::DomKey::META}},
 
@@ skipping 19 matching lines @@
       {ui::ET_KEY_PRESSED,
        {ui::VKEY_B, ui::DomCode::US_B,
         ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN,
         ui::DomKey::Constant<'B'>::Character},
        {ui::VKEY_B, ui::DomCode::US_B,
         ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN |
             ui::EF_COMMAND_DOWN,
         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[] = {
       // Release Control and Escape, as Search and Alt would transform Backspace
       // to Delete.
       {ui::ET_KEY_RELEASED,
        {ui::VKEY_CONTROL, ui::DomCode::CONTROL_LEFT, ui::EF_NONE,
         ui::DomKey::CONTROL},
        {ui::VKEY_LWIN, ui::DomCode::META_LEFT, ui::EF_ALT_DOWN,
         ui::DomKey::META}},
       {ui::ET_KEY_RELEASED,
        {ui::VKEY_ESCAPE, ui::DomCode::ESCAPE, ui::EF_NONE, ui::DomKey::ESCAPE},
        {ui::VKEY_MENU, ui::DomCode::ALT_LEFT, ui::EF_NONE, ui::DomKey::ALT}},
       // Press Search. Confirm the event is now VKEY_BACK.
       {ui::ET_KEY_PRESSED,
        {ui::VKEY_LWIN, ui::DomCode::META_LEFT, ui::EF_COMMAND_DOWN,
         ui::DomKey::META},
        {ui::VKEY_BACK, ui::DomCode::BACKSPACE, ui::EF_NONE,
         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[] = {
       // Press Backspace. Confirm the event is now VKEY_ESCAPE.
       {ui::ET_KEY_PRESSED,
        {ui::VKEY_BACK, ui::DomCode::BACKSPACE, ui::EF_NONE,
         ui::DomKey::BACKSPACE},
        {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.
   EXPECT_TRUE(ime_keyboard.caps_lock_is_enabled_);
 
   // Release Search.
   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.
   EXPECT_TRUE(ime_keyboard.caps_lock_is_enabled_);
 
   // Press Search.
   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));
   // Confirm that the Caps Lock status is changed.
   EXPECT_FALSE(ime_keyboard.caps_lock_is_enabled_);
 
   // Release Search.
   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.
   EXPECT_FALSE(ime_keyboard.caps_lock_is_enabled_);
 
   // Press Caps Lock (on an external keyboard).
   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));
 
 #if defined(USE_X11)
   // Confirm that calling RewriteForTesting() does not change the state of
   // |ime_keyboard|. In this case, X Window system itself should change the
   // Caps Lock state, not ash::EventRewriter.
   EXPECT_FALSE(ime_keyboard.caps_lock_is_enabled_);
 #elif defined(USE_OZONE)
   // Under Ozone the rewriter is responsible for changing the caps lock
   // state when the final key is Caps Lock, regardless of whether the
   // initial key is Caps Lock.
   EXPECT_TRUE(ime_keyboard.caps_lock_is_enabled_);
 #endif
 
   // Release Caps Lock (on an external keyboard).
   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)
   EXPECT_FALSE(ime_keyboard.caps_lock_is_enabled_);
 #elif defined(USE_OZONE)
   EXPECT_TRUE(ime_keyboard.caps_lock_is_enabled_);
 #endif
 }
 
 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
       // specified.
       {ui::ET_KEY_PRESSED,
        {ui::VKEY_F15, ui::DomCode::F15, ui::EF_NONE, ui::DomKey::F15},
        {ui::VKEY_CONTROL, ui::DomCode::CONTROL_LEFT, ui::EF_CONTROL_DOWN,
         ui::DomKey::CONTROL}},
 
       {ui::ET_KEY_RELEASED,
        {ui::VKEY_F15, ui::DomCode::F15, ui::EF_NONE, ui::DomKey::F15},
        {ui::VKEY_CONTROL, ui::DomCode::CONTROL_LEFT, ui::EF_NONE,
         ui::DomKey::CONTROL}},
 
       // However, Mod2Mask should not be rewritten to CtrlMask when
       // --has-chromeos-diamond-key is not specified.
       {ui::ET_KEY_PRESSED,
        {ui::VKEY_A, ui::DomCode::US_A, ui::EF_NONE,
         ui::DomKey::Constant<'a'>::Character},
        {ui::VKEY_A, ui::DomCode::US_A, ui::EF_NONE,
         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) {
   const base::CommandLine original_cl(*base::CommandLine::ForCurrentProcess());
   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));
 
   diamond.SetValue(chromeos::input_method::kControlKey);
 
   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));
 
   diamond.SetValue(chromeos::input_method::kAltKey);
 
   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));
 
   diamond.SetValue(chromeos::input_method::kCapsLockKey);
 
   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.
   EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_PRESSED, ui::VKEY_A,
                                       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));
 
   *base::CommandLine::ForCurrentProcess() = original_cl;
 }
 
 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.
       // On Chrome OS, CapsLock works as a Mod3 modifier.
       {ui::ET_KEY_PRESSED,
        {ui::VKEY_A, ui::DomCode::US_A, ui::EF_MOD3_DOWN,
         ui::DomKey::Constant<'a'>::Character},
        {ui::VKEY_A, ui::DomCode::US_A, ui::EF_CONTROL_DOWN,
         ui::DomKey::Constant<'a'>::Character}},
 
       // Press Control+CapsLock+a. Confirm that Mod3Mask is rewritten to
       // ControlMask
       {ui::ET_KEY_PRESSED,
        {ui::VKEY_A, ui::DomCode::US_A, ui::EF_CONTROL_DOWN | ui::EF_MOD3_DOWN,
         ui::DomKey::Constant<'a'>::Character},
        {ui::VKEY_A, ui::DomCode::US_A, ui::EF_CONTROL_DOWN,
         ui::DomKey::Constant<'a'>::Character}},
 
       // Press Alt+CapsLock+a. Confirm that Mod3Mask is rewritten to
       // ControlMask.
       {ui::ET_KEY_PRESSED,
        {ui::VKEY_A, ui::DomCode::US_A, ui::EF_ALT_DOWN | ui::EF_MOD3_DOWN,
         ui::DomKey::Constant<'a'>::Character},
        {ui::VKEY_A, ui::DomCode::US_A, ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN,
         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
   // when Mod3Mask is already in use by the current XKB layout.
   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));
 
   input_method_manager_mock_->set_mod3_used(false);
 }
 
 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
       {ui::ET_KEY_PRESSED,
        {ui::VKEY_BACK, ui::DomCode::BACKSPACE, ui::EF_ALT_DOWN,
         ui::DomKey::BACKSPACE},
        {ui::VKEY_DELETE, ui::DomCode::DEL, ui::EF_NONE, ui::DomKey::DEL}},
       // Control+Alt+Backspace -> Control+Delete
       {ui::ET_KEY_PRESSED,
        {ui::VKEY_BACK, ui::DomCode::BACKSPACE,
@@ skipping 114 matching lines @@
         ui::DomKey::Constant<'.'>::Character},
        {ui::VKEY_INSERT, ui::DomCode::INSERT, ui::EF_NONE, ui::DomKey::INSERT}},
       // Control+Search+Period -> Control+Insert
       {ui::ET_KEY_PRESSED,
        {ui::VKEY_OEM_PERIOD, ui::DomCode::PERIOD,
         ui::EF_COMMAND_DOWN | ui::EF_CONTROL_DOWN,
         ui::DomKey::Constant<'.'>::Character},
        {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
       {ui::ET_KEY_PRESSED,
        {ui::VKEY_F1, ui::DomCode::F1, ui::EF_NONE, ui::DomKey::F1},
        {ui::VKEY_BROWSER_BACK, ui::DomCode::BROWSER_BACK, ui::EF_NONE,
         ui::DomKey::BROWSER_BACK}},
       {ui::ET_KEY_PRESSED,
        {ui::VKEY_F1, ui::DomCode::F1, ui::EF_CONTROL_DOWN, ui::DomKey::F1},
        {ui::VKEY_BROWSER_BACK, ui::DomCode::BROWSER_BACK, ui::EF_CONTROL_DOWN,
@@ skipping 284 matching lines @@
       {ui::ET_KEY_PRESSED,
        {ui::VKEY_F10, ui::DomCode::F10, ui::EF_COMMAND_DOWN, ui::DomKey::F10},
        {ui::VKEY_F10, ui::DomCode::F10, ui::EF_NONE, ui::DomKey::F10}},
       {ui::ET_KEY_PRESSED,
        {ui::VKEY_F11, ui::DomCode::F11, ui::EF_COMMAND_DOWN, ui::DomKey::F11},
        {ui::VKEY_F11, ui::DomCode::F11, ui::EF_NONE, ui::DomKey::F11}},
       {ui::ET_KEY_PRESSED,
        {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
       {ui::ET_KEY_PRESSED,
        {ui::VKEY_DOWN, ui::DomCode::ARROW_DOWN,
         ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN, ui::DomKey::ARROW_DOWN},
        {ui::VKEY_END, ui::DomCode::END, ui::EF_NONE, ui::DomKey::END}},
 
       // Shift+Alt+Search+Down -> Shift+End
       {ui::ET_KEY_PRESSED,
        {ui::VKEY_DOWN, ui::DomCode::ARROW_DOWN,
         ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN,
         ui::DomKey::ARROW_DOWN},
        {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.
   {
     ui::KeyEvent keyevent(ui::ET_KEY_PRESSED, ui::VKEY_CONTROL,
                           ui::DomCode::CONTROL_LEFT, ui::EF_FINAL,
                           ui::DomKey::CONTROL, ui::EventTimeForNow());
     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)
   // Send left control press, using XI2 native events.
   {
     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.
     ui::KeyEvent keyevent(xev);
     std::unique_ptr<ui::Event> new_event;
     // 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
 }
 
 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);
   ui::TouchEvent press(ui::ET_TOUCH_PRESSED, location, kTouchId,
                        base::TimeTicks());
   press.set_flags(ui::EF_CONTROL_DOWN);
 #if defined(USE_X11)
   ui::UpdateX11EventForFlags(&press);
 #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,
             new_event->flags() & (ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN));
 }
 
 // Keeps a buffer of handled events.
 class EventBuffer : public ui::test::TestEventProcessor {
  public:
   EventBuffer() {}
@@ skipping 69 matching lines @@
   sync_preferences::TestingPrefServiceSyncable* prefs() { return &prefs_; }
 
   void PopEvents(std::vector<std::unique_ptr<ui::Event>>* events) {
     buffer_.PopEvents(events);
   }
 
   void SetUp() override {
     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::chromeos::EventRewriter>(
+        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
     source_.AddEventRewriter(rewriter_.get());
     sticky_keys_controller_->Enable(true);
   }
 
   void TearDown() override {
     rewriter_.reset();
     AshTestBase::TearDown();
   }
 
  protected:
   ash::StickyKeysController* sticky_keys_controller_;
 
  private:
-  std::unique_ptr<EventRewriter> rewriter_;
+  std::unique_ptr<EventRewriterDelegateImpl> delegate_;
+  std::unique_ptr<ui::chromeos::EventRewriter> rewriter_;
 
   EventBuffer buffer_;
   TestEventSource source_;
 
   chromeos::FakeChromeUserManager* fake_user_manager_;  // Not owned.
   chromeos::ScopedUserManagerEnabler user_manager_enabler_;
   sync_preferences::TestingPrefServiceSyncable prefs_;
 
   DISALLOW_COPY_AND_ASSIGN(EventRewriterAshTest);
 };
@@ skipping 35 matching lines @@
             GetKeyEventAsString(*static_cast<ui::KeyEvent*>(events[0].get())));
 }
 
 TEST_F(EventRewriterTest, TestRewrittenModifierClick) {
 #if defined(USE_X11)
   std::vector<int> device_list;
   device_list.push_back(10);
   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.
   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());
   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());
   EXPECT_FALSE(ui::EF_ALT_DOWN & result->flags());
   EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & result->flags());
 #endif
 }
 
 TEST_F(EventRewriterTest, DontRewriteIfNotRewritten) {
 // TODO(kpschoedel): pending changes for crbug.com/360377
-// to |chromeos::EventRewriter::RewriteLocatedEvent()
+// to |ui::chromeos::EventRewriter::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.
   {
     ui::MouseEvent press(ui::ET_MOUSE_PRESSED, gfx::Point(), gfx::Point(),
                          ui::EventTimeForNow(), 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());
     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());
   }
   {
     ui::MouseEvent release(ui::ET_MOUSE_RELEASED, gfx::Point(), gfx::Point(),
                            ui::EventTimeForNow(), kLeftAndAltFlag,
                            ui::EF_LEFT_MOUSE_BUTTON);
     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());
   }
 #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());
     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());
   }
   {
     ui::ScopedXI2Event xev;
     xev.InitGenericButtonEvent(10, ui::ET_MOUSE_RELEASED, gfx::Point(),
                                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());
   }
 #endif
 
   // No ALT in frst click.
   {
     ui::MouseEvent press(ui::ET_MOUSE_PRESSED, gfx::Point(), gfx::Point(),
                          ui::EventTimeForNow(), ui::EF_LEFT_MOUSE_BUTTON,
                          ui::EF_LEFT_MOUSE_BUTTON);
     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());
   }
   {
     ui::MouseEvent release(ui::ET_MOUSE_RELEASED, gfx::Point(), gfx::Point(),
                            ui::EventTimeForNow(), kLeftAndAltFlag,
                            ui::EF_LEFT_MOUSE_BUTTON);
     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());
   }
 #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);
     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());
   }
   {
     ui::ScopedXI2Event xev;
     xev.InitGenericButtonEvent(10, ui::ET_MOUSE_RELEASED, gfx::Point(),
                                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());
   }
 #endif
 
   // ALT on different device.
   {
     ui::MouseEvent press(ui::ET_MOUSE_PRESSED, gfx::Point(), gfx::Point(),
                          ui::EventTimeForNow(), kLeftAndAltFlag,
                          ui::EF_LEFT_MOUSE_BUTTON);
     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());
   }
   {
     ui::MouseEvent release(ui::ET_MOUSE_RELEASED, gfx::Point(), gfx::Point(),
                            ui::EventTimeForNow(), kLeftAndAltFlag,
                            ui::EF_LEFT_MOUSE_BUTTON);
     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());
   }
   {
     ui::MouseEvent release(ui::ET_MOUSE_RELEASED, gfx::Point(), gfx::Point(),
                            ui::EventTimeForNow(), kLeftAndAltFlag,
                            ui::EF_LEFT_MOUSE_BUTTON);
     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());
   }
 #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);
     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());
   }
   {
     ui::ScopedXI2Event xev;
     xev.InitGenericButtonEvent(10, ui::ET_MOUSE_RELEASED, gfx::Point(),
                                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());
   }
   {
     ui::ScopedXI2Event xev;
     xev.InitGenericButtonEvent(11, ui::ET_MOUSE_RELEASED, gfx::Point(),
                                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());
   }
 #endif
 }
 
 TEST_F(EventRewriterAshTest, StickyKeyEventDispatchImpl) {
   // Test the actual key event dispatch implementation.
   std::vector<std::unique_ptr<ui::Event>> events;
@@ skipping 345 matching lines @@
   // Turn off AltGr.
   sticky_keys_controller_->SetModifiersEnabled(true, false);
   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));
 }
 

[sadrul, 2017/03/16 05:04:00]

In a follow-up CL, can you look into moving these tests (at least the ones that
can be extracted without pulling in dependency on chrome or ash) into
ui/chromeos/events/ too?

 }  // namespace chromeos