1 // Copyright 2014 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "chrome/browser/chromeos/events/event_rewriter.h" 6 7 #include <vector> 8 9 #include "ash/sticky_keys/sticky_keys_controller.h" 10 #include "ash/wm/window_state.h" 11 #include "ash/wm/window_util.h" 12 #include "base/command_line.h" 13 #include "base/logging.h" 14 #include "base/macros.h" 15 #include "base/prefs/pref_service.h" 16 #include "base/strings/string_util.h" 17 #include "base/sys_info.h" 18 #include "chrome/browser/chromeos/login/ui/login_display_host_impl.h" 19 #include "chrome/browser/extensions/extension_commands_global_registry.h" 20 #include "chrome/browser/profiles/profile_manager.h" 21 #include "chrome/common/pref_names.h" 22 #include "chromeos/chromeos_switches.h" 23 #include "chromeos/ime/ime_keyboard.h" 24 #include "chromeos/ime/input_method_manager.h" 25 #include "components/user_manager/user_manager.h" 26 #include "ui/events/event.h" 27 #include "ui/events/event_utils.h" 28 #include "ui/events/keycodes/keyboard_code_conversion.h" 29 #include "ui/wm/core/window_util.h" 30 31 #if defined(USE_X11) 32 #include <X11/extensions/XInput2.h> 33 #include <X11/Xlib.h> 34 // Get rid of macros from Xlib.h that conflicts with other parts of the code. 35 #undef RootWindow 36 #undef Status 37 38 #include "ui/base/x/x11_util.h" 39 #include "ui/events/keycodes/keyboard_code_conversion_x.h" 40 #endif 41 42 namespace chromeos { 43 44 namespace { 45 46 // Table of key properties of remappable keys and/or remapping targets. 47 // This is searched in two distinct ways: 48 // - |remap_to| is an |input_method::ModifierKey|, which is the form 49 // held in user preferences. |GetRemappedKey()| maps this to the 50 // corresponding |key_code| and characterstic event |flag|. 51 // - |flag| is a |ui::EventFlags|. |GetRemappedModifierMasks()| maps this 52 // to the corresponding user preference |pref_name| for that flag's 53 // key, so that it can then be remapped as above. 54 // In addition |kModifierRemappingCtrl| is a direct reference to the 55 // Control key entry in the table, used in handling Chromebook Diamond 56 // and Apple Command keys. 57 const struct ModifierRemapping { 58 int remap_to; 59 int flag; 60 ui::KeyboardCode key_code; 61 const char* pref_name; 62 } kModifierRemappings[] = { 63 {input_method::kSearchKey, ui::EF_COMMAND_DOWN, ui::VKEY_LWIN, 64 prefs::kLanguageRemapSearchKeyTo}, 65 {input_method::kControlKey, ui::EF_CONTROL_DOWN, ui::VKEY_CONTROL, 66 prefs::kLanguageRemapControlKeyTo}, 67 {input_method::kAltKey, ui::EF_ALT_DOWN, ui::VKEY_MENU, 68 prefs::kLanguageRemapAltKeyTo}, 69 {input_method::kVoidKey, 0, ui::VKEY_UNKNOWN, NULL}, 70 {input_method::kCapsLockKey, ui::EF_MOD3_DOWN, ui::VKEY_CAPITAL, 71 prefs::kLanguageRemapCapsLockKeyTo}, 72 {input_method::kEscapeKey, 0, ui::VKEY_ESCAPE, NULL}, 73 {0, 0, ui::VKEY_F15, prefs::kLanguageRemapDiamondKeyTo}, 74 }; 75 76 const ModifierRemapping* kModifierRemappingCtrl = &kModifierRemappings[1]; 77 78 // Gets a remapped key for |pref_name| key. For example, to find out which 79 // key Search is currently remapped to, call the function with 80 // prefs::kLanguageRemapSearchKeyTo. 81 const ModifierRemapping* GetRemappedKey(const std::string& pref_name, 82 const PrefService& pref_service) { 83 if (!pref_service.FindPreference(pref_name.c_str())) 84 return NULL; // The |pref_name| hasn't been registered. On login screen? 85 const int value = pref_service.GetInteger(pref_name.c_str()); 86 for (size_t i = 0; i < arraysize(kModifierRemappings); ++i) { 87 if (value == kModifierRemappings[i].remap_to) 88 return &kModifierRemappings[i]; 89 } 90 return NULL; 91 } 92 93 bool HasDiamondKey() { 94 return CommandLine::ForCurrentProcess()->HasSwitch( 95 chromeos::switches::kHasChromeOSDiamondKey); 96 } 97 98 bool IsISOLevel5ShiftUsedByCurrentInputMethod() { 99 // Since both German Neo2 XKB layout and Caps Lock depend on Mod3Mask, 100 // it's not possible to make both features work. For now, we don't remap 101 // Mod3Mask when Neo2 is in use. 102 // TODO(yusukes): Remove the restriction. 103 input_method::InputMethodManager* manager = 104 input_method::InputMethodManager::Get(); 105 return manager->IsISOLevel5ShiftUsedByCurrentInputMethod(); 106 } 107 108 bool IsExtensionCommandRegistered(const ui::KeyEvent& key_event) { 109 // Some keyboard events for ChromeOS get rewritten, such as: 110 // Search+Shift+Left gets converted to Shift+Home (BeginDocument). 111 // This doesn't make sense if the user has assigned that shortcut 112 // to an extension. Because: 113 // 1) The extension would, upon seeing a request for Ctrl+Shift+Home have 114 // to register for Shift+Home, instead. 115 // 2) The conversion is unnecessary, because Shift+Home (BeginDocument) isn't 116 // going to be executed. 117 // Therefore, we skip converting the accelerator if an extension has 118 // registered for this shortcut. 119 Profile* profile = ProfileManager::GetActiveUserProfile(); 120 if (!profile || !extensions::ExtensionCommandsGlobalRegistry::Get(profile)) 121 return false; 122 123 int modifiers = key_event.flags() & (ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN | 124 ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN); 125 ui::Accelerator accelerator(key_event.key_code(), modifiers); 126 return extensions::ExtensionCommandsGlobalRegistry::Get(profile) 127 ->IsRegistered(accelerator); 128 } 129 130 EventRewriter::DeviceType GetDeviceType(const std::string& device_name) { 131 std::vector<std::string> tokens; 132 Tokenize(device_name, " .", &tokens); 133 134 // If the |device_name| contains the two words, "apple" and "keyboard", treat 135 // it as an Apple keyboard. 136 bool found_apple = false; 137 bool found_keyboard = false; 138 for (size_t i = 0; i < tokens.size(); ++i) { 139 if (!found_apple && LowerCaseEqualsASCII(tokens[i], "apple")) 140 found_apple = true; 141 if (!found_keyboard && LowerCaseEqualsASCII(tokens[i], "keyboard")) 142 found_keyboard = true; 143 if (found_apple && found_keyboard) 144 return EventRewriter::kDeviceAppleKeyboard; 145 } 146 147 return EventRewriter::kDeviceUnknown; 148 } 149 150 } // namespace 151 152 EventRewriter::EventRewriter(ash::StickyKeysController* sticky_keys_controller) 153 : last_keyboard_device_id_(ui::ED_UNKNOWN_DEVICE), 154 ime_keyboard_for_testing_(NULL), 155 pref_service_for_testing_(NULL), 156 sticky_keys_controller_(sticky_keys_controller), 157 current_diamond_key_modifier_flags_(ui::EF_NONE) { 158 } 159 160 EventRewriter::~EventRewriter() { 161 } 162 163 EventRewriter::DeviceType EventRewriter::KeyboardDeviceAddedForTesting( 164 int device_id, 165 const std::string& device_name) { 166 // Tests must avoid XI2 reserved device IDs. 167 DCHECK((device_id < 0) || (device_id > 1)); 168 return KeyboardDeviceAddedInternal(device_id, device_name); 169 } 170 171 void EventRewriter::RewriteMouseButtonEventForTesting( 172 const ui::MouseEvent& event, 173 scoped_ptr<ui::Event>* rewritten_event) { 174 RewriteMouseButtonEvent(event, rewritten_event); 175 } 176 177 ui::EventRewriteStatus EventRewriter::RewriteEvent( 178 const ui::Event& event, 179 scoped_ptr<ui::Event>* rewritten_event) { 180 if ((event.type() == ui::ET_KEY_PRESSED) || 181 (event.type() == ui::ET_KEY_RELEASED)) { 182 return RewriteKeyEvent(static_cast<const ui::KeyEvent&>(event), 183 rewritten_event); 184 } 185 if ((event.type() == ui::ET_MOUSE_PRESSED) || 186 (event.type() == ui::ET_MOUSE_RELEASED)) { 187 return RewriteMouseButtonEvent(static_cast<const ui::MouseEvent&>(event), 188 rewritten_event); 189 } 190 if (event.type() == ui::ET_MOUSEWHEEL) { 191 return RewriteMouseWheelEvent( 192 static_cast<const ui::MouseWheelEvent&>(event), rewritten_event); 193 } 194 if ((event.type() == ui::ET_TOUCH_PRESSED) || 195 (event.type() == ui::ET_TOUCH_RELEASED)) { 196 return RewriteTouchEvent(static_cast<const ui::TouchEvent&>(event), 197 rewritten_event); 198 } 199 if (event.IsScrollEvent()) { 200 return RewriteScrollEvent(static_cast<const ui::ScrollEvent&>(event), 201 rewritten_event); 202 } 203 return ui::EVENT_REWRITE_CONTINUE; 204 } 205 206 ui::EventRewriteStatus EventRewriter::NextDispatchEvent( 207 const ui::Event& last_event, 208 scoped_ptr<ui::Event>* new_event) { 209 if (sticky_keys_controller_) { 210 // In the case of sticky keys, we know what the events obtained here are: 211 // modifier key releases that match the ones previously discarded. So, we 212 // know that they don't have to be passed through the post-sticky key 213 // rewriting phases, |RewriteExtendedKeys()| and |RewriteFunctionKeys()|, 214 // because those phases do nothing with modifier key releases. 215 return sticky_keys_controller_->NextDispatchEvent(new_event); 216 } 217 NOTREACHED(); 218 return ui::EVENT_REWRITE_CONTINUE; 219 } 220 221 void EventRewriter::BuildRewrittenKeyEvent( 222 const ui::KeyEvent& key_event, 223 ui::KeyboardCode key_code, 224 int flags, 225 scoped_ptr<ui::Event>* rewritten_event) { 226 ui::KeyEvent* rewritten_key_event = NULL; 227 #if defined(USE_X11) 228 XEvent* xev = key_event.native_event(); 229 if (xev) { 230 XEvent xkeyevent; 231 // Convert all XI2-based key events into X11 core-based key events, 232 // until consumers no longer depend on receiving X11 core events. 233 if (xev->type == GenericEvent) 234 ui::InitXKeyEventFromXIDeviceEvent(*xev, &xkeyevent); 235 else 236 xkeyevent.xkey = xev->xkey; 237 238 unsigned int original_x11_keycode = xkeyevent.xkey.keycode; 239 // Update native event to match rewritten |ui::Event|. 240 // The X11 keycode represents a physical key position, so it shouldn't 241 // change unless we have actually changed keys, not just modifiers. 242 // This is one guard against problems like crbug.com/390263. 243 if (key_event.key_code() != key_code) { 244 xkeyevent.xkey.keycode = 245 XKeyCodeForWindowsKeyCode(key_code, flags, gfx::GetXDisplay()); 246 } 247 ui::KeyEvent x11_key_event(&xkeyevent); 248 rewritten_key_event = new ui::KeyEvent(x11_key_event); 249 250 // For numpad keys, the key char should always NOT be changed because 251 // XKeyCodeForWindowsKeyCode method cannot handle non-US keyboard layout. 252 // The correct key char can be got from original X11 keycode but not for the 253 // rewritten X11 keycode. 254 // For Shift+NumpadKey cases, use the rewritten X11 keycode (US layout). 255 // Please see crbug.com/335644. 256 if (key_code >= ui::VKEY_NUMPAD0 && key_code <= ui::VKEY_DIVIDE) { 257 XEvent numpad_xevent; 258 numpad_xevent.xkey = xkeyevent.xkey; 259 // Remove the shift state before getting key char. 260 // Because X11/XKB sometimes returns unexpected key char for 261 // Shift+NumpadKey. e.g. Shift+Numpad_4 returns 'D', etc. 262 numpad_xevent.xkey.state &= ~ShiftMask; 263 numpad_xevent.xkey.state |= Mod2Mask; // Always set NumLock mask. 264 if (!(flags & ui::EF_SHIFT_DOWN)) 265 numpad_xevent.xkey.keycode = original_x11_keycode; 266 rewritten_key_event->set_character( 267 ui::GetCharacterFromXEvent(&numpad_xevent)); 268 } 269 } 270 #endif 271 if (!rewritten_key_event) 272 rewritten_key_event = new ui::KeyEvent(key_event); 273 rewritten_key_event->set_flags(flags); 274 rewritten_key_event->set_key_code(key_code); 275 #if defined(USE_X11) 276 ui::UpdateX11EventForFlags(rewritten_key_event); 277 rewritten_key_event->NormalizeFlags(); 278 #endif 279 rewritten_event->reset(rewritten_key_event); 280 } 281 282 void EventRewriter::DeviceKeyPressedOrReleased(int device_id) { 283 if (!device_id_to_type_.count(device_id)) 284 KeyboardDeviceAdded(device_id); 285 last_keyboard_device_id_ = device_id; 286 } 287 288 const PrefService* EventRewriter::GetPrefService() const { 289 if (pref_service_for_testing_) 290 return pref_service_for_testing_; 291 Profile* profile = ProfileManager::GetActiveUserProfile(); 292 return profile ? profile->GetPrefs() : NULL; 293 } 294 295 bool EventRewriter::IsAppleKeyboard() const { 296 if (last_keyboard_device_id_ == ui::ED_UNKNOWN_DEVICE) 297 return false; 298 299 // Check which device generated |event|. 300 std::map<int, DeviceType>::const_iterator iter = 301 device_id_to_type_.find(last_keyboard_device_id_); 302 if (iter == device_id_to_type_.end()) { 303 LOG(ERROR) << "Device ID " << last_keyboard_device_id_ << " is unknown."; 304 return false; 305 } 306 307 const DeviceType type = iter->second; 308 return type == kDeviceAppleKeyboard; 309 } 310 311 bool EventRewriter::TopRowKeysAreFunctionKeys(const ui::KeyEvent& event) const { 312 const PrefService* prefs = GetPrefService(); 313 if (prefs && prefs->FindPreference(prefs::kLanguageSendFunctionKeys) && 314 prefs->GetBoolean(prefs::kLanguageSendFunctionKeys)) 315 return true; 316 317 ash::wm::WindowState* state = ash::wm::GetActiveWindowState(); 318 return state ? state->top_row_keys_are_function_keys() : false; 319 } 320 321 int EventRewriter::GetRemappedModifierMasks(const PrefService& pref_service, 322 const ui::Event& event, 323 int original_flags) const { 324 int unmodified_flags = original_flags; 325 int rewritten_flags = current_diamond_key_modifier_flags_; 326 for (size_t i = 0; unmodified_flags && (i < arraysize(kModifierRemappings)); 327 ++i) { 328 const ModifierRemapping* remapped_key = NULL; 329 if (!(unmodified_flags & kModifierRemappings[i].flag)) 330 continue; 331 switch (kModifierRemappings[i].flag) { 332 case ui::EF_COMMAND_DOWN: 333 // Rewrite Command key presses on an Apple keyboard to Control. 334 if (IsAppleKeyboard()) { 335 DCHECK_EQ(ui::EF_CONTROL_DOWN, kModifierRemappingCtrl->flag); 336 remapped_key = kModifierRemappingCtrl; 337 } 338 break; 339 case ui::EF_MOD3_DOWN: 340 // If EF_MOD3_DOWN is used by the current input method, leave it alone; 341 // it is not remappable. 342 if (IsISOLevel5ShiftUsedByCurrentInputMethod()) 343 continue; 344 // Otherwise, Mod3Mask is set on X events when the Caps Lock key 345 // is down, but, if Caps Lock is remapped, CapsLock is NOT set, 346 // because pressing the key does not invoke caps lock. So, the 347 // kModifierRemappings[] table uses EF_MOD3_DOWN for the Caps 348 // Lock remapping. 349 break; 350 default: 351 break; 352 } 353 if (!remapped_key && kModifierRemappings[i].pref_name) { 354 remapped_key = 355 GetRemappedKey(kModifierRemappings[i].pref_name, pref_service); 356 } 357 if (remapped_key) { 358 unmodified_flags &= ~kModifierRemappings[i].flag; 359 rewritten_flags |= remapped_key->flag; 360 } 361 } 362 return rewritten_flags | unmodified_flags; 363 } 364 365 bool EventRewriter::RewriteWithKeyboardRemappingsByKeyCode( 366 const KeyboardRemapping* remappings, 367 size_t num_remappings, 368 const MutableKeyState& input, 369 MutableKeyState* remapped_state) { 370 for (size_t i = 0; i < num_remappings; ++i) { 371 const KeyboardRemapping& map = remappings[i]; 372 if (input.key_code != map.input_key_code) 373 continue; 374 if ((input.flags & map.input_flags) != map.input_flags) 375 continue; 376 remapped_state->key_code = map.output_key_code; 377 remapped_state->flags = (input.flags & ~map.input_flags) | map.output_flags; 378 return true; 379 } 380 return false; 381 } 382 383 ui::EventRewriteStatus EventRewriter::RewriteKeyEvent( 384 const ui::KeyEvent& key_event, 385 scoped_ptr<ui::Event>* rewritten_event) { 386 if (IsExtensionCommandRegistered(key_event)) 387 return ui::EVENT_REWRITE_CONTINUE; 388 if (key_event.source_device_id() != ui::ED_UNKNOWN_DEVICE) 389 DeviceKeyPressedOrReleased(key_event.source_device_id()); 390 MutableKeyState state = {key_event.flags(), key_event.key_code()}; 391 // Do not rewrite an event sent by ui_controls::SendKeyPress(). See 392 // crbug.com/136465. 393 if (!(key_event.flags() & ui::EF_FINAL)) { 394 RewriteModifierKeys(key_event, &state); 395 RewriteNumPadKeys(key_event, &state); 396 } 397 ui::EventRewriteStatus status = ui::EVENT_REWRITE_CONTINUE; 398 if (sticky_keys_controller_) { 399 status = sticky_keys_controller_->RewriteKeyEvent( 400 key_event, state.key_code, &state.flags); 401 if (status == ui::EVENT_REWRITE_DISCARD) 402 return ui::EVENT_REWRITE_DISCARD; 403 } 404 if (!(key_event.flags() & ui::EF_FINAL)) { 405 RewriteExtendedKeys(key_event, &state); 406 RewriteFunctionKeys(key_event, &state); 407 } 408 if ((key_event.flags() == state.flags) && 409 (key_event.key_code() == state.key_code) && 410 #if defined(USE_X11) 411 // TODO(kpschoedel): This test is present because several consumers of 412 // key events depend on having a native core X11 event, so we rewrite 413 // all XI2 key events (GenericEvent) into corresponding core X11 key 414 // events. Remove this when event consumers no longer care about 415 // native X11 event details (crbug.com/380349). 416 (!key_event.HasNativeEvent() || 417 (key_event.native_event()->type != GenericEvent)) && 418 #endif 419 (status == ui::EVENT_REWRITE_CONTINUE)) { 420 return ui::EVENT_REWRITE_CONTINUE; 421 } 422 // Sticky keys may have returned a result other than |EVENT_REWRITE_CONTINUE|, 423 // in which case we need to preserve that return status. Alternatively, we 424 // might be here because key_event changed, in which case we need to 425 // return |EVENT_REWRITE_REWRITTEN|. 426 if (status == ui::EVENT_REWRITE_CONTINUE) 427 status = ui::EVENT_REWRITE_REWRITTEN; 428 BuildRewrittenKeyEvent( 429 key_event, state.key_code, state.flags, rewritten_event); 430 return status; 431 } 432 433 ui::EventRewriteStatus EventRewriter::RewriteMouseButtonEvent( 434 const ui::MouseEvent& mouse_event, 435 scoped_ptr<ui::Event>* rewritten_event) { 436 int flags = mouse_event.flags(); 437 RewriteLocatedEvent(mouse_event, &flags); 438 ui::EventRewriteStatus status = ui::EVENT_REWRITE_CONTINUE; 439 if (sticky_keys_controller_) 440 status = sticky_keys_controller_->RewriteMouseEvent(mouse_event, &flags); 441 int changed_button = ui::EF_NONE; 442 if ((mouse_event.type() == ui::ET_MOUSE_PRESSED) || 443 (mouse_event.type() == ui::ET_MOUSE_RELEASED)) { 444 changed_button = RewriteModifierClick(mouse_event, &flags); 445 } 446 if ((mouse_event.flags() == flags) && 447 (status == ui::EVENT_REWRITE_CONTINUE)) { 448 return ui::EVENT_REWRITE_CONTINUE; 449 } 450 if (status == ui::EVENT_REWRITE_CONTINUE) 451 status = ui::EVENT_REWRITE_REWRITTEN; 452 ui::MouseEvent* rewritten_mouse_event = new ui::MouseEvent(mouse_event); 453 rewritten_event->reset(rewritten_mouse_event); 454 rewritten_mouse_event->set_flags(flags); 455 #if defined(USE_X11) 456 ui::UpdateX11EventForFlags(rewritten_mouse_event); 457 #endif 458 if (changed_button != ui::EF_NONE) { 459 rewritten_mouse_event->set_changed_button_flags(changed_button); 460 #if defined(USE_X11) 461 ui::UpdateX11EventForChangedButtonFlags(rewritten_mouse_event); 462 #endif 463 } 464 return status; 465 } 466 467 ui::EventRewriteStatus EventRewriter::RewriteMouseWheelEvent( 468 const ui::MouseWheelEvent& wheel_event, 469 scoped_ptr<ui::Event>* rewritten_event) { 470 if (!sticky_keys_controller_) 471 return ui::EVENT_REWRITE_CONTINUE; 472 int flags = wheel_event.flags(); 473 ui::EventRewriteStatus status = 474 sticky_keys_controller_->RewriteMouseEvent(wheel_event, &flags); 475 if ((wheel_event.flags() == flags) && 476 (status == ui::EVENT_REWRITE_CONTINUE)) { 477 return ui::EVENT_REWRITE_CONTINUE; 478 } 479 if (status == ui::EVENT_REWRITE_CONTINUE) 480 status = ui::EVENT_REWRITE_REWRITTEN; 481 ui::MouseWheelEvent* rewritten_wheel_event = 482 new ui::MouseWheelEvent(wheel_event); 483 rewritten_event->reset(rewritten_wheel_event); 484 rewritten_wheel_event->set_flags(flags); 485 #if defined(USE_X11) 486 ui::UpdateX11EventForFlags(rewritten_wheel_event); 487 #endif 488 return status; 489 } 490 491 ui::EventRewriteStatus EventRewriter::RewriteTouchEvent( 492 const ui::TouchEvent& touch_event, 493 scoped_ptr<ui::Event>* rewritten_event) { 494 int flags = touch_event.flags(); 495 RewriteLocatedEvent(touch_event, &flags); 496 if (touch_event.flags() == flags) 497 return ui::EVENT_REWRITE_CONTINUE; 498 ui::TouchEvent* rewritten_touch_event = new ui::TouchEvent(touch_event); 499 rewritten_event->reset(rewritten_touch_event); 500 rewritten_touch_event->set_flags(flags); 501 #if defined(USE_X11) 502 ui::UpdateX11EventForFlags(rewritten_touch_event); 503 #endif 504 return ui::EVENT_REWRITE_REWRITTEN; 505 } 506 507 ui::EventRewriteStatus EventRewriter::RewriteScrollEvent( 508 const ui::ScrollEvent& scroll_event, 509 scoped_ptr<ui::Event>* rewritten_event) { 510 int flags = scroll_event.flags(); 511 ui::EventRewriteStatus status = ui::EVENT_REWRITE_CONTINUE; 512 if (sticky_keys_controller_) 513 status = sticky_keys_controller_->RewriteScrollEvent(scroll_event, &flags); 514 if (status == ui::EVENT_REWRITE_CONTINUE) 515 return status; 516 ui::ScrollEvent* rewritten_scroll_event = new ui::ScrollEvent(scroll_event); 517 rewritten_event->reset(rewritten_scroll_event); 518 rewritten_scroll_event->set_flags(flags); 519 #if defined(USE_X11) 520 ui::UpdateX11EventForFlags(rewritten_scroll_event); 521 #endif 522 return status; 523 } 524 525 void EventRewriter::RewriteModifierKeys(const ui::KeyEvent& key_event, 526 MutableKeyState* state) { 527 DCHECK(key_event.type() == ui::ET_KEY_PRESSED || 528 key_event.type() == ui::ET_KEY_RELEASED); 529 530 // Do nothing if we have just logged in as guest but have not restarted chrome 531 // process yet (so we are still on the login screen). In this situations we 532 // have no user profile so can not do anything useful. 533 // Note that currently, unlike other accounts, when user logs in as guest, we 534 // restart chrome process. In future this is to be changed. 535 // TODO(glotov): remove the following condition when we do not restart chrome 536 // when user logs in as guest. 537 // TODO(kpschoedel): check whether this is still necessary. 538 if (user_manager::UserManager::Get()->IsLoggedInAsGuest() && 539 LoginDisplayHostImpl::default_host()) 540 return; 541 542 const PrefService* pref_service = GetPrefService(); 543 if (!pref_service) 544 return; 545 546 MutableKeyState incoming = *state; 547 state->flags = ui::EF_NONE; 548 int characteristic_flag = ui::EF_NONE; 549 550 // First, remap the key code. 551 const ModifierRemapping* remapped_key = NULL; 552 switch (incoming.key_code) { 553 // On Chrome OS, F15 (XF86XK_Launch6) with NumLock (Mod2Mask) is sent 554 // when Diamond key is pressed. 555 case ui::VKEY_F15: 556 // When diamond key is not available, the configuration UI for Diamond 557 // key is not shown. Therefore, ignore the kLanguageRemapDiamondKeyTo 558 // syncable pref. 559 if (HasDiamondKey()) 560 remapped_key = 561 GetRemappedKey(prefs::kLanguageRemapDiamondKeyTo, *pref_service); 562 // Default behavior of F15 is Control, even if --has-chromeos-diamond-key 563 // is absent, according to unit test comments. 564 if (!remapped_key) { 565 DCHECK_EQ(ui::VKEY_CONTROL, kModifierRemappingCtrl->key_code); 566 remapped_key = kModifierRemappingCtrl; 567 } 568 // F15 is not a modifier key, so we need to track its state directly. 569 if (key_event.type() == ui::ET_KEY_PRESSED) { 570 int remapped_flag = remapped_key->flag; 571 if (remapped_key->remap_to == input_method::kCapsLockKey) 572 remapped_flag |= ui::EF_CAPS_LOCK_DOWN; 573 current_diamond_key_modifier_flags_ = remapped_flag; 574 } else { 575 current_diamond_key_modifier_flags_ = ui::EF_NONE; 576 } 577 break; 578 // On Chrome OS, XF86XK_Launch7 (F16) with Mod3Mask is sent when Caps Lock 579 // is pressed (with one exception: when 580 // IsISOLevel5ShiftUsedByCurrentInputMethod() is true, the key generates 581 // XK_ISO_Level3_Shift with Mod3Mask, not XF86XK_Launch7). 582 case ui::VKEY_F16: 583 characteristic_flag = ui::EF_CAPS_LOCK_DOWN; 584 remapped_key = 585 GetRemappedKey(prefs::kLanguageRemapCapsLockKeyTo, *pref_service); 586 break; 587 case ui::VKEY_LWIN: 588 case ui::VKEY_RWIN: 589 characteristic_flag = ui::EF_COMMAND_DOWN; 590 // Rewrite Command-L/R key presses on an Apple keyboard to Control. 591 if (IsAppleKeyboard()) { 592 DCHECK_EQ(ui::VKEY_CONTROL, kModifierRemappingCtrl->key_code); 593 remapped_key = kModifierRemappingCtrl; 594 } else { 595 remapped_key = 596 GetRemappedKey(prefs::kLanguageRemapSearchKeyTo, *pref_service); 597 } 598 // Default behavior is Super key, hence don't remap the event if the pref 599 // is unavailable. 600 break; 601 case ui::VKEY_CONTROL: 602 characteristic_flag = ui::EF_CONTROL_DOWN; 603 remapped_key = 604 GetRemappedKey(prefs::kLanguageRemapControlKeyTo, *pref_service); 605 break; 606 case ui::VKEY_MENU: 607 // ALT key 608 characteristic_flag = ui::EF_ALT_DOWN; 609 remapped_key = 610 GetRemappedKey(prefs::kLanguageRemapAltKeyTo, *pref_service); 611 break; 612 default: 613 break; 614 } 615 616 if (remapped_key) { 617 state->key_code = remapped_key->key_code; 618 incoming.flags |= characteristic_flag; 619 characteristic_flag = remapped_key->flag; 620 } 621 622 // Next, remap modifier bits. 623 state->flags |= 624 GetRemappedModifierMasks(*pref_service, key_event, incoming.flags); 625 if (key_event.type() == ui::ET_KEY_PRESSED) 626 state->flags |= characteristic_flag; 627 else 628 state->flags &= ~characteristic_flag; 629 630 // Toggle Caps Lock if the remapped key is ui::VKEY_CAPITAL, but do nothing if 631 // the original key is ui::VKEY_CAPITAL (i.e. a Caps Lock key on an external 632 // keyboard is pressed) since X can handle that case. 633 if (key_event.type() == ui::ET_KEY_PRESSED && 634 incoming.key_code != ui::VKEY_CAPITAL && 635 state->key_code == ui::VKEY_CAPITAL) { 636 chromeos::input_method::ImeKeyboard* ime_keyboard = 637 ime_keyboard_for_testing_ 638 ? ime_keyboard_for_testing_ 639 : chromeos::input_method::InputMethodManager::Get() 640 ->GetImeKeyboard(); 641 ime_keyboard->SetCapsLockEnabled(!ime_keyboard->CapsLockIsEnabled()); 642 } 643 } 644 645 void EventRewriter::RewriteNumPadKeys(const ui::KeyEvent& key_event, 646 MutableKeyState* state) { 647 DCHECK(key_event.type() == ui::ET_KEY_PRESSED || 648 key_event.type() == ui::ET_KEY_RELEASED); 649 if (!(state->flags & ui::EF_NUMPAD_KEY)) 650 return; 651 MutableKeyState incoming = *state; 652 653 static const KeyboardRemapping kNumPadRemappings[] = { 654 {ui::VKEY_INSERT, ui::EF_NUMPAD_KEY, ui::VKEY_NUMPAD0, ui::EF_NUMPAD_KEY}, 655 {ui::VKEY_DELETE, ui::EF_NUMPAD_KEY, ui::VKEY_DECIMAL, ui::EF_NUMPAD_KEY}, 656 {ui::VKEY_END, ui::EF_NUMPAD_KEY, ui::VKEY_NUMPAD1, ui::EF_NUMPAD_KEY}, 657 {ui::VKEY_DOWN, ui::EF_NUMPAD_KEY, ui::VKEY_NUMPAD2, ui::EF_NUMPAD_KEY}, 658 {ui::VKEY_NEXT, ui::EF_NUMPAD_KEY, ui::VKEY_NUMPAD3, ui::EF_NUMPAD_KEY}, 659 {ui::VKEY_LEFT, ui::EF_NUMPAD_KEY, ui::VKEY_NUMPAD4, ui::EF_NUMPAD_KEY}, 660 {ui::VKEY_CLEAR, ui::EF_NUMPAD_KEY, ui::VKEY_NUMPAD5, ui::EF_NUMPAD_KEY}, 661 {ui::VKEY_RIGHT, ui::EF_NUMPAD_KEY, ui::VKEY_NUMPAD6, ui::EF_NUMPAD_KEY}, 662 {ui::VKEY_HOME, ui::EF_NUMPAD_KEY, ui::VKEY_NUMPAD7, ui::EF_NUMPAD_KEY}, 663 {ui::VKEY_UP, ui::EF_NUMPAD_KEY, ui::VKEY_NUMPAD8, ui::EF_NUMPAD_KEY}, 664 {ui::VKEY_PRIOR, ui::EF_NUMPAD_KEY, ui::VKEY_NUMPAD9, ui::EF_NUMPAD_KEY}, 665 }; 666 667 RewriteWithKeyboardRemappingsByKeyCode( 668 kNumPadRemappings, arraysize(kNumPadRemappings), incoming, state); 669 } 670 671 void EventRewriter::RewriteExtendedKeys(const ui::KeyEvent& key_event, 672 MutableKeyState* state) { 673 DCHECK(key_event.type() == ui::ET_KEY_PRESSED || 674 key_event.type() == ui::ET_KEY_RELEASED); 675 676 MutableKeyState incoming = *state; 677 bool rewritten = false; 678 679 if ((incoming.flags & (ui::EF_COMMAND_DOWN | ui::EF_ALT_DOWN)) == 680 (ui::EF_COMMAND_DOWN | ui::EF_ALT_DOWN)) { 681 // Allow Search to avoid rewriting extended keys. 682 static const KeyboardRemapping kAvoidRemappings[] = { 683 { // Alt+Backspace 684 ui::VKEY_BACK, ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN, ui::VKEY_BACK, 685 ui::EF_ALT_DOWN, 686 }, 687 { // Control+Alt+Up 688 ui::VKEY_UP, 689 ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN | ui::EF_COMMAND_DOWN, 690 ui::VKEY_UP, ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN, 691 }, 692 { // Alt+Up 693 ui::VKEY_UP, ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN, ui::VKEY_UP, 694 ui::EF_ALT_DOWN, 695 }, 696 { // Control+Alt+Down 697 ui::VKEY_DOWN, 698 ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN | ui::EF_COMMAND_DOWN, 699 ui::VKEY_DOWN, ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN, 700 }, 701 { // Alt+Down 702 ui::VKEY_DOWN, ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN, ui::VKEY_DOWN, 703 ui::EF_ALT_DOWN, 704 }}; 705 706 rewritten = RewriteWithKeyboardRemappingsByKeyCode( 707 kAvoidRemappings, arraysize(kAvoidRemappings), incoming, state); 708 } 709 710 if (!rewritten && (incoming.flags & ui::EF_COMMAND_DOWN)) { 711 static const KeyboardRemapping kSearchRemappings[] = { 712 { // Search+BackSpace -> Delete 713 ui::VKEY_BACK, ui::EF_COMMAND_DOWN, ui::VKEY_DELETE, 0}, 714 { // Search+Left -> Home 715 ui::VKEY_LEFT, ui::EF_COMMAND_DOWN, ui::VKEY_HOME, 0}, 716 { // Search+Up -> Prior (aka PageUp) 717 ui::VKEY_UP, ui::EF_COMMAND_DOWN, ui::VKEY_PRIOR, 0}, 718 { // Search+Right -> End 719 ui::VKEY_RIGHT, ui::EF_COMMAND_DOWN, ui::VKEY_END, 0}, 720 { // Search+Down -> Next (aka PageDown) 721 ui::VKEY_DOWN, ui::EF_COMMAND_DOWN, ui::VKEY_NEXT, 0}, 722 { // Search+Period -> Insert 723 ui::VKEY_OEM_PERIOD, ui::EF_COMMAND_DOWN, ui::VKEY_INSERT, 0}}; 724 725 rewritten = RewriteWithKeyboardRemappingsByKeyCode( 726 kSearchRemappings, arraysize(kSearchRemappings), incoming, state); 727 } 728 729 if (!rewritten && (incoming.flags & ui::EF_ALT_DOWN)) { 730 static const KeyboardRemapping kNonSearchRemappings[] = { 731 { // Alt+BackSpace -> Delete 732 ui::VKEY_BACK, ui::EF_ALT_DOWN, ui::VKEY_DELETE, 0}, 733 { // Control+Alt+Up -> Home 734 ui::VKEY_UP, ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN, ui::VKEY_HOME, 0}, 735 { // Alt+Up -> Prior (aka PageUp) 736 ui::VKEY_UP, ui::EF_ALT_DOWN, ui::VKEY_PRIOR, 0}, 737 { // Control+Alt+Down -> End 738 ui::VKEY_DOWN, ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN, ui::VKEY_END, 0}, 739 { // Alt+Down -> Next (aka PageDown) 740 ui::VKEY_DOWN, ui::EF_ALT_DOWN, ui::VKEY_NEXT, 0}}; 741 742 rewritten = RewriteWithKeyboardRemappingsByKeyCode( 743 kNonSearchRemappings, arraysize(kNonSearchRemappings), incoming, state); 744 } 745 } 746 747 void EventRewriter::RewriteFunctionKeys(const ui::KeyEvent& key_event, 748 MutableKeyState* state) { 749 CHECK(key_event.type() == ui::ET_KEY_PRESSED || 750 key_event.type() == ui::ET_KEY_RELEASED); 751 MutableKeyState incoming = *state; 752 bool rewritten = false; 753 754 if ((incoming.key_code >= ui::VKEY_F1) && 755 (incoming.key_code <= ui::VKEY_F24)) { 756 // By default the top row (F1-F12) keys are system keys for back, forward, 757 // brightness, volume, etc. However, windows for v2 apps can optionally 758 // request raw function keys for these keys. 759 bool top_row_keys_are_function_keys = TopRowKeysAreFunctionKeys(key_event); 760 bool search_is_pressed = (incoming.flags & ui::EF_COMMAND_DOWN) != 0; 761 762 // Search? Top Row Result 763 // ------- -------- ------ 764 // No Fn Unchanged 765 // No System Fn -> System 766 // Yes Fn Fn -> System 767 // Yes System Search+Fn -> Fn 768 if (top_row_keys_are_function_keys == search_is_pressed) { 769 // Rewrite the F1-F12 keys on a Chromebook keyboard to system keys. 770 static const KeyboardRemapping kFkeysToSystemKeys[] = { 771 {ui::VKEY_F1, 0, ui::VKEY_BROWSER_BACK, 0}, 772 {ui::VKEY_F2, 0, ui::VKEY_BROWSER_FORWARD, 0}, 773 {ui::VKEY_F3, 0, ui::VKEY_BROWSER_REFRESH, 0}, 774 {ui::VKEY_F4, 0, ui::VKEY_MEDIA_LAUNCH_APP2, 0}, 775 {ui::VKEY_F5, 0, ui::VKEY_MEDIA_LAUNCH_APP1, 0}, 776 {ui::VKEY_F6, 0, ui::VKEY_BRIGHTNESS_DOWN, 0}, 777 {ui::VKEY_F7, 0, ui::VKEY_BRIGHTNESS_UP, 0}, 778 {ui::VKEY_F8, 0, ui::VKEY_VOLUME_MUTE, 0}, 779 {ui::VKEY_F9, 0, ui::VKEY_VOLUME_DOWN, 0}, 780 {ui::VKEY_F10, 0, ui::VKEY_VOLUME_UP, 0}, 781 }; 782 MutableKeyState incoming_without_command = incoming; 783 incoming_without_command.flags &= ~ui::EF_COMMAND_DOWN; 784 rewritten = 785 RewriteWithKeyboardRemappingsByKeyCode(kFkeysToSystemKeys, 786 arraysize(kFkeysToSystemKeys), 787 incoming_without_command, 788 state); 789 } else if (search_is_pressed) { 790 // Allow Search to avoid rewriting F1-F12. 791 state->flags &= ~ui::EF_COMMAND_DOWN; 792 rewritten = true; 793 } 794 } 795 796 if (!rewritten && (incoming.flags & ui::EF_COMMAND_DOWN)) { 797 // Remap Search+<number> to F<number>. 798 // We check the keycode here instead of the keysym, as these keys have 799 // different keysyms when modifiers are pressed, such as shift. 800 801 // TODO(danakj): On some i18n keyboards, these choices will be bad and we 802 // should make layout-specific choices here. For eg. on a french keyboard 803 // "-" and "6" are the same key, so F11 will not be accessible. 804 static const KeyboardRemapping kNumberKeysToFkeys[] = { 805 {ui::VKEY_1, ui::EF_COMMAND_DOWN, ui::VKEY_F1, 0}, 806 {ui::VKEY_2, ui::EF_COMMAND_DOWN, ui::VKEY_F2, 0}, 807 {ui::VKEY_3, ui::EF_COMMAND_DOWN, ui::VKEY_F3, 0}, 808 {ui::VKEY_4, ui::EF_COMMAND_DOWN, ui::VKEY_F4, 0}, 809 {ui::VKEY_5, ui::EF_COMMAND_DOWN, ui::VKEY_F5, 0}, 810 {ui::VKEY_6, ui::EF_COMMAND_DOWN, ui::VKEY_F6, 0}, 811 {ui::VKEY_7, ui::EF_COMMAND_DOWN, ui::VKEY_F7, 0}, 812 {ui::VKEY_8, ui::EF_COMMAND_DOWN, ui::VKEY_F8, 0}, 813 {ui::VKEY_9, ui::EF_COMMAND_DOWN, ui::VKEY_F9, 0}, 814 {ui::VKEY_0, ui::EF_COMMAND_DOWN, ui::VKEY_F10, 0}, 815 {ui::VKEY_OEM_MINUS, ui::EF_COMMAND_DOWN, ui::VKEY_F11, 0}, 816 {ui::VKEY_OEM_PLUS, ui::EF_COMMAND_DOWN, ui::VKEY_F12, 0}}; 817 rewritten = RewriteWithKeyboardRemappingsByKeyCode( 818 kNumberKeysToFkeys, arraysize(kNumberKeysToFkeys), incoming, state); 819 } 820 } 821 822 void EventRewriter::RewriteLocatedEvent(const ui::Event& event, 823 int* flags) { 824 const PrefService* pref_service = GetPrefService(); 825 if (!pref_service) 826 return; 827 *flags = GetRemappedModifierMasks(*pref_service, event, *flags); 828 } 829 830 int EventRewriter::RewriteModifierClick(const ui::MouseEvent& mouse_event, 831 int* flags) { 832 // Remap Alt+Button1 to Button3. 833 const int kAltLeftButton = (ui::EF_ALT_DOWN | ui::EF_LEFT_MOUSE_BUTTON); 834 if (((*flags & kAltLeftButton) == kAltLeftButton) && 835 ((mouse_event.type() == ui::ET_MOUSE_PRESSED) || 836 pressed_device_ids_.count(mouse_event.source_device_id()))) { 837 *flags &= ~kAltLeftButton; 838 *flags |= ui::EF_RIGHT_MOUSE_BUTTON; 839 if (mouse_event.type() == ui::ET_MOUSE_PRESSED) 840 pressed_device_ids_.insert(mouse_event.source_device_id()); 841 else 842 pressed_device_ids_.erase(mouse_event.source_device_id()); 843 return ui::EF_RIGHT_MOUSE_BUTTON; 844 } 845 return ui::EF_NONE; 846 } 847 848 EventRewriter::DeviceType EventRewriter::KeyboardDeviceAddedInternal( 849 int device_id, 850 const std::string& device_name) { 851 const DeviceType type = GetDeviceType(device_name); 852 if (type == kDeviceAppleKeyboard) { 853 VLOG(1) << "Apple keyboard '" << device_name << "' connected: " 854 << "id=" << device_id; 855 } 856 // Always overwrite the existing device_id since the X server may reuse a 857 // device id for an unattached device. 858 device_id_to_type_[device_id] = type; 859 return type; 860 } 861 862 void EventRewriter::KeyboardDeviceAdded(int device_id) { 863 #if defined(USE_X11) 864 DCHECK_NE(XIAllDevices, device_id); 865 DCHECK_NE(XIAllMasterDevices, device_id); 866 if (device_id == XIAllDevices || device_id == XIAllMasterDevices) { 867 LOG(ERROR) << "Unexpected device_id passed: " << device_id; 868 return; 869 } 870 871 int ndevices_return = 0; 872 XIDeviceInfo* device_info = 873 XIQueryDevice(gfx::GetXDisplay(), device_id, &ndevices_return); 874 875 // Since |device_id| is neither XIAllDevices nor XIAllMasterDevices, 876 // the number of devices found should be either 0 (not found) or 1. 877 if (!device_info) { 878 LOG(ERROR) << "XIQueryDevice: Device ID " << device_id << " is unknown."; 879 return; 880 } 881 882 DCHECK_EQ(1, ndevices_return); 883 for (int i = 0; i < ndevices_return; ++i) { 884 DCHECK_EQ(device_id, device_info[i].deviceid); // see the comment above. 885 DCHECK(device_info[i].name); 886 KeyboardDeviceAddedInternal(device_info[i].deviceid, device_info[i].name); 887 } 888 889 XIFreeDeviceInfo(device_info); 890 #else 891 KeyboardDeviceAddedInternal(device_id, "keyboard"); 892 #endif 893 } 894 895 } // namespace chromeos 896
