src/ash/accelerators/accelerator_controller.cc

   1 // Copyright (c) 2012 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 "ash/accelerators/accelerator_controller.h"
   6
   7 #include <algorithm>
   8 #include <cmath>
   9 #include <string>
  10
  11 #include "ash/accelerators/accelerator_commands.h"
  12 #include "ash/accelerators/accelerator_table.h"
  13 #include "ash/accelerators/debug_commands.h"
  14 #include "ash/ash_switches.h"
  15 #include "ash/debug.h"
  16 #include "ash/display/display_controller.h"
  17 #include "ash/display/display_manager.h"
  18 #include "ash/focus_cycler.h"
  19 #include "ash/gpu_support.h"
  20 #include "ash/host/ash_window_tree_host.h"
  21 #include "ash/ime_control_delegate.h"
  22 #include "ash/magnifier/magnification_controller.h"
  23 #include "ash/magnifier/partial_magnification_controller.h"
  24 #include "ash/media_delegate.h"
  25 #include "ash/multi_profile_uma.h"
  26 #include "ash/new_window_delegate.h"
  27 #include "ash/root_window_controller.h"
  28 #include "ash/rotator/screen_rotation.h"
  29 #include "ash/screenshot_delegate.h"
  30 #include "ash/session/session_state_delegate.h"
  31 #include "ash/shelf/shelf.h"
  32 #include "ash/shelf/shelf_delegate.h"
  33 #include "ash/shelf/shelf_model.h"
  34 #include "ash/shelf/shelf_widget.h"
  35 #include "ash/shell.h"
  36 #include "ash/shell_delegate.h"
  37 #include "ash/shell_window_ids.h"
  38 #include "ash/system/brightness_control_delegate.h"
  39 #include "ash/system/keyboard_brightness/keyboard_brightness_control_delegate.h"
  40 #include "ash/system/status_area_widget.h"
  41 #include "ash/system/tray/system_tray.h"
  42 #include "ash/system/tray/system_tray_delegate.h"
  43 #include "ash/system/tray/system_tray_notifier.h"
  44 #include "ash/system/web_notification/web_notification_tray.h"
  45 #include "ash/touch/touch_hud_debug.h"
  46 #include "ash/volume_control_delegate.h"
  47 #include "ash/wm/maximize_mode/maximize_mode_controller.h"
  48 #include "ash/wm/mru_window_tracker.h"
  49 #include "ash/wm/overview/window_selector_controller.h"
  50 #include "ash/wm/partial_screenshot_view.h"
  51 #include "ash/wm/power_button_controller.h"
  52 #include "ash/wm/window_cycle_controller.h"
  53 #include "ash/wm/window_state.h"
  54 #include "ash/wm/window_util.h"
  55 #include "ash/wm/wm_event.h"
  56 #include "base/bind.h"
  57 #include "base/command_line.h"
  58 #include "base/metrics/user_metrics.h"
  59 #include "ui/aura/env.h"
  60 #include "ui/aura/window_event_dispatcher.h"
  61 #include "ui/base/accelerators/accelerator.h"
  62 #include "ui/base/accelerators/accelerator_manager.h"
  63 #include "ui/compositor/debug_utils.h"
  64 #include "ui/compositor/layer.h"
  65 #include "ui/compositor/layer_animation_sequence.h"
  66 #include "ui/compositor/layer_animator.h"
  67 #include "ui/events/event.h"
  68 #include "ui/events/keycodes/keyboard_codes.h"
  69 #include "ui/gfx/screen.h"
  70 #include "ui/views/controls/webview/webview.h"
  71 #include "ui/views/debug_utils.h"
  72 #include "ui/views/widget/widget.h"
  73
  74 #if defined(OS_CHROMEOS)
  75 #include "ash/system/chromeos/keyboard_brightness_controller.h"
  76 #include "base/sys_info.h"
  77 #include "chromeos/ime/ime_keyboard.h"
  78 #include "chromeos/ime/input_method_manager.h"
  79 #endif  // defined(OS_CHROMEOS)
  80
  81 namespace ash {
  82 namespace {
  83
  84 using base::UserMetricsAction;
  85
  86 bool DebugShortcutsEnabled() {
  87 #if defined(NDEBUG)
  88   return CommandLine::ForCurrentProcess()->HasSwitch(
  89           switches::kAshDebugShortcuts);
  90 #else
  91   return true;
  92 #endif
  93 }
  94
  95 bool HandleAccessibleFocusCycle(bool reverse) {
  96   if (reverse) {
  97     base::RecordAction(UserMetricsAction("Accel_Accessible_Focus_Previous"));
  98   } else {
  99     base::RecordAction(UserMetricsAction("Accel_Accessible_Focus_Next"));
 100   }
 101
 102   if (!Shell::GetInstance()->accessibility_delegate()->
 103       IsSpokenFeedbackEnabled()) {
 104     return false;
 105   }
 106   aura::Window* active_window = ash::wm::GetActiveWindow();
 107   if (!active_window)
 108     return false;
 109   views::Widget* widget =
 110       views::Widget::GetWidgetForNativeWindow(active_window);
 111   if (!widget)
 112     return false;
 113   views::FocusManager* focus_manager = widget->GetFocusManager();
 114   if (!focus_manager)
 115     return false;
 116   views::View* view = focus_manager->GetFocusedView();
 117   if (!view)
 118     return false;
 119   if (!strcmp(view->GetClassName(), views::WebView::kViewClassName))
 120     return false;
 121
 122   focus_manager->AdvanceFocus(reverse);
 123   return true;
 124 }
 125
 126 bool HandleCycleBackwardMRU(const ui::Accelerator& accelerator) {
 127   if (accelerator.key_code() == ui::VKEY_TAB)
 128     base::RecordAction(base::UserMetricsAction("Accel_PrevWindow_Tab"));
 129
 130   Shell::GetInstance()->window_cycle_controller()->HandleCycleWindow(
 131       WindowCycleController::BACKWARD);
 132   return true;
 133 }
 134
 135 bool HandleCycleForwardMRU(const ui::Accelerator& accelerator) {
 136   if (accelerator.key_code() == ui::VKEY_TAB)
 137     base::RecordAction(base::UserMetricsAction("Accel_NextWindow_Tab"));
 138
 139   Shell::GetInstance()->window_cycle_controller()->HandleCycleWindow(
 140       WindowCycleController::FORWARD);
 141   return true;
 142 }
 143
 144 bool ToggleOverview(const ui::Accelerator& accelerator) {
 145   base::RecordAction(base::UserMetricsAction("Accel_Overview_F5"));
 146   Shell::GetInstance()->window_selector_controller()->ToggleOverview();
 147   return true;
 148 }
 149
 150 bool HandleFocusShelf() {
 151   Shell* shell = Shell::GetInstance();
 152   base::RecordAction(base::UserMetricsAction("Accel_Focus_Shelf"));
 153   return shell->focus_cycler()->FocusWidget(
 154       Shelf::ForPrimaryDisplay()->shelf_widget());
 155 }
 156
 157 bool HandleLaunchAppN(int n) {
 158   base::RecordAction(UserMetricsAction("Accel_Launch_App"));
 159   Shelf::ForPrimaryDisplay()->LaunchAppIndexAt(n);
 160   return true;
 161 }
 162
 163 bool HandleLaunchLastApp() {
 164   base::RecordAction(UserMetricsAction("Accel_Launch_Last_App"));
 165   Shelf::ForPrimaryDisplay()->LaunchAppIndexAt(-1);
 166   return true;
 167 }
 168
 169 // Magnify the screen
 170 bool HandleMagnifyScreen(int delta_index) {
 171   if (ash::Shell::GetInstance()->magnification_controller()->IsEnabled()) {
 172     // TODO(yoshiki): Move the following logic to MagnificationController.
 173     float scale =
 174         ash::Shell::GetInstance()->magnification_controller()->GetScale();
 175     // Calculate rounded logarithm (base kMagnificationScaleFactor) of scale.
 176     int scale_index =
 177         std::floor(std::log(scale) / std::log(kMagnificationScaleFactor) + 0.5);
 178
 179     int new_scale_index = std::max(0, std::min(8, scale_index + delta_index));
 180
 181     ash::Shell::GetInstance()->magnification_controller()->
 182         SetScale(std::pow(kMagnificationScaleFactor, new_scale_index), true);
 183   } else if (ash::Shell::GetInstance()->
 184              partial_magnification_controller()->is_enabled()) {
 185     float scale = delta_index > 0 ? kDefaultPartialMagnifiedScale : 1;
 186     ash::Shell::GetInstance()->partial_magnification_controller()->
 187         SetScale(scale);
 188   }
 189
 190   return true;
 191 }
 192
 193 bool HandleMediaNextTrack() {
 194   Shell::GetInstance()->media_delegate()->HandleMediaNextTrack();
 195   return true;
 196 }
 197
 198 bool HandleMediaPlayPause() {
 199   Shell::GetInstance()->media_delegate()->HandleMediaPlayPause();
 200   return true;
 201 }
 202
 203 bool HandleMediaPrevTrack() {
 204   Shell::GetInstance()->media_delegate()->HandleMediaPrevTrack();
 205   return true;
 206 }
 207
 208 bool HandleNewIncognitoWindow() {
 209   base::RecordAction(UserMetricsAction("Accel_New_Incognito_Window"));
 210   bool incognito_allowed =
 211     Shell::GetInstance()->delegate()->IsIncognitoAllowed();
 212   if (incognito_allowed)
 213     Shell::GetInstance()->new_window_delegate()->NewWindow(
 214         true /* is_incognito */);
 215   return incognito_allowed;
 216 }
 217
 218 bool HandleNewTab(ui::KeyboardCode key_code) {
 219   if (key_code == ui::VKEY_T)
 220     base::RecordAction(base::UserMetricsAction("Accel_NewTab_T"));
 221   Shell::GetInstance()->new_window_delegate()->NewTab();
 222   return true;
 223 }
 224
 225 bool HandleNewWindow() {
 226   base::RecordAction(base::UserMetricsAction("Accel_New_Window"));
 227   Shell::GetInstance()->new_window_delegate()->NewWindow(
 228       false /* is_incognito */);
 229   return true;
 230 }
 231
 232 void HandleNextIme(ImeControlDelegate* ime_control_delegate,
 233                    ui::EventType previous_event_type,
 234                    ui::KeyboardCode previous_key_code) {
 235   // This check is necessary e.g. not to process the Shift+Alt+
 236   // ET_KEY_RELEASED accelerator for Chrome OS (see ash/accelerators/
 237   // accelerator_controller.cc) when Shift+Alt+Tab is pressed and then Tab
 238   // is released.
 239   if (previous_event_type == ui::ET_KEY_RELEASED &&
 240       // Workaround for crbug.com/139556. CJK IME users tend to press
 241       // Enter (or Space) and Shift+Alt almost at the same time to commit
 242       // an IME string and then switch from the IME to the English layout.
 243       // This workaround allows the user to trigger NEXT_IME even if the
 244       // user presses Shift+Alt before releasing Enter.
 245       // TODO(nona|mazda): Fix crbug.com/139556 in a cleaner way.
 246       previous_key_code != ui::VKEY_RETURN &&
 247       previous_key_code != ui::VKEY_SPACE) {
 248     // We totally ignore this accelerator.
 249     // TODO(mazda): Fix crbug.com/158217
 250     return;
 251   }
 252   base::RecordAction(UserMetricsAction("Accel_Next_Ime"));
 253   if (ime_control_delegate)
 254     ime_control_delegate->HandleNextIme();
 255 }
 256
 257 bool HandleOpenFeedbackPage() {
 258   base::RecordAction(UserMetricsAction("Accel_Open_Feedback_Page"));
 259   ash::Shell::GetInstance()->new_window_delegate()->OpenFeedbackPage();
 260   return true;
 261 }
 262
 263 bool HandlePositionCenter() {
 264   base::RecordAction(UserMetricsAction("Accel_Window_Position_Center"));
 265   aura::Window* window = wm::GetActiveWindow();
 266   // Docked windows do not support centering and ignore accelerator.
 267   if (window && !wm::GetWindowState(window)->IsDocked()) {
 268     wm::CenterWindow(window);
 269     return true;
 270   }
 271   return false;
 272 }
 273
 274 bool HandlePreviousIme(ImeControlDelegate* ime_control_delegate,
 275                        const ui::Accelerator& accelerator) {
 276   base::RecordAction(UserMetricsAction("Accel_Previous_Ime"));
 277   if (ime_control_delegate)
 278     return ime_control_delegate->HandlePreviousIme(accelerator);
 279   return false;
 280 }
 281
 282 bool HandleRestoreTab() {
 283   base::RecordAction(base::UserMetricsAction("Accel_Restore_Tab"));
 284   Shell::GetInstance()->new_window_delegate()->RestoreTab();
 285   return true;
 286 }
 287
 288 bool HandleRotatePaneFocus(Shell::Direction direction) {
 289   Shell* shell = Shell::GetInstance();
 290   switch (direction) {
 291     // TODO(stevet): Not sure if this is the same as IDC_FOCUS_NEXT_PANE.
 292     case Shell::FORWARD: {
 293       base::RecordAction(UserMetricsAction("Accel_Focus_Next_Pane"));
 294       shell->focus_cycler()->RotateFocus(FocusCycler::FORWARD);
 295       break;
 296     }
 297     case Shell::BACKWARD: {
 298       base::RecordAction(UserMetricsAction("Accel_Focus_Previous_Pane"));
 299       shell->focus_cycler()->RotateFocus(FocusCycler::BACKWARD);
 300       break;
 301     }
 302   }
 303   return true;
 304 }
 305
 306 // Rotate the active window.
 307 bool HandleRotateActiveWindow() {
 308   base::RecordAction(UserMetricsAction("Accel_Rotate_Window"));
 309   aura::Window* active_window = wm::GetActiveWindow();
 310   if (active_window) {
 311     // The rotation animation bases its target transform on the current
 312     // rotation and position. Since there could be an animation in progress
 313     // right now, queue this animation so when it starts it picks up a neutral
 314     // rotation and position. Use replace so we only enqueue one at a time.
 315     active_window->layer()->GetAnimator()->
 316         set_preemption_strategy(ui::LayerAnimator::REPLACE_QUEUED_ANIMATIONS);
 317     active_window->layer()->GetAnimator()->StartAnimation(
 318         new ui::LayerAnimationSequence(
 319             new ash::ScreenRotation(360, active_window->layer())));
 320   }
 321   return true;
 322 }
 323
 324 gfx::Display::Rotation GetNextRotation(gfx::Display::Rotation current) {
 325   switch (current) {
 326     case gfx::Display::ROTATE_0:
 327       return gfx::Display::ROTATE_90;
 328     case gfx::Display::ROTATE_90:
 329       return gfx::Display::ROTATE_180;
 330     case gfx::Display::ROTATE_180:
 331       return gfx::Display::ROTATE_270;
 332     case gfx::Display::ROTATE_270:
 333       return gfx::Display::ROTATE_0;
 334   }
 335   NOTREACHED() << "Unknown rotation:" << current;
 336   return gfx::Display::ROTATE_0;
 337 }
 338
 339 // Rotates the screen.
 340 bool HandleRotateScreen() {
 341   base::RecordAction(UserMetricsAction("Accel_Rotate_Window"));
 342   gfx::Point point = Shell::GetScreen()->GetCursorScreenPoint();
 343   gfx::Display display = Shell::GetScreen()->GetDisplayNearestPoint(point);
 344   const DisplayInfo& display_info =
 345       Shell::GetInstance()->display_manager()->GetDisplayInfo(display.id());
 346   Shell::GetInstance()->display_manager()->SetDisplayRotation(
 347       display.id(), GetNextRotation(display_info.rotation()));
 348   return true;
 349 }
 350
 351 bool HandleScaleReset() {
 352   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
 353   int64 display_id = display_manager->GetDisplayIdForUIScaling();
 354   if (display_id == gfx::Display::kInvalidDisplayID)
 355     return false;
 356
 357   base::RecordAction(UserMetricsAction("Accel_Scale_Ui_Reset"));
 358
 359   display_manager->SetDisplayUIScale(display_id, 1.0f);
 360   return true;
 361 }
 362
 363 bool HandleScaleUI(bool up) {
 364   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
 365   int64 display_id = display_manager->GetDisplayIdForUIScaling();
 366   if (display_id == gfx::Display::kInvalidDisplayID)
 367     return false;
 368
 369   if (up) {
 370     base::RecordAction(UserMetricsAction("Accel_Scale_Ui_Up"));
 371   } else {
 372     base::RecordAction(UserMetricsAction("Accel_Scale_Ui_Down"));
 373   }
 374
 375   const DisplayInfo& display_info = display_manager->GetDisplayInfo(display_id);
 376   float next_scale = DisplayManager::GetNextUIScale(display_info, up);
 377   display_manager->SetDisplayUIScale(display_id, next_scale);
 378   return true;
 379 }
 380
 381 #if defined(OS_CHROMEOS)
 382 bool HandleSwapPrimaryDisplay() {
 383   base::RecordAction(UserMetricsAction("Accel_Swap_Primary_Display"));
 384   Shell::GetInstance()->display_controller()->SwapPrimaryDisplay();
 385   return true;
 386 }
 387 #endif
 388
 389 bool HandleShowKeyboardOverlay() {
 390   base::RecordAction(UserMetricsAction("Accel_Show_Keyboard_Overlay"));
 391   ash::Shell::GetInstance()->new_window_delegate()->ShowKeyboardOverlay();
 392
 393   return true;
 394 }
 395
 396 void HandleShowMessageCenterBubble() {
 397   base::RecordAction(UserMetricsAction("Accel_Show_Message_Center_Bubble"));
 398   RootWindowController* controller =
 399       RootWindowController::ForTargetRootWindow();
 400   StatusAreaWidget* status_area_widget =
 401       controller->shelf()->status_area_widget();
 402   if (status_area_widget) {
 403     WebNotificationTray* notification_tray =
 404       status_area_widget->web_notification_tray();
 405     if (notification_tray->visible())
 406       notification_tray->ShowMessageCenterBubble();
 407   }
 408 }
 409
 410 bool HandleShowSystemTrayBubble() {
 411   base::RecordAction(UserMetricsAction("Accel_Show_System_Tray_Bubble"));
 412   RootWindowController* controller =
 413       RootWindowController::ForTargetRootWindow();
 414   if (!controller->GetSystemTray()->HasSystemBubble()) {
 415     controller->GetSystemTray()->ShowDefaultView(BUBBLE_CREATE_NEW);
 416     return true;
 417   }
 418   return false;
 419 }
 420
 421 bool HandleShowTaskManager() {
 422   base::RecordAction(UserMetricsAction("Accel_Show_Task_Manager"));
 423   Shell::GetInstance()->new_window_delegate()->ShowTaskManager();
 424   return true;
 425 }
 426
 427 #if defined(OS_CHROMEOS)
 428 void HandleSilenceSpokenFeedback() {
 429   base::RecordAction(UserMetricsAction("Accel_Silence_Spoken_Feedback"));
 430
 431   AccessibilityDelegate* delegate =
 432       Shell::GetInstance()->accessibility_delegate();
 433   if (!delegate->IsSpokenFeedbackEnabled())
 434     return;
 435   delegate->SilenceSpokenFeedback();
 436 }
 437 #endif
 438
 439 bool HandleSwitchIme(ImeControlDelegate* ime_control_delegate,
 440                      const ui::Accelerator& accelerator) {
 441   base::RecordAction(UserMetricsAction("Accel_Switch_Ime"));
 442   if (ime_control_delegate)
 443     return ime_control_delegate->HandleSwitchIme(accelerator);
 444   return false;
 445 }
 446
 447 bool HandleTakePartialScreenshot(ScreenshotDelegate* screenshot_delegate) {
 448   base::RecordAction(UserMetricsAction("Accel_Take_Partial_Screenshot"));
 449   if (screenshot_delegate) {
 450     ash::PartialScreenshotView::StartPartialScreenshot(
 451         screenshot_delegate);
 452   }
 453   // Return true to prevent propagation of the key event because
 454   // this key combination is reserved for partial screenshot.
 455   return true;
 456 }
 457
 458 bool HandleTakeScreenshot(ScreenshotDelegate* screenshot_delegate) {
 459   base::RecordAction(UserMetricsAction("Accel_Take_Screenshot"));
 460   if (screenshot_delegate &&
 461       screenshot_delegate->CanTakeScreenshot()) {
 462     screenshot_delegate->HandleTakeScreenshotForAllRootWindows();
 463   }
 464   // Return true to prevent propagation of the key event.
 465   return true;
 466 }
 467
 468 bool HandleToggleAppList(ui::KeyboardCode key_code,
 469                          ui::EventType previous_event_type,
 470                          ui::KeyboardCode previous_key_code,
 471                          const ui::Accelerator& accelerator) {
 472   // If something else was pressed between the Search key (LWIN)
 473   // being pressed and released, then ignore the release of the
 474   // Search key.
 475   if (key_code == ui::VKEY_LWIN &&
 476       (previous_event_type == ui::ET_KEY_RELEASED ||
 477        previous_key_code != ui::VKEY_LWIN))
 478     return false;
 479   if (key_code == ui::VKEY_LWIN)
 480     base::RecordAction(base::UserMetricsAction("Accel_Search_LWin"));
 481   // When spoken feedback is enabled, we should neither toggle the list nor
 482   // consume the key since Search+Shift is one of the shortcuts the a11y
 483   // feature uses. crbug.com/132296
 484   DCHECK_EQ(ui::VKEY_LWIN, accelerator.key_code());
 485   if (Shell::GetInstance()->accessibility_delegate()->
 486       IsSpokenFeedbackEnabled())
 487     return false;
 488   ash::Shell::GetInstance()->ToggleAppList(NULL);
 489   return true;
 490 }
 491
 492 bool HandleToggleFullscreen(ui::KeyboardCode key_code) {
 493   if (key_code == ui::VKEY_MEDIA_LAUNCH_APP2) {
 494     base::RecordAction(UserMetricsAction("Accel_Fullscreen_F4"));
 495   }
 496   accelerators::ToggleFullscreen();
 497   return true;
 498 }
 499
 500 bool HandleToggleRootWindowFullScreen() {
 501   Shell::GetPrimaryRootWindowController()->ash_host()->ToggleFullScreen();
 502   return true;
 503 }
 504
 505 bool HandleWindowSnap(int action) {
 506   wm::WindowState* window_state = wm::GetActiveWindowState();
 507   // Disable window snapping shortcut key for full screen window due to
 508   // http://crbug.com/135487.
 509   if (!window_state ||
 510       window_state->window()->type() != ui::wm::WINDOW_TYPE_NORMAL ||
 511       window_state->IsFullscreen() ||
 512       !window_state->CanSnap()) {
 513     return false;
 514   }
 515
 516   if (action == WINDOW_SNAP_LEFT) {
 517     base::RecordAction(UserMetricsAction("Accel_Window_Snap_Left"));
 518   } else {
 519     base::RecordAction(UserMetricsAction("Accel_Window_Snap_Right"));
 520   }
 521   const wm::WMEvent event(action == WINDOW_SNAP_LEFT ?
 522                           wm::WM_EVENT_SNAP_LEFT : wm::WM_EVENT_SNAP_RIGHT);
 523   window_state->OnWMEvent(&event);
 524   return true;
 525 }
 526
 527 bool HandleWindowMinimize() {
 528   base::RecordAction(
 529       base::UserMetricsAction("Accel_Toggle_Minimized_Minus"));
 530   return accelerators::ToggleMinimized();
 531 }
 532
 533 #if defined(OS_CHROMEOS)
 534 bool HandleAddRemoveDisplay() {
 535   base::RecordAction(UserMetricsAction("Accel_Add_Remove_Display"));
 536   Shell::GetInstance()->display_manager()->AddRemoveDisplay();
 537   return true;
 538 }
 539
 540 bool HandleCrosh() {
 541   base::RecordAction(UserMetricsAction("Accel_Open_Crosh"));
 542
 543   Shell::GetInstance()->new_window_delegate()->OpenCrosh();
 544   return true;
 545 }
 546
 547 bool HandleFileManager() {
 548   base::RecordAction(UserMetricsAction("Accel_Open_File_Manager"));
 549
 550   Shell::GetInstance()->new_window_delegate()->OpenFileManager();
 551   return true;
 552 }
 553
 554 bool HandleLock(ui::KeyboardCode key_code) {
 555   base::RecordAction(UserMetricsAction("Accel_LockScreen_L"));
 556   Shell::GetInstance()->session_state_delegate()->LockScreen();
 557   return true;
 558 }
 559
 560 bool HandleCycleUser(SessionStateDelegate::CycleUser cycle_user) {
 561   if (!Shell::GetInstance()->delegate()->IsMultiProfilesEnabled())
 562     return false;
 563   ash::SessionStateDelegate* delegate =
 564       ash::Shell::GetInstance()->session_state_delegate();
 565   if (delegate->NumberOfLoggedInUsers() <= 1)
 566     return false;
 567   MultiProfileUMA::RecordSwitchActiveUser(
 568       MultiProfileUMA::SWITCH_ACTIVE_USER_BY_ACCELERATOR);
 569   switch (cycle_user) {
 570     case SessionStateDelegate::CYCLE_TO_NEXT_USER:
 571       base::RecordAction(UserMetricsAction("Accel_Switch_To_Next_User"));
 572       break;
 573     case SessionStateDelegate::CYCLE_TO_PREVIOUS_USER:
 574       base::RecordAction(UserMetricsAction("Accel_Switch_To_Previous_User"));
 575       break;
 576   }
 577   delegate->CycleActiveUser(cycle_user);
 578   return true;
 579 }
 580
 581 bool HandleToggleMirrorMode() {
 582   base::RecordAction(UserMetricsAction("Accel_Toggle_Mirror_Mode"));
 583   Shell::GetInstance()->display_controller()->ToggleMirrorMode();
 584   return true;
 585 }
 586
 587 bool HandleToggleSpokenFeedback() {
 588   base::RecordAction(UserMetricsAction("Accel_Toggle_Spoken_Feedback"));
 589
 590   Shell::GetInstance()->accessibility_delegate()->
 591       ToggleSpokenFeedback(A11Y_NOTIFICATION_SHOW);
 592   return true;
 593 }
 594
 595 bool HandleToggleTouchViewTesting() {
 596   // TODO(skuhne): This is only temporary! Remove this!
 597   if (CommandLine::ForCurrentProcess()->HasSwitch(
 598           switches::kAshEnableTouchViewTesting)) {
 599     MaximizeModeController* controller = Shell::GetInstance()->
 600         maximize_mode_controller();
 601     controller->EnableMaximizeModeWindowManager(
 602         !controller->IsMaximizeModeWindowManagerEnabled());
 603     return true;
 604   }
 605   return false;
 606 }
 607
 608 bool HandleTouchHudClear() {
 609   RootWindowController* controller =
 610       RootWindowController::ForTargetRootWindow();
 611   if (controller->touch_hud_debug()) {
 612     controller->touch_hud_debug()->Clear();
 613     return true;
 614   }
 615   return false;
 616 }
 617
 618 bool HandleTouchHudModeChange() {
 619   RootWindowController* controller =
 620       RootWindowController::ForTargetRootWindow();
 621   if (controller->touch_hud_debug()) {
 622     controller->touch_hud_debug()->ChangeToNextMode();
 623     return true;
 624   }
 625   return false;
 626 }
 627
 628 bool HandleTouchHudProjectToggle() {
 629   base::RecordAction(UserMetricsAction("Accel_Touch_Hud_Clear"));
 630   bool enabled = Shell::GetInstance()->is_touch_hud_projection_enabled();
 631   Shell::GetInstance()->SetTouchHudProjectionEnabled(!enabled);
 632   return true;
 633 }
 634
 635 bool HandleDisableCapsLock(ui::KeyboardCode key_code,
 636                            ui::EventType previous_event_type,
 637                            ui::KeyboardCode previous_key_code) {
 638   if (previous_event_type == ui::ET_KEY_RELEASED ||
 639       (previous_key_code != ui::VKEY_LSHIFT &&
 640        previous_key_code != ui::VKEY_SHIFT &&
 641        previous_key_code != ui::VKEY_RSHIFT)) {
 642     // If something else was pressed between the Shift key being pressed
 643     // and released, then ignore the release of the Shift key.
 644     return false;
 645   }
 646   base::RecordAction(UserMetricsAction("Accel_Disable_Caps_Lock"));
 647   chromeos::input_method::InputMethodManager* ime =
 648       chromeos::input_method::InputMethodManager::Get();
 649   chromeos::input_method::ImeKeyboard* keyboard =
 650       ime ? ime->GetImeKeyboard() : NULL;
 651   if (keyboard && keyboard->CapsLockIsEnabled()) {
 652     keyboard->SetCapsLockEnabled(false);
 653     return true;
 654   }
 655   return false;
 656 }
 657
 658 bool HandleToggleCapsLock(ui::KeyboardCode key_code,
 659                           ui::EventType previous_event_type,
 660                           ui::KeyboardCode previous_key_code) {
 661   if (key_code == ui::VKEY_LWIN) {
 662     // If something else was pressed between the Search key (LWIN)
 663     // being pressed and released, then ignore the release of the
 664     // Search key.
 665     // TODO(danakj): Releasing Alt first breaks this: crbug.com/166495
 666     if (previous_event_type == ui::ET_KEY_RELEASED ||
 667         previous_key_code != ui::VKEY_LWIN)
 668       return false;
 669   }
 670   base::RecordAction(UserMetricsAction("Accel_Toggle_Caps_Lock"));
 671   chromeos::input_method::InputMethodManager* ime =
 672       chromeos::input_method::InputMethodManager::Get();
 673   chromeos::input_method::ImeKeyboard* keyboard =
 674       ime ? ime->GetImeKeyboard() : NULL;
 675   if (keyboard)
 676     keyboard->SetCapsLockEnabled(!keyboard->CapsLockIsEnabled());
 677   return true;
 678 }
 679
 680 #endif  // defined(OS_CHROMEOS)
 681
 682 // Debug print methods.
 683
 684 bool HandlePrintLayerHierarchy() {
 685   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
 686   for (size_t i = 0; i < root_windows.size(); ++i) {
 687     ui::PrintLayerHierarchy(
 688         root_windows[i]->layer(),
 689         root_windows[i]->GetHost()->dispatcher()->GetLastMouseLocationInRoot());
 690   }
 691   return true;
 692 }
 693
 694 bool HandlePrintViewHierarchy() {
 695   aura::Window* active_window = ash::wm::GetActiveWindow();
 696   if (!active_window)
 697     return true;
 698   views::Widget* browser_widget =
 699       views::Widget::GetWidgetForNativeWindow(active_window);
 700   if (!browser_widget)
 701     return true;
 702   views::PrintViewHierarchy(browser_widget->GetRootView());
 703   return true;
 704 }
 705
 706 void PrintWindowHierarchy(aura::Window* window,
 707                           int indent,
 708                           std::ostringstream* out) {
 709   std::string indent_str(indent, ' ');
 710   std::string name(window->name());
 711   if (name.empty())
 712     name = "\"\"";
 713   *out << indent_str << name << " (" << window << ")"
 714        << " type=" << window->type()
 715        << (wm::IsActiveWindow(window) ? " [active] " : " ")
 716        << (window->IsVisible() ? " visible " : " ")
 717        << window->bounds().ToString()
 718        << '\n';
 719
 720   for (size_t i = 0; i < window->children().size(); ++i)
 721     PrintWindowHierarchy(window->children()[i], indent + 3, out);
 722 }
 723
 724 bool HandlePrintWindowHierarchy() {
 725   Shell::RootWindowControllerList controllers =
 726       Shell::GetAllRootWindowControllers();
 727   for (size_t i = 0; i < controllers.size(); ++i) {
 728     std::ostringstream out;
 729     out << "RootWindow " << i << ":\n";
 730     PrintWindowHierarchy(controllers[i]->GetRootWindow(), 0, &out);
 731     // Error so logs can be collected from end-users.
 732     LOG(ERROR) << out.str();
 733   }
 734   return true;
 735 }
 736
 737 bool HandlePrintUIHierarchies() {
 738   // This is a separate command so the user only has to hit one key to generate
 739   // all the logs. Developers use the individual dumps repeatedly, so keep
 740   // those as separate commands to avoid spamming their logs.
 741   HandlePrintLayerHierarchy();
 742   HandlePrintWindowHierarchy();
 743   HandlePrintViewHierarchy();
 744   return true;
 745 }
 746
 747 class AutoSet {
 748  public:
 749   AutoSet(ui::Accelerator* scoped, ui::Accelerator new_value)
 750       : scoped_(scoped), new_value_(new_value) {}
 751   ~AutoSet() { *scoped_ = new_value_; }
 752
 753  private:
 754   ui::Accelerator* scoped_;
 755   const ui::Accelerator new_value_;
 756
 757   DISALLOW_COPY_AND_ASSIGN(AutoSet);
 758 };
 759
 760 }  // namespace
 761
 762 ////////////////////////////////////////////////////////////////////////////////
 763 // AcceleratorController, public:
 764
 765 AcceleratorController::AcceleratorController()
 766     : accelerator_manager_(new ui::AcceleratorManager) {
 767   Init();
 768 }
 769
 770 AcceleratorController::~AcceleratorController() {
 771 }
 772
 773 void AcceleratorController::Init() {
 774   previous_accelerator_.set_type(ui::ET_UNKNOWN);
 775   for (size_t i = 0; i < kActionsAllowedAtLoginOrLockScreenLength; ++i) {
 776     actions_allowed_at_login_screen_.insert(
 777         kActionsAllowedAtLoginOrLockScreen[i]);
 778     actions_allowed_at_lock_screen_.insert(
 779         kActionsAllowedAtLoginOrLockScreen[i]);
 780   }
 781   for (size_t i = 0; i < kActionsAllowedAtLockScreenLength; ++i)
 782     actions_allowed_at_lock_screen_.insert(kActionsAllowedAtLockScreen[i]);
 783   for (size_t i = 0; i < kActionsAllowedAtModalWindowLength; ++i)
 784     actions_allowed_at_modal_window_.insert(kActionsAllowedAtModalWindow[i]);
 785   for (size_t i = 0; i < kPreferredActionsLength; ++i)
 786     preferred_actions_.insert(kPreferredActions[i]);
 787   for (size_t i = 0; i < kReservedActionsLength; ++i)
 788     reserved_actions_.insert(kReservedActions[i]);
 789   for (size_t i = 0; i < kNonrepeatableActionsLength; ++i)
 790     nonrepeatable_actions_.insert(kNonrepeatableActions[i]);
 791   for (size_t i = 0; i < kActionsAllowedInAppModeLength; ++i)
 792     actions_allowed_in_app_mode_.insert(kActionsAllowedInAppMode[i]);
 793   for (size_t i = 0; i < kActionsNeedingWindowLength; ++i)
 794     actions_needing_window_.insert(kActionsNeedingWindow[i]);
 795
 796   RegisterAccelerators(kAcceleratorData, kAcceleratorDataLength);
 797
 798 #if !defined(NDEBUG)
 799   RegisterAccelerators(kDesktopAcceleratorData, kDesktopAcceleratorDataLength);
 800 #endif
 801
 802   if (DebugShortcutsEnabled()) {
 803     RegisterAccelerators(kDebugAcceleratorData, kDebugAcceleratorDataLength);
 804     for (size_t i = 0; i < kReservedDebugActionsLength; ++i)
 805       reserved_actions_.insert(kReservedDebugActions[i]);
 806   }
 807
 808 #if defined(OS_CHROMEOS)
 809   keyboard_brightness_control_delegate_.reset(
 810       new KeyboardBrightnessController());
 811 #endif
 812 }
 813
 814 void AcceleratorController::Register(const ui::Accelerator& accelerator,
 815                                      ui::AcceleratorTarget* target) {
 816   accelerator_manager_->Register(accelerator,
 817                                  ui::AcceleratorManager::kNormalPriority,
 818                                  target);
 819 }
 820
 821 void AcceleratorController::Unregister(const ui::Accelerator& accelerator,
 822                                        ui::AcceleratorTarget* target) {
 823   accelerator_manager_->Unregister(accelerator, target);
 824 }
 825
 826 void AcceleratorController::UnregisterAll(ui::AcceleratorTarget* target) {
 827   accelerator_manager_->UnregisterAll(target);
 828 }
 829
 830 bool AcceleratorController::Process(const ui::Accelerator& accelerator) {
 831   AutoSet auto_set(&previous_accelerator_, accelerator);
 832
 833   if (ime_control_delegate_) {
 834     return accelerator_manager_->Process(
 835         ime_control_delegate_->RemapAccelerator(accelerator));
 836   }
 837   return accelerator_manager_->Process(accelerator);
 838 }
 839
 840 bool AcceleratorController::IsRegistered(
 841     const ui::Accelerator& accelerator) const {
 842   return accelerator_manager_->GetCurrentTarget(accelerator) != NULL;
 843 }
 844
 845 bool AcceleratorController::IsPreferred(
 846     const ui::Accelerator& accelerator) const {
 847   const ui::Accelerator remapped_accelerator = ime_control_delegate_.get() ?
 848       ime_control_delegate_->RemapAccelerator(accelerator) : accelerator;
 849
 850   std::map<ui::Accelerator, int>::const_iterator iter =
 851       accelerators_.find(remapped_accelerator);
 852   if (iter == accelerators_.end())
 853     return false;  // not an accelerator.
 854
 855   return preferred_actions_.find(iter->second) != preferred_actions_.end();
 856 }
 857
 858 bool AcceleratorController::IsReserved(
 859     const ui::Accelerator& accelerator) const {
 860   const ui::Accelerator remapped_accelerator = ime_control_delegate_.get() ?
 861       ime_control_delegate_->RemapAccelerator(accelerator) : accelerator;
 862
 863   std::map<ui::Accelerator, int>::const_iterator iter =
 864       accelerators_.find(remapped_accelerator);
 865   if (iter == accelerators_.end())
 866     return false;  // not an accelerator.
 867
 868   return reserved_actions_.find(iter->second) != reserved_actions_.end();
 869 }
 870
 871 bool AcceleratorController::PerformAction(int action,
 872                                           const ui::Accelerator& accelerator) {
 873   ash::Shell* shell = ash::Shell::GetInstance();
 874   AcceleratorProcessingRestriction restriction =
 875       GetAcceleratorProcessingRestriction(action);
 876   if (restriction != RESTRICTION_NONE)
 877     return restriction == RESTRICTION_PREVENT_PROCESSING_AND_PROPAGATION;
 878
 879   const ui::KeyboardCode key_code = accelerator.key_code();
 880   // PerformAction() is performed from gesture controllers and passes
 881   // empty Accelerator() instance as the second argument. Such events
 882   // should never be suspended.
 883   const bool gesture_event = key_code == ui::VKEY_UNKNOWN;
 884   // Ignore accelerators invoked as repeated (while holding a key for a long
 885   // time, if their handling is nonrepeatable.
 886   if (nonrepeatable_actions_.find(action) != nonrepeatable_actions_.end() &&
 887       accelerator.IsRepeat() && !gesture_event) {
 888     return true;
 889   }
 890   // Type of the previous accelerator. Used by NEXT_IME and DISABLE_CAPS_LOCK.
 891   const ui::EventType previous_event_type = previous_accelerator_.type();
 892   const ui::KeyboardCode previous_key_code = previous_accelerator_.key_code();
 893
 894   // You *MUST* return true when some action is performed. Otherwise, this
 895   // function might be called *twice*, via BrowserView::PreHandleKeyboardEvent
 896   // and BrowserView::HandleKeyboardEvent, for a single accelerator press.
 897   //
 898   // If your accelerator invokes more than one line of code, please either
 899   // implement it in your module's controller code (like TOGGLE_MIRROR_MODE
 900   // below) or pull it into a HandleFoo() function above.
 901   switch (action) {
 902     case ACCESSIBLE_FOCUS_NEXT:
 903       return HandleAccessibleFocusCycle(false);
 904     case ACCESSIBLE_FOCUS_PREVIOUS:
 905       return HandleAccessibleFocusCycle(true);
 906     case CYCLE_BACKWARD_MRU:
 907       return HandleCycleBackwardMRU(accelerator);
 908     case CYCLE_FORWARD_MRU:
 909       return HandleCycleForwardMRU(accelerator);
 910     case TOGGLE_OVERVIEW:
 911       return ToggleOverview(accelerator);
 912 #if defined(OS_CHROMEOS)
 913     case ADD_REMOVE_DISPLAY:
 914       return HandleAddRemoveDisplay();
 915     case TOGGLE_MIRROR_MODE:
 916       return HandleToggleMirrorMode();
 917     case LOCK_SCREEN:
 918       return HandleLock(key_code);
 919     case OPEN_FILE_MANAGER:
 920       return HandleFileManager();
 921     case OPEN_CROSH:
 922       return HandleCrosh();
 923     case SILENCE_SPOKEN_FEEDBACK:
 924       HandleSilenceSpokenFeedback();
 925       break;
 926     case SWAP_PRIMARY_DISPLAY:
 927       return HandleSwapPrimaryDisplay();
 928     case SWITCH_TO_NEXT_USER:
 929       return HandleCycleUser(SessionStateDelegate::CYCLE_TO_NEXT_USER);
 930     case SWITCH_TO_PREVIOUS_USER:
 931       return HandleCycleUser(SessionStateDelegate::CYCLE_TO_PREVIOUS_USER);
 932     case TOGGLE_SPOKEN_FEEDBACK:
 933       return HandleToggleSpokenFeedback();
 934     case TOGGLE_TOUCH_VIEW_TESTING:
 935       return HandleToggleTouchViewTesting();
 936     case TOGGLE_WIFI:
 937       Shell::GetInstance()->system_tray_notifier()->NotifyRequestToggleWifi();
 938       return true;
 939     case TOUCH_HUD_CLEAR:
 940       return HandleTouchHudClear();
 941     case TOUCH_HUD_MODE_CHANGE:
 942       return HandleTouchHudModeChange();
 943     case TOUCH_HUD_PROJECTION_TOGGLE:
 944       return HandleTouchHudProjectToggle();
 945     case DISABLE_GPU_WATCHDOG:
 946       Shell::GetInstance()->gpu_support()->DisableGpuWatchdog();
 947       return true;
 948     case DISABLE_CAPS_LOCK:
 949       return HandleDisableCapsLock(
 950           key_code, previous_event_type, previous_key_code);
 951     case TOGGLE_CAPS_LOCK:
 952       return HandleToggleCapsLock(
 953           key_code, previous_event_type, previous_key_code);
 954 #endif  // OS_CHROMEOS
 955     case OPEN_FEEDBACK_PAGE:
 956       return HandleOpenFeedbackPage();
 957     case EXIT:
 958       // UMA metrics are recorded in the handler.
 959       exit_warning_handler_.HandleAccelerator();
 960       return true;
 961     case NEW_INCOGNITO_WINDOW:
 962       return HandleNewIncognitoWindow();
 963     case NEW_TAB:
 964       return HandleNewTab(key_code);
 965     case NEW_WINDOW:
 966       return HandleNewWindow();
 967     case RESTORE_TAB:
 968       return HandleRestoreTab();
 969     case TAKE_SCREENSHOT:
 970       return HandleTakeScreenshot(screenshot_delegate_.get());
 971     case TAKE_PARTIAL_SCREENSHOT:
 972       return HandleTakePartialScreenshot(screenshot_delegate_.get());
 973     case TOGGLE_APP_LIST:
 974       return HandleToggleAppList(
 975           key_code, previous_event_type, previous_key_code, accelerator);
 976     case BRIGHTNESS_DOWN:
 977       if (brightness_control_delegate_)
 978         return brightness_control_delegate_->HandleBrightnessDown(accelerator);
 979       break;
 980     case BRIGHTNESS_UP:
 981       if (brightness_control_delegate_)
 982         return brightness_control_delegate_->HandleBrightnessUp(accelerator);
 983       break;
 984     case KEYBOARD_BRIGHTNESS_DOWN:
 985       if (keyboard_brightness_control_delegate_)
 986         return keyboard_brightness_control_delegate_->
 987             HandleKeyboardBrightnessDown(accelerator);
 988       break;
 989     case KEYBOARD_BRIGHTNESS_UP:
 990       if (keyboard_brightness_control_delegate_)
 991         return keyboard_brightness_control_delegate_->
 992             HandleKeyboardBrightnessUp(accelerator);
 993       break;
 994     case VOLUME_MUTE: {
 995       ash::VolumeControlDelegate* volume_delegate =
 996           shell->system_tray_delegate()->GetVolumeControlDelegate();
 997       return volume_delegate && volume_delegate->HandleVolumeMute(accelerator);
 998     }
 999     case VOLUME_DOWN: {
1000       ash::VolumeControlDelegate* volume_delegate =
1001           shell->system_tray_delegate()->GetVolumeControlDelegate();
1002       return volume_delegate && volume_delegate->HandleVolumeDown(accelerator);
1003     }
1004     case VOLUME_UP: {
1005       ash::VolumeControlDelegate* volume_delegate =
1006           shell->system_tray_delegate()->GetVolumeControlDelegate();
1007       return volume_delegate && volume_delegate->HandleVolumeUp(accelerator);
1008     }
1009     case FOCUS_SHELF:
1010       return HandleFocusShelf();
1011     case FOCUS_NEXT_PANE:
1012       return HandleRotatePaneFocus(Shell::FORWARD);
1013     case FOCUS_PREVIOUS_PANE:
1014       return HandleRotatePaneFocus(Shell::BACKWARD);
1015     case SHOW_KEYBOARD_OVERLAY:
1016       return HandleShowKeyboardOverlay();
1017     case SHOW_SYSTEM_TRAY_BUBBLE:
1018       return HandleShowSystemTrayBubble();
1019     case SHOW_MESSAGE_CENTER_BUBBLE:
1020       HandleShowMessageCenterBubble();
1021       break;
1022     case SHOW_TASK_MANAGER:
1023       return HandleShowTaskManager();
1024     case NEXT_IME:
1025       HandleNextIme(
1026           ime_control_delegate_.get(), previous_event_type, previous_key_code);
1027       // NEXT_IME is bound to Alt-Shift key up event. To be consistent with
1028       // Windows behavior, do not consume the key event here.
1029       return false;
1030     case PREVIOUS_IME:
1031       return HandlePreviousIme(ime_control_delegate_.get(), accelerator);
1032     case PRINT_UI_HIERARCHIES:
1033       return HandlePrintUIHierarchies();
1034     case SWITCH_IME:
1035       return HandleSwitchIme(ime_control_delegate_.get(), accelerator);
1036     case LAUNCH_APP_0:
1037       return HandleLaunchAppN(0);
1038     case LAUNCH_APP_1:
1039       return HandleLaunchAppN(1);
1040     case LAUNCH_APP_2:
1041       return HandleLaunchAppN(2);
1042     case LAUNCH_APP_3:
1043       return HandleLaunchAppN(3);
1044     case LAUNCH_APP_4:
1045       return HandleLaunchAppN(4);
1046     case LAUNCH_APP_5:
1047       return HandleLaunchAppN(5);
1048     case LAUNCH_APP_6:
1049       return HandleLaunchAppN(6);
1050     case LAUNCH_APP_7:
1051       return HandleLaunchAppN(7);
1052     case LAUNCH_LAST_APP:
1053       return HandleLaunchLastApp();
1054     case WINDOW_SNAP_LEFT:
1055     case WINDOW_SNAP_RIGHT:
1056       return HandleWindowSnap(action);
1057     case WINDOW_MINIMIZE:
1058       return HandleWindowMinimize();
1059     case TOGGLE_FULLSCREEN:
1060       return HandleToggleFullscreen(key_code);
1061     case TOGGLE_MAXIMIZED:
1062       accelerators::ToggleMaximized();
1063       return true;
1064     case WINDOW_POSITION_CENTER:
1065      return HandlePositionCenter();
1066     case SCALE_UI_UP:
1067       return HandleScaleUI(true /* up */);
1068     case SCALE_UI_DOWN:
1069       return HandleScaleUI(false /* down */);
1070     case SCALE_UI_RESET:
1071       return HandleScaleReset();
1072     case ROTATE_WINDOW:
1073       return HandleRotateActiveWindow();
1074     case ROTATE_SCREEN:
1075       return HandleRotateScreen();
1076     case TOGGLE_DESKTOP_BACKGROUND_MODE:
1077       return debug::CycleDesktopBackgroundMode();
1078     case TOGGLE_ROOT_WINDOW_FULL_SCREEN:
1079       return HandleToggleRootWindowFullScreen();
1080     case DEBUG_TOGGLE_DEVICE_SCALE_FACTOR:
1081       Shell::GetInstance()->display_manager()->ToggleDisplayScaleFactor();
1082       return true;
1083     case DEBUG_TOGGLE_SHOW_DEBUG_BORDERS:
1084       ash::debug::ToggleShowDebugBorders();
1085       return true;
1086     case DEBUG_TOGGLE_SHOW_FPS_COUNTER:
1087       ash::debug::ToggleShowFpsCounter();
1088       return true;
1089     case DEBUG_TOGGLE_SHOW_PAINT_RECTS:
1090       ash::debug::ToggleShowPaintRects();
1091       return true;
1092     case MAGNIFY_SCREEN_ZOOM_IN:
1093       return HandleMagnifyScreen(1);
1094     case MAGNIFY_SCREEN_ZOOM_OUT:
1095       return HandleMagnifyScreen(-1);
1096     case MEDIA_NEXT_TRACK:
1097       return HandleMediaNextTrack();
1098     case MEDIA_PLAY_PAUSE:
1099        return HandleMediaPlayPause();
1100     case MEDIA_PREV_TRACK:
1101        return HandleMediaPrevTrack();
1102     case POWER_PRESSED:  // fallthrough
1103     case POWER_RELEASED:
1104 #if defined(OS_CHROMEOS)
1105       if (!base::SysInfo::IsRunningOnChromeOS()) {
1106         // There is no powerd in linux desktop, so call the
1107         // PowerButtonController here.
1108         Shell::GetInstance()->power_button_controller()->
1109             OnPowerButtonEvent(action == POWER_PRESSED, base::TimeTicks());
1110       }
1111 #endif
1112       // We don't do anything with these at present on the device,
1113       // (power button events are reported to us from powerm via
1114       // D-BUS), but we consume them to prevent them from getting
1115       // passed to apps -- see http://crbug.com/146609.
1116       return true;
1117     case LOCK_PRESSED:
1118     case LOCK_RELEASED:
1119       Shell::GetInstance()->power_button_controller()->
1120           OnLockButtonEvent(action == LOCK_PRESSED, base::TimeTicks());
1121       return true;
1122     case PRINT_LAYER_HIERARCHY:
1123       return HandlePrintLayerHierarchy();
1124     case PRINT_VIEW_HIERARCHY:
1125       return HandlePrintViewHierarchy();
1126     case PRINT_WINDOW_HIERARCHY:
1127       return HandlePrintWindowHierarchy();
1128     default:
1129       NOTREACHED() << "Unhandled action " << action;
1130   }
1131   return false;
1132 }
1133
1134 AcceleratorController::AcceleratorProcessingRestriction
1135 AcceleratorController::GetCurrentAcceleratorRestriction() {
1136   return GetAcceleratorProcessingRestriction(-1);
1137 }
1138
1139 AcceleratorController::AcceleratorProcessingRestriction
1140 AcceleratorController::GetAcceleratorProcessingRestriction(int action) {
1141   ash::Shell* shell = ash::Shell::GetInstance();
1142   if (!shell->session_state_delegate()->IsActiveUserSessionStarted() &&
1143       actions_allowed_at_login_screen_.find(action) ==
1144           actions_allowed_at_login_screen_.end()) {
1145     return RESTRICTION_PREVENT_PROCESSING;
1146   }
1147   if (shell->session_state_delegate()->IsScreenLocked() &&
1148       actions_allowed_at_lock_screen_.find(action) ==
1149           actions_allowed_at_lock_screen_.end()) {
1150     return RESTRICTION_PREVENT_PROCESSING;
1151   }
1152   if (shell->IsSystemModalWindowOpen() &&
1153       actions_allowed_at_modal_window_.find(action) ==
1154           actions_allowed_at_modal_window_.end()) {
1155     // Note we prevent the shortcut from propagating so it will not
1156     // be passed to the modal window. This is important for things like
1157     // Alt+Tab that would cause an undesired effect in the modal window by
1158     // cycling through its window elements.
1159     return RESTRICTION_PREVENT_PROCESSING_AND_PROPAGATION;
1160   }
1161   if (shell->delegate()->IsRunningInForcedAppMode() &&
1162       actions_allowed_in_app_mode_.find(action) ==
1163           actions_allowed_in_app_mode_.end()) {
1164     return RESTRICTION_PREVENT_PROCESSING;
1165   }
1166   if (MruWindowTracker::BuildWindowList(false).empty() &&
1167       actions_needing_window_.find(action) != actions_needing_window_.end()) {
1168     Shell::GetInstance()->accessibility_delegate()->TriggerAccessibilityAlert(
1169         A11Y_ALERT_WINDOW_NEEDED);
1170     return RESTRICTION_PREVENT_PROCESSING_AND_PROPAGATION;
1171   }
1172   return RESTRICTION_NONE;
1173 }
1174
1175 void AcceleratorController::SetBrightnessControlDelegate(
1176     scoped_ptr<BrightnessControlDelegate> brightness_control_delegate) {
1177   brightness_control_delegate_ = brightness_control_delegate.Pass();
1178 }
1179
1180 void AcceleratorController::SetImeControlDelegate(
1181     scoped_ptr<ImeControlDelegate> ime_control_delegate) {
1182   ime_control_delegate_ = ime_control_delegate.Pass();
1183 }
1184
1185 void AcceleratorController::SetScreenshotDelegate(
1186     scoped_ptr<ScreenshotDelegate> screenshot_delegate) {
1187   screenshot_delegate_ = screenshot_delegate.Pass();
1188 }
1189
1190 ////////////////////////////////////////////////////////////////////////////////
1191 // AcceleratorController, ui::AcceleratorTarget implementation:
1192
1193 bool AcceleratorController::AcceleratorPressed(
1194     const ui::Accelerator& accelerator) {
1195   std::map<ui::Accelerator, int>::const_iterator it =
1196       accelerators_.find(accelerator);
1197   DCHECK(it != accelerators_.end());
1198   return PerformAction(static_cast<AcceleratorAction>(it->second), accelerator);
1199 }
1200
1201 void AcceleratorController::RegisterAccelerators(
1202     const AcceleratorData accelerators[],
1203     size_t accelerators_length) {
1204   for (size_t i = 0; i < accelerators_length; ++i) {
1205     ui::Accelerator accelerator(accelerators[i].keycode,
1206                                 accelerators[i].modifiers);
1207     accelerator.set_type(accelerators[i].trigger_on_press ?
1208                          ui::ET_KEY_PRESSED : ui::ET_KEY_RELEASED);
1209     Register(accelerator, this);
1210     accelerators_.insert(
1211         std::make_pair(accelerator, accelerators[i].action));
1212   }
1213 }
1214
1215 void AcceleratorController::SetKeyboardBrightnessControlDelegate(
1216     scoped_ptr<KeyboardBrightnessControlDelegate>
1217     keyboard_brightness_control_delegate) {
1218   keyboard_brightness_control_delegate_ =
1219       keyboard_brightness_control_delegate.Pass();
1220 }
1221
1222 bool AcceleratorController::CanHandleAccelerators() const {
1223   return true;
1224 }
1225
1226 }  // namespace ash