ui/chromeos/events/event_rewriter.cc - Issue 2724913002: Move chromeos::EventRewriter to //ui/chromeos/events

Unified Diff: ui/chromeos/events/event_rewriter.cc

Issue 2724913002: Move chromeos::EventRewriter to //ui/chromeos/events (Closed)

Patch Set: Fix build error Created 3 years, 10 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

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 5a68721e218eae08058ef9c1c5d5a96fa078ed47..6e479d5bb37ffc2651c65b56f9e0e54b490f9b7b 100644

--- a/chrome/browser/chromeos/events/event_rewriter.cc

+++ b/ui/chromeos/events/event_rewriter.cc

@@ -2,32 +2,22 @@

// 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 "ash/common/wm/window_state.h"

-#include "ash/sticky_keys/sticky_keys_controller.h"

-#include "ash/wm/window_util.h"

#include "base/command_line.h"

#include "base/logging.h"

#include "base/macros.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/pref_names.h"

#include "ui/events/devices/input_device_manager.h"

#include "ui/events/event.h"

#include "ui/events/event_utils.h"

@@ -38,8 +28,8 @@

#include "ui/wm/core/window_util.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

@@ -49,6 +39,7 @@

#include "ui/events/keycodes/keyboard_code_conversion_x.h"

#endif

sadrul 2017/03/03 15:11:41 We should get rid of the USE_X11 code, since it's

Peng 2017/03/03 16:07:05 Sure. I will do it in a separate CL.

+namespace ui {

namespace chromeos {

namespace {

@@ -84,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}}};

@@ -133,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)

@@ -156,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() {

@@ -164,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) {

@@ -306,10 +269,11 @@ ui::DomCode RelocateModifier(ui::DomCode code, ui::DomKeyLocation location) {

} // namespace

-EventRewriter::EventRewriter(ash::StickyKeysController* sticky_keys_controller)

+EventRewriter::EventRewriter(Delegate* delegate,

+ StickyKeysController* sticky_keys_controller)

: last_keyboard_device_id_(ui::ED_UNKNOWN_DEVICE),

ime_keyboard_for_testing_(NULL),

- 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),

@@ -404,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);

}

@@ -435,14 +392,7 @@ 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_;

@@ -481,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;

@@ -494,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());

@@ -528,7 +479,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,

@@ -665,20 +617,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

@@ -700,7 +639,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) {

@@ -718,11 +657,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)

@@ -763,7 +702,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:

@@ -774,7 +713,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.

@@ -783,22 +722,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;

@@ -810,15 +748,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.

@@ -851,10 +788,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());

}

@@ -1010,8 +947,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

// ------- -------- ------

@@ -1110,10 +1048,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,

@@ -1174,3 +1111,4 @@ EventRewriter::DeviceType EventRewriter::KeyboardDeviceAdded(int device_id) {

}

} // namespace chromeos

+} // namespace ui

« ui/chromeos/events/event_rewriter.h ('K') | « ui/chromeos/events/event_rewriter.h ('k') | ui/chromeos/pref_names.h » ('j') | no next file with comments »