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

ui/chromeos/events/event_rewriter.cc

Index: ui/chromeos/events/event_rewriter.cc
diff --git a/chrome/browser/chromeos/events/event_rewriter.cc b/ui/chromeos/events/event_rewriter.cc
similarity index 88%
rename from chrome/browser/chromeos/events/event_rewriter.cc
rename to ui/chromeos/events/event_rewriter.cc
index d622d52f11b2bf35d87509c276640b6c40a715a7..faa85ba1b5cdfa54b9a2306393c0f73a44591456 100644
--- a/chrome/browser/chromeos/events/event_rewriter.cc
+++ b/ui/chromeos/events/event_rewriter.cc
@@ -2,7 +2,7 @@
 // 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>
 
@@ -11,20 +11,14 @@
 #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"
@@ -34,8 +28,8 @@
 #include "ui/events/keycodes/keyboard_code_conversion.h"
 
 #if defined(USE_X11)
-#include <X11/extensions/XInput2.h>
 #include <X11/Xlib.h>
+#include <X11/extensions/XInput2.h>
 
 // Get rid of macros from Xlib.h that conflicts with other parts of the code.
 #undef RootWindow
@@ -45,6 +39,7 @@
 #include "ui/events/keycodes/keyboard_code_conversion_x.h"
 #endif
 
+namespace ui {
 namespace chromeos {
 
 namespace {
@@ -80,45 +75,45 @@ const struct ModifierRemapping {
 } 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}}};
 
@@ -129,19 +124,13 @@ const ModifierRemapping* kModifierRemappingNeoMod3 = &kModifierRemappings[1];
 // 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)
@@ -152,7 +141,7 @@ const ModifierRemapping* GetRemappedKey(const std::string& pref_name,
 
 bool HasDiamondKey() {
   return base::CommandLine::ForCurrentProcess()->HasSwitch(
-      chromeos::switches::kHasChromeOSDiamondKey);
+      ::chromeos::switches::kHasChromeOSDiamondKey);
 }
 
 bool IsISOLevel5ShiftUsedByCurrentInputMethod() {
@@ -160,33 +149,11 @@ bool IsISOLevel5ShiftUsedByCurrentInputMethod() {
   // 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) {
@@ -302,10 +269,11 @@ ui::DomCode RelocateModifier(ui::DomCode code, ui::DomKeyLocation location) {
 
 }  // 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),
-      pref_service_for_testing_(NULL),
+      ime_keyboard_for_testing_(nullptr),
+      delegate_(delegate),
       sticky_keys_controller_(sticky_keys_controller),
       pressed_modifier_latches_(ui::EF_NONE),
       latched_modifier_latches_(ui::EF_NONE),
@@ -400,13 +368,6 @@ void EventRewriter::DeviceKeyPressedOrReleased(int device_id) {
   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);
 }
@@ -431,20 +392,13 @@ bool EventRewriter::IsLastKeyboardOfType(DeviceType device_type) const {
   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;
+    const ModifierRemapping* remapped_key = nullptr;
     if (!(unmodified_flags & kModifierRemappings[i].flag))
       continue;
     switch (kModifierRemappings[i].flag) {
@@ -477,7 +431,7 @@ int EventRewriter::GetRemappedModifierMasks(const PrefService& pref_service,
     }
     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;
@@ -490,7 +444,8 @@ int EventRewriter::GetRemappedModifierMasks(const PrefService& pref_service,
 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());
@@ -530,7 +485,8 @@ ui::EventRewriteStatus EventRewriter::RewriteKeyEvent(
     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,
@@ -685,20 +641,7 @@ bool EventRewriter::RewriteModifierKeys(const ui::KeyEvent& key_event,
   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
@@ -709,7 +652,7 @@ bool EventRewriter::RewriteModifierKeys(const ui::KeyEvent& key_event,
   bool exact_event = false;
 
   // First, remap the key code.
-  const ModifierRemapping* remapped_key = NULL;
+  const ModifierRemapping* remapped_key = nullptr;
   // Remapping based on DomKey.
   switch (incoming.key) {
     // On Chrome OS, F15 (XF86XK_Launch6) with NumLock (Mod2Mask) is sent
@@ -720,7 +663,7 @@ bool EventRewriter::RewriteModifierKeys(const ui::KeyEvent& key_event,
       // 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) {
@@ -738,11 +681,11 @@ bool EventRewriter::RewriteModifierKeys(const ui::KeyEvent& key_event,
         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)
@@ -783,7 +726,7 @@ bool EventRewriter::RewriteModifierKeys(const ui::KeyEvent& key_event,
     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:
@@ -794,7 +737,7 @@ bool EventRewriter::RewriteModifierKeys(const ui::KeyEvent& key_event,
         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.
@@ -803,22 +746,21 @@ bool EventRewriter::RewriteModifierKeys(const ui::KeyEvent& key_event,
     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;
@@ -830,15 +772,14 @@ bool EventRewriter::RewriteModifierKeys(const ui::KeyEvent& key_event,
     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.
@@ -871,10 +812,10 @@ bool EventRewriter::RewriteModifierKeys(const ui::KeyEvent& key_event,
         && 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());
     }
@@ -1030,8 +971,9 @@ void EventRewriter::RewriteFunctionKeys(const ui::KeyEvent& key_event,
     // 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
     //  ------- --------  ------
@@ -1130,10 +1072,9 @@ void EventRewriter::RewriteFunctionKeys(const ui::KeyEvent& key_event,
 }
 
 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,
@@ -1194,3 +1135,4 @@ EventRewriter::DeviceType EventRewriter::KeyboardDeviceAdded(int device_id) {
 }
 
 }  // namespace chromeos
+}  // namespace ui