Move chromeos::EventRewriter to //ui/chromeos/events

ui/chromeos/events/event_rewriter.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 "ui/chromeos/events/event_rewriter.h"
 
 #include <stddef.h>
 
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/sys_info.h"
-#include "chrome/browser/chromeos/login/ui/login_display_host.h"
-#include "chrome/browser/extensions/extension_commands_global_registry.h"
-#include "chrome/browser/profiles/profile_manager.h"
-#include "chrome/browser/ui/webui/chromeos/login/oobe_ui.h"
-#include "chrome/browser/ui/webui/chromeos/login/signin_screen_handler.h"
-#include "chrome/common/pref_names.h"
 #include "chromeos/chromeos_switches.h"
-#include "components/prefs/pref_service.h"
-#include "components/user_manager/user_manager.h"
 #include "ui/base/ime/chromeos/ime_keyboard.h"
 #include "ui/base/ime/chromeos/input_method_manager.h"
+#include "ui/chromeos/events/pref_names.h"
 #include "ui/events/devices/input_device_manager.h"
 #include "ui/events/event.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/keycodes/keyboard_code_conversion.h"
 
 #if defined(USE_X11)
+#include <X11/Xlib.h>
 #include <X11/extensions/XInput2.h>
-#include <X11/Xlib.h>
 
 // Get rid of macros from Xlib.h that conflicts with other parts of the code.
 #undef RootWindow
 #undef Status
 
 #include "ui/base/x/x11_util.h"
 #include "ui/events/keycodes/keyboard_code_conversion_x.h"
 #endif
 
+namespace ui {
 namespace chromeos {
 
 namespace {
 
 // Hotrod controller vendor/product ids.
 const int kHotrodRemoteVendorId = 0x0471;
 const int kHotrodRemoteProductId = 0x21cc;
 const int kUnknownVendorId = -1;
 const int kUnknownProductId = -1;
 
@@ skipping 15 matching lines @@
 // it likewise uses |GetRemappedKey()| to find the properties of the
 // user preference target key, and replaces the flag accordingly.
 const struct ModifierRemapping {
   int flag;
   int remap_to;
   const char* pref_name;
   EventRewriter::MutableKeyState result;
 } kModifierRemappings[] = {
     {// kModifierRemappingCtrl references this entry by index.
      ui::EF_CONTROL_DOWN,
-     input_method::kControlKey,
+     ::chromeos::input_method::kControlKey,
      prefs::kLanguageRemapControlKeyTo,
      {ui::EF_CONTROL_DOWN, ui::DomCode::CONTROL_LEFT, ui::DomKey::CONTROL,
       ui::VKEY_CONTROL}},
     {// kModifierRemappingNeoMod3 references this entry by index.
      ui::EF_MOD3_DOWN | ui::EF_ALTGR_DOWN,
-     input_method::kNumModifierKeys,
+     ::chromeos::input_method::kNumModifierKeys,
      nullptr,
      {ui::EF_MOD3_DOWN | ui::EF_ALTGR_DOWN, ui::DomCode::CAPS_LOCK,
       ui::DomKey::ALT_GRAPH, ui::VKEY_ALTGR}},
     {ui::EF_COMMAND_DOWN,
-     input_method::kSearchKey,
+     ::chromeos::input_method::kSearchKey,
      prefs::kLanguageRemapSearchKeyTo,
      {ui::EF_COMMAND_DOWN, ui::DomCode::META_LEFT, ui::DomKey::META,
       ui::VKEY_LWIN}},
     {ui::EF_ALT_DOWN,
-     input_method::kAltKey,
+     ::chromeos::input_method::kAltKey,
      prefs::kLanguageRemapAltKeyTo,
      {ui::EF_ALT_DOWN, ui::DomCode::ALT_LEFT, ui::DomKey::ALT, ui::VKEY_MENU}},
     {ui::EF_NONE,
-     input_method::kVoidKey,
+     ::chromeos::input_method::kVoidKey,
      nullptr,
      {ui::EF_NONE, ui::DomCode::NONE, ui::DomKey::NONE, ui::VKEY_UNKNOWN}},
     {ui::EF_MOD3_DOWN,
-     input_method::kCapsLockKey,
+     ::chromeos::input_method::kCapsLockKey,
      prefs::kLanguageRemapCapsLockKeyTo,
      {ui::EF_MOD3_DOWN, ui::DomCode::CAPS_LOCK, ui::DomKey::CAPS_LOCK,
       ui::VKEY_CAPITAL}},
     {ui::EF_NONE,
-     input_method::kEscapeKey,
+     ::chromeos::input_method::kEscapeKey,
      prefs::kLanguageRemapEscapeKeyTo,
      {ui::EF_NONE, ui::DomCode::ESCAPE, ui::DomKey::ESCAPE, ui::VKEY_ESCAPE}},
     {ui::EF_NONE,
-     input_method::kBackspaceKey,
+     ::chromeos::input_method::kBackspaceKey,
      prefs::kLanguageRemapBackspaceKeyTo,
      {ui::EF_NONE, ui::DomCode::BACKSPACE, ui::DomKey::BACKSPACE,
       ui::VKEY_BACK}},
     {ui::EF_NONE,
-     input_method::kNumModifierKeys,
+     ::chromeos::input_method::kNumModifierKeys,
      prefs::kLanguageRemapDiamondKeyTo,
      {ui::EF_NONE, ui::DomCode::F15, ui::DomKey::F15, ui::VKEY_F15}}};
 
 const ModifierRemapping* kModifierRemappingCtrl = &kModifierRemappings[0];
 const ModifierRemapping* kModifierRemappingNeoMod3 = &kModifierRemappings[1];
 
 // Gets a remapped key for |pref_name| key. For example, to find out which
 // key Search is currently remapped to, call the function with
 // prefs::kLanguageRemapSearchKeyTo.
 const ModifierRemapping* GetRemappedKey(const std::string& pref_name,
-                                        const PrefService& pref_service) {
+                                        EventRewriter::Delegate* delegate) {
+  if (!delegate)
+    return nullptr;
+
   int value = -1;
-  // If we're at the login screen, try to get the pref from the global prefs
-  // dictionary.
-  if (!LoginDisplayHost::default_host() ||
-      !LoginDisplayHost::default_host()
-           ->GetOobeUI()
-           ->signin_screen_handler()
-           ->GetKeyboardRemappedPrefValue(pref_name, &value)) {
-    if (!pref_service.FindPreference(pref_name))
-      return nullptr;
-    value = pref_service.GetInteger(pref_name);
-  }
+  if (!delegate->GetKeyboardRemappedPrefValue(pref_name, &value))
+    return nullptr;
 
   for (size_t i = 0; i < arraysize(kModifierRemappings); ++i) {
     if (value == kModifierRemappings[i].remap_to)
       return &kModifierRemappings[i];
   }
   return nullptr;
 }
 
 bool HasDiamondKey() {
   return base::CommandLine::ForCurrentProcess()->HasSwitch(
-      chromeos::switches::kHasChromeOSDiamondKey);
+      ::chromeos::switches::kHasChromeOSDiamondKey);
 }
 
 bool IsISOLevel5ShiftUsedByCurrentInputMethod() {
   // Since both German Neo2 XKB layout and Caps Lock depend on Mod3Mask,
   // it's not possible to make both features work. For now, we don't remap
   // Mod3Mask when Neo2 is in use.
   // TODO(yusukes): Remove the restriction.
-  input_method::InputMethodManager* manager =
-      input_method::InputMethodManager::Get();
+  ::chromeos::input_method::InputMethodManager* manager =
+      ::chromeos::input_method::InputMethodManager::Get();
   return manager->IsISOLevel5ShiftUsedByCurrentInputMethod();
 }
 
-bool IsExtensionCommandRegistered(ui::KeyboardCode key_code, int flags) {
-  // Some keyboard events for ChromeOS get rewritten, such as:
-  // Search+Shift+Left gets converted to Shift+Home (BeginDocument).
-  // This doesn't make sense if the user has assigned that shortcut
-  // to an extension. Because:
-  // 1) The extension would, upon seeing a request for Ctrl+Shift+Home have
-  //    to register for Shift+Home, instead.
-  // 2) The conversion is unnecessary, because Shift+Home (BeginDocument) isn't
-  //    going to be executed.
-  // Therefore, we skip converting the accelerator if an extension has
-  // registered for this shortcut.
-  Profile* profile = ProfileManager::GetActiveUserProfile();
-  if (!profile || !extensions::ExtensionCommandsGlobalRegistry::Get(profile))
-    return false;
-
-  int modifiers = flags & (ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN |
-                           ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN);
-  ui::Accelerator accelerator(key_code, modifiers);
-  return extensions::ExtensionCommandsGlobalRegistry::Get(profile)
-      ->IsRegistered(accelerator);
-}
-
 EventRewriter::DeviceType GetDeviceType(const std::string& device_name,
                                         int vendor_id,
                                         int product_id) {
   if (vendor_id == kHotrodRemoteVendorId &&
       product_id == kHotrodRemoteProductId) {
     return EventRewriter::kDeviceHotrodRemote;
   }
 
   if (base::LowerCaseEqualsASCII(device_name, "virtual core keyboard"))
     return EventRewriter::kDeviceVirtualCoreKeyboard;
@@ skipping 95 matching lines @@
     case ui::DomCode::META_RIGHT:
       return right ? ui::DomCode::META_RIGHT : ui::DomCode::META_LEFT;
     default:
       break;
   }
   return code;
 }
 
 }  // namespace
 
-EventRewriter::EventRewriter(ui::EventRewriter* sticky_keys_controller)
+EventRewriter::EventRewriter(Delegate* delegate,
+                             ui::EventRewriter* sticky_keys_controller)
     : last_keyboard_device_id_(ui::ED_UNKNOWN_DEVICE),
       ime_keyboard_for_testing_(NULL),

[sadrul, 2017/03/14 01:15:41]

While you are here: nullptr?

[Peng, 2017/03/14 16:06:52]

Done. And replace all NULL with nullptr.

-      pref_service_for_testing_(NULL),
+      delegate_(delegate),
       sticky_keys_controller_(sticky_keys_controller),
       pressed_modifier_latches_(ui::EF_NONE),
       latched_modifier_latches_(ui::EF_NONE),
       used_modifier_latches_(ui::EF_NONE) {}
 
 EventRewriter::~EventRewriter() {}
 
 EventRewriter::DeviceType EventRewriter::KeyboardDeviceAddedForTesting(
     int device_id,
     const std::string& device_name) {
@@ skipping 74 matching lines @@
 
   // Ignore virtual Xorg keyboard (magic that generates key repeat
   // events). Pretend that the previous real keyboard is the one that is still
   // in use.
   if (type == kDeviceVirtualCoreKeyboard)
     return;
 
   last_keyboard_device_id_ = device_id;
 }
 
-const PrefService* EventRewriter::GetPrefService() const {
-  if (pref_service_for_testing_)
-    return pref_service_for_testing_;
-  Profile* profile = ProfileManager::GetActiveUserProfile();
-  return profile ? profile->GetPrefs() : NULL;
-}
-
 bool EventRewriter::IsAppleKeyboard() const {
   return IsLastKeyboardOfType(kDeviceAppleKeyboard);
 }
 
 bool EventRewriter::IsHotrodRemote() const {
   return IsLastKeyboardOfType(kDeviceHotrodRemote);
 }
 
 bool EventRewriter::IsLastKeyboardOfType(DeviceType device_type) const {
   if (last_keyboard_device_id_ == ui::ED_UNKNOWN_DEVICE)
     return false;
 
   // Check which device generated |event|.
   std::map<int, DeviceType>::const_iterator iter =
       device_id_to_type_.find(last_keyboard_device_id_);
   if (iter == device_id_to_type_.end()) {
     LOG(ERROR) << "Device ID " << last_keyboard_device_id_ << " is unknown.";
     return false;
   }
 
   const DeviceType type = iter->second;
   return type == device_type;
 }
 
-bool EventRewriter::TopRowKeysAreFunctionKeys(const ui::KeyEvent& event) const {
-  const PrefService* prefs = GetPrefService();
-  return prefs && prefs->FindPreference(prefs::kLanguageSendFunctionKeys) &&
-         prefs->GetBoolean(prefs::kLanguageSendFunctionKeys);
-}
-
-int EventRewriter::GetRemappedModifierMasks(const PrefService& pref_service,
-                                            const ui::Event& event,
+int EventRewriter::GetRemappedModifierMasks(const ui::Event& event,
                                             int original_flags) const {
   int unmodified_flags = original_flags;
   int rewritten_flags = pressed_modifier_latches_ | latched_modifier_latches_;
   for (size_t i = 0; unmodified_flags && (i < arraysize(kModifierRemappings));
        ++i) {
     const ModifierRemapping* remapped_key = NULL;
     if (!(unmodified_flags & kModifierRemappings[i].flag))
       continue;
     switch (kModifierRemappings[i].flag) {
       case ui::EF_COMMAND_DOWN:
@@ skipping 18 matching lines @@
         if ((original_flags & ui::EF_ALTGR_DOWN) &&
             IsISOLevel5ShiftUsedByCurrentInputMethod()) {
           remapped_key = kModifierRemappingNeoMod3;
         }
         break;
       default:
         break;
     }
     if (!remapped_key && kModifierRemappings[i].pref_name) {
       remapped_key =
-          GetRemappedKey(kModifierRemappings[i].pref_name, pref_service);
+          GetRemappedKey(kModifierRemappings[i].pref_name, delegate_);
     }
     if (remapped_key) {
       unmodified_flags &= ~kModifierRemappings[i].flag;
       rewritten_flags |= remapped_key->flag;
     }
   }
   return rewritten_flags | unmodified_flags;
 }
 
 ui::EventRewriteStatus EventRewriter::RewriteKeyEvent(
     const ui::KeyEvent& key_event,
     std::unique_ptr<ui::Event>* rewritten_event) {
-  if (IsExtensionCommandRegistered(key_event.key_code(), key_event.flags()))
+  if (delegate_ && delegate_->IsExtensionCommandRegistered(key_event.key_code(),
+                                                           key_event.flags()))
     return ui::EVENT_REWRITE_CONTINUE;
   if (key_event.source_device_id() != ui::ED_UNKNOWN_DEVICE)
     DeviceKeyPressedOrReleased(key_event.source_device_id());
 
   // Drop repeated keys from Hotrod remote.
   if ((key_event.flags() & ui::EF_IS_REPEAT) &&
       (key_event.type() == ui::ET_KEY_PRESSED) && IsHotrodRemote() &&
       key_event.key_code() != ui::VKEY_BACK) {
     return ui::EVENT_REWRITE_DISCARD;
   }
@@ skipping 19 matching lines @@
     tmp_event.set_key_code(state.key_code);
     tmp_event.set_flags(state.flags);
     std::unique_ptr<ui::Event> output_event;
     status = sticky_keys_controller_->RewriteEvent(tmp_event, &output_event);
     if (status == ui::EVENT_REWRITE_REWRITTEN ||
         status == ui::EVENT_REWRITE_DISPATCH_ANOTHER)
       state.flags = output_event->flags();
     if (status == ui::EVENT_REWRITE_DISCARD)
       return ui::EVENT_REWRITE_DISCARD;
     is_sticky_key_extension_command =
-        IsExtensionCommandRegistered(state.key_code, state.flags);
+        delegate_ &&
+        delegate_->IsExtensionCommandRegistered(state.key_code, state.flags);
   }
 
   // If flags have changed, this may change the interpretation of the key,
   // so reapply layout.
   if (state.flags != key_event.flags())
     SetMeaningForLayout(key_event.type(), &state);
 
   // If sticky key rewrites the event, and it matches an extension command, do
   // not further rewrite the event since it won't match the extension command
   // thereafter.
@@ skipping 134 matching lines @@
     ui::UpdateX11EventForFlags(rewritten_event->get());
 #endif
   return status;
 }
 
 bool EventRewriter::RewriteModifierKeys(const ui::KeyEvent& key_event,
                                         MutableKeyState* state) {
   DCHECK(key_event.type() == ui::ET_KEY_PRESSED ||
          key_event.type() == ui::ET_KEY_RELEASED);
 
-  // Do nothing if we have just logged in as guest but have not restarted chrome
-  // process yet (so we are still on the login screen). In this situations we
-  // have no user profile so can not do anything useful.
-  // Note that currently, unlike other accounts, when user logs in as guest, we
-  // restart chrome process. In future this is to be changed.
-  // TODO(glotov): remove the following condition when we do not restart chrome
-  // when user logs in as guest.
-  // TODO(kpschoedel): check whether this is still necessary.
-  if (user_manager::UserManager::Get()->IsLoggedInAsGuest() &&
-      LoginDisplayHost::default_host())
-    return false;
-
-  const PrefService* pref_service = GetPrefService();
-  if (!pref_service)
+  if (!delegate_ || !delegate_->RewriteModifierKeys())
     return false;
 
   // Preserve a copy of the original before rewriting |state| based on
   // user preferences, device configuration, and certain IME properties.
   MutableKeyState incoming = *state;
   state->flags = ui::EF_NONE;
   int characteristic_flag = ui::EF_NONE;
   bool exact_event = false;
 
   // First, remap the key code.
   const ModifierRemapping* remapped_key = NULL;
   // Remapping based on DomKey.
   switch (incoming.key) {
     // On Chrome OS, F15 (XF86XK_Launch6) with NumLock (Mod2Mask) is sent
     // when Diamond key is pressed.
     case ui::DomKey::F15:
       // When diamond key is not available, the configuration UI for Diamond
       // key is not shown. Therefore, ignore the kLanguageRemapDiamondKeyTo
       // syncable pref.
       if (HasDiamondKey())
         remapped_key =
-            GetRemappedKey(prefs::kLanguageRemapDiamondKeyTo, *pref_service);
+            GetRemappedKey(prefs::kLanguageRemapDiamondKeyTo, delegate_);
       // Default behavior of F15 is Control, even if --has-chromeos-diamond-key
       // is absent, according to unit test comments.
       if (!remapped_key) {
         DCHECK_EQ(ui::VKEY_CONTROL, kModifierRemappingCtrl->result.key_code);
         remapped_key = kModifierRemappingCtrl;
       }
       break;
     case ui::DomKey::ALT_GRAPH:
       // The Neo2 codes modifiers such that CapsLock appears as VKEY_ALTGR,
       // but AltGraph (right Alt) also appears as VKEY_ALTGR in Neo2,
       // as it does in other layouts. Neo2's "Mod3" is represented in
       // EventFlags by a combination of AltGr+Mod3, while its "Mod4" is
       // AltGr alone.
       if (IsISOLevel5ShiftUsedByCurrentInputMethod()) {
         if (incoming.code == ui::DomCode::CAPS_LOCK) {
           characteristic_flag = ui::EF_ALTGR_DOWN | ui::EF_MOD3_DOWN;
           remapped_key =
-              GetRemappedKey(prefs::kLanguageRemapCapsLockKeyTo, *pref_service);
+              GetRemappedKey(prefs::kLanguageRemapCapsLockKeyTo, delegate_);
         } else {
           characteristic_flag = ui::EF_ALTGR_DOWN;
           remapped_key =
-              GetRemappedKey(prefs::kLanguageRemapSearchKeyTo, *pref_service);
+              GetRemappedKey(prefs::kLanguageRemapSearchKeyTo, delegate_);
         }
       }
       if (remapped_key && remapped_key->result.key_code == ui::VKEY_CAPITAL)
         remapped_key = kModifierRemappingNeoMod3;
       break;
 #if !defined(USE_X11)
     case ui::DomKey::ALT_GRAPH_LATCH:
       if (key_event.type() == ui::ET_KEY_PRESSED) {
         pressed_modifier_latches_ |= ui::EF_ALTGR_DOWN;
       } else {
@@ skipping 20 matching lines @@
   // Remapping based on DomCode.
   switch (incoming.code) {
     // On Chrome OS, XF86XK_Launch7 (F16) with Mod3Mask is sent when Caps Lock
     // is pressed (with one exception: when
     // IsISOLevel5ShiftUsedByCurrentInputMethod() is true, the key generates
     // XK_ISO_Level3_Shift with Mod3Mask, not XF86XK_Launch7).
     case ui::DomCode::F16:
     case ui::DomCode::CAPS_LOCK:
       characteristic_flag = ui::EF_CAPS_LOCK_ON;
       remapped_key =
-          GetRemappedKey(prefs::kLanguageRemapCapsLockKeyTo, *pref_service);
+          GetRemappedKey(prefs::kLanguageRemapCapsLockKeyTo, delegate_);
       break;
     case ui::DomCode::META_LEFT:
     case ui::DomCode::META_RIGHT:
       characteristic_flag = ui::EF_COMMAND_DOWN;
       // Rewrite Command-L/R key presses on an Apple keyboard to Control.
       if (IsAppleKeyboard()) {
         DCHECK_EQ(ui::VKEY_CONTROL, kModifierRemappingCtrl->result.key_code);
         remapped_key = kModifierRemappingCtrl;
       } else {
         remapped_key =
-            GetRemappedKey(prefs::kLanguageRemapSearchKeyTo, *pref_service);
+            GetRemappedKey(prefs::kLanguageRemapSearchKeyTo, delegate_);
       }
       // Default behavior is Super key, hence don't remap the event if the pref
       // is unavailable.
       break;
     case ui::DomCode::CONTROL_LEFT:
     case ui::DomCode::CONTROL_RIGHT:
       characteristic_flag = ui::EF_CONTROL_DOWN;
       remapped_key =
-          GetRemappedKey(prefs::kLanguageRemapControlKeyTo, *pref_service);
+          GetRemappedKey(prefs::kLanguageRemapControlKeyTo, delegate_);
       break;
     case ui::DomCode::ALT_LEFT:
     case ui::DomCode::ALT_RIGHT:
       // ALT key
       characteristic_flag = ui::EF_ALT_DOWN;
-      remapped_key =
-          GetRemappedKey(prefs::kLanguageRemapAltKeyTo, *pref_service);
+      remapped_key = GetRemappedKey(prefs::kLanguageRemapAltKeyTo, delegate_);
       break;
     case ui::DomCode::ESCAPE:
       remapped_key =
-          GetRemappedKey(prefs::kLanguageRemapEscapeKeyTo, *pref_service);
+          GetRemappedKey(prefs::kLanguageRemapEscapeKeyTo, delegate_);
       break;
     case ui::DomCode::BACKSPACE:
       remapped_key =
-          GetRemappedKey(prefs::kLanguageRemapBackspaceKeyTo, *pref_service);
+          GetRemappedKey(prefs::kLanguageRemapBackspaceKeyTo, delegate_);
       break;
     default:
       break;
   }
 
   if (remapped_key) {
     state->key_code = remapped_key->result.key_code;
     state->code = remapped_key->result.code;
     state->key = remapped_key->result.key;
     incoming.flags |= characteristic_flag;
     characteristic_flag = remapped_key->flag;
-    if (remapped_key->remap_to == input_method::kCapsLockKey)
+    if (remapped_key->remap_to == ::chromeos::input_method::kCapsLockKey)
       characteristic_flag |= ui::EF_CAPS_LOCK_ON;
     state->code = RelocateModifier(
         state->code, ui::KeycodeConverter::DomCodeToLocation(incoming.code));
   }
 
   // Next, remap modifier bits.
-  state->flags |=
-      GetRemappedModifierMasks(*pref_service, key_event, incoming.flags);
+  state->flags |= GetRemappedModifierMasks(key_event, incoming.flags);
 
   // If the DomKey is not a modifier before remapping but is after, set the
   // modifier latches for the later non-modifier key's modifier states.
   bool non_modifier_to_modifier =
       !ui::KeycodeConverter::IsDomKeyForModifier(incoming.key) &&
       ui::KeycodeConverter::IsDomKeyForModifier(state->key);
   if (key_event.type() == ui::ET_KEY_PRESSED) {
     state->flags |= characteristic_flag;
     if (non_modifier_to_modifier)
       pressed_modifier_latches_ |= characteristic_flag;
@@ skipping 12 matching lines @@
     if (state->key_code == ui::VKEY_CAPITAL
         // ... except on linux Chrome OS, where InputMethodChromeOS handles it.
         && (base::SysInfo::IsRunningOnChromeOS() || ime_keyboard_for_testing_)
 #if defined(USE_X11)
         // ... but for X11, do nothing if the original key is ui::VKEY_CAPITAL
         // (i.e. a Caps Lock key on an external keyboard is pressed) since X
         // handles that itself.
         && incoming.key_code != ui::VKEY_CAPITAL
 #endif
         ) {
-      chromeos::input_method::ImeKeyboard* ime_keyboard =
+      ::chromeos::input_method::ImeKeyboard* ime_keyboard =
           ime_keyboard_for_testing_
               ? ime_keyboard_for_testing_
-              : chromeos::input_method::InputMethodManager::Get()
+              : ::chromeos::input_method::InputMethodManager::Get()
                     ->GetImeKeyboard();
       ime_keyboard->SetCapsLockEnabled(!ime_keyboard->CapsLockIsEnabled());
     }
   }
   return exact_event;
 }
 
 void EventRewriter::RewriteNumPadKeys(const ui::KeyEvent& key_event,
                                       MutableKeyState* state) {
   DCHECK(key_event.type() == ui::ET_KEY_PRESSED ||
@@ skipping 135 matching lines @@
 
 void EventRewriter::RewriteFunctionKeys(const ui::KeyEvent& key_event,
                                         MutableKeyState* state) {
   CHECK(key_event.type() == ui::ET_KEY_PRESSED ||
         key_event.type() == ui::ET_KEY_RELEASED);
 
   if ((state->key_code >= ui::VKEY_F1) && (state->key_code <= ui::VKEY_F12)) {
     // By default the top row (F1-F12) keys are system keys for back, forward,
     // brightness, volume, etc. However, windows for v2 apps can optionally
     // request raw function keys for these keys.
-    bool top_row_keys_are_function_keys = TopRowKeysAreFunctionKeys(key_event);
-    bool search_is_pressed = (state->flags & ui::EF_COMMAND_DOWN) != 0;
+    const bool top_row_keys_are_function_keys =
+        delegate_ && delegate_->TopRowKeysAreFunctionKeys();
+    const bool search_is_pressed = (state->flags & ui::EF_COMMAND_DOWN) != 0;
 
     //  Search? Top Row   Result
     //  ------- --------  ------
     //  No      Fn        Unchanged
     //  No      System    Fn -> System
     //  Yes     Fn        Fn -> System
     //  Yes     System    Search+Fn -> Fn
     if (top_row_keys_are_function_keys == search_is_pressed) {
       // Rewrite the F1-F12 keys on a Chromebook keyboard to system keys.
       static const KeyboardRemapping kFkeysToSystemKeys[] = {
@@ skipping 78 matching lines @@
       if (state->code == map.input_dom_code) {
         state->flags &= ~ui::EF_COMMAND_DOWN;
         ApplyRemapping(map.result, state);
         return;
       }
     }
   }
 }
 
 void EventRewriter::RewriteLocatedEvent(const ui::Event& event, int* flags) {
-  const PrefService* pref_service = GetPrefService();
-  if (!pref_service)
+  if (!delegate_)
     return;
-  *flags = GetRemappedModifierMasks(*pref_service, event, *flags);
+  *flags = GetRemappedModifierMasks(event, *flags);
 }
 
 int EventRewriter::RewriteModifierClick(const ui::MouseEvent& mouse_event,
                                         int* flags) {
   // Remap Alt+Button1 to Button3.
   const int kAltLeftButton = (ui::EF_ALT_DOWN | ui::EF_LEFT_MOUSE_BUTTON);
   if (((*flags & kAltLeftButton) == kAltLeftButton) &&
       ((mouse_event.type() == ui::ET_MOUSE_PRESSED) ||
        pressed_device_ids_.count(mouse_event.source_device_id()))) {
     *flags &= ~kAltLeftButton;
@@ skipping 40 matching lines @@
   for (const auto& keyboard : keyboard_devices) {
     if (keyboard.id == device_id) {
       return KeyboardDeviceAddedInternal(
           keyboard.id, keyboard.name, keyboard.vendor_id, keyboard.product_id);
     }
   }
   return kDeviceUnknown;
 }
 
 }  // namespace chromeos
+}  // namespace ui