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
81namespace ash {
82namespace {
83
84using base::UserMetricsAction;
85
86bool DebugShortcutsEnabled() {
87#if defined(NDEBUG)
88  return CommandLine::ForCurrentProcess()->HasSwitch(
89          switches::kAshDebugShortcuts);
90#else
91  return true;
92#endif
93}
94
95bool 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
126bool 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
135bool 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
144bool 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
150bool 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
157bool HandleLaunchAppN(int n) {
158  base::RecordAction(UserMetricsAction("Accel_Launch_App"));
159  Shelf::ForPrimaryDisplay()->LaunchAppIndexAt(n);
160  return true;
161}
162
163bool HandleLaunchLastApp() {
164  base::RecordAction(UserMetricsAction("Accel_Launch_Last_App"));
165  Shelf::ForPrimaryDisplay()->LaunchAppIndexAt(-1);
166  return true;
167}
168
169// Magnify the screen
170bool 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
193bool HandleMediaNextTrack() {
194  Shell::GetInstance()->media_delegate()->HandleMediaNextTrack();
195  return true;
196}
197
198bool HandleMediaPlayPause() {
199  Shell::GetInstance()->media_delegate()->HandleMediaPlayPause();
200  return true;
201}
202
203bool HandleMediaPrevTrack() {
204  Shell::GetInstance()->media_delegate()->HandleMediaPrevTrack();
205  return true;
206}
207
208bool 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
218bool 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
225bool 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
232void 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
257bool HandleOpenFeedbackPage() {
258  base::RecordAction(UserMetricsAction("Accel_Open_Feedback_Page"));
259  ash::Shell::GetInstance()->new_window_delegate()->OpenFeedbackPage();
260  return true;
261}
262
263bool 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
274bool 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
282bool HandleRestoreTab() {
283  base::RecordAction(base::UserMetricsAction("Accel_Restore_Tab"));
284  Shell::GetInstance()->new_window_delegate()->RestoreTab();
285  return true;
286}
287
288bool 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.
307bool 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
324gfx::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.
340bool 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
351bool 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
363bool 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)
382bool HandleSwapPrimaryDisplay() {
383  base::RecordAction(UserMetricsAction("Accel_Swap_Primary_Display"));
384  Shell::GetInstance()->display_controller()->SwapPrimaryDisplay();
385  return true;
386}
387#endif
388
389bool HandleShowKeyboardOverlay() {
390  base::RecordAction(UserMetricsAction("Accel_Show_Keyboard_Overlay"));
391  ash::Shell::GetInstance()->new_window_delegate()->ShowKeyboardOverlay();
392
393  return true;
394}
395
396void 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
410bool 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
421bool 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)
428void 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
439bool 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
447bool 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
458bool 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
468bool 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
492bool 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
500bool HandleToggleRootWindowFullScreen() {
501  Shell::GetPrimaryRootWindowController()->ash_host()->ToggleFullScreen();
502  return true;
503}
504
505bool 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
527bool HandleWindowMinimize() {
528  base::RecordAction(
529      base::UserMetricsAction("Accel_Toggle_Minimized_Minus"));
530  return accelerators::ToggleMinimized();
531}
532
533#if defined(OS_CHROMEOS)
534bool HandleAddRemoveDisplay() {
535  base::RecordAction(UserMetricsAction("Accel_Add_Remove_Display"));
536  Shell::GetInstance()->display_manager()->AddRemoveDisplay();
537  return true;
538}
539
540bool HandleCrosh() {
541  base::RecordAction(UserMetricsAction("Accel_Open_Crosh"));
542
543  Shell::GetInstance()->new_window_delegate()->OpenCrosh();
544  return true;
545}
546
547bool HandleFileManager() {
548  base::RecordAction(UserMetricsAction("Accel_Open_File_Manager"));
549
550  Shell::GetInstance()->new_window_delegate()->OpenFileManager();
551  return true;
552}
553
554bool HandleLock(ui::KeyboardCode key_code) {
555  base::RecordAction(UserMetricsAction("Accel_LockScreen_L"));
556  Shell::GetInstance()->session_state_delegate()->LockScreen();
557  return true;
558}
559
560bool 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
581bool HandleToggleMirrorMode() {
582  base::RecordAction(UserMetricsAction("Accel_Toggle_Mirror_Mode"));
583  Shell::GetInstance()->display_controller()->ToggleMirrorMode();
584  return true;
585}
586
587bool 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
595bool 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
608bool 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
618bool 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
628bool 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
635bool 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
658bool 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
684bool 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
694bool 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
706void 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
724bool 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
737bool 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
747class 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
765AcceleratorController::AcceleratorController()
766    : accelerator_manager_(new ui::AcceleratorManager) {
767  Init();
768}
769
770AcceleratorController::~AcceleratorController() {
771}
772
773void 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
814void AcceleratorController::Register(const ui::Accelerator& accelerator,
815                                     ui::AcceleratorTarget* target) {
816  accelerator_manager_->Register(accelerator,
817                                 ui::AcceleratorManager::kNormalPriority,
818                                 target);
819}
820
821void AcceleratorController::Unregister(const ui::Accelerator& accelerator,
822                                       ui::AcceleratorTarget* target) {
823  accelerator_manager_->Unregister(accelerator, target);
824}
825
826void AcceleratorController::UnregisterAll(ui::AcceleratorTarget* target) {
827  accelerator_manager_->UnregisterAll(target);
828}
829
830bool 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
840bool AcceleratorController::IsRegistered(
841    const ui::Accelerator& accelerator) const {
842  return accelerator_manager_->GetCurrentTarget(accelerator) != NULL;
843}
844
845bool 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
858bool 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
871bool 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
1134AcceleratorController::AcceleratorProcessingRestriction
1135AcceleratorController::GetCurrentAcceleratorRestriction() {
1136  return GetAcceleratorProcessingRestriction(-1);
1137}
1138
1139AcceleratorController::AcceleratorProcessingRestriction
1140AcceleratorController::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
1175void AcceleratorController::SetBrightnessControlDelegate(
1176    scoped_ptr<BrightnessControlDelegate> brightness_control_delegate) {
1177  brightness_control_delegate_ = brightness_control_delegate.Pass();
1178}
1179
1180void AcceleratorController::SetImeControlDelegate(
1181    scoped_ptr<ImeControlDelegate> ime_control_delegate) {
1182  ime_control_delegate_ = ime_control_delegate.Pass();
1183}
1184
1185void AcceleratorController::SetScreenshotDelegate(
1186    scoped_ptr<ScreenshotDelegate> screenshot_delegate) {
1187  screenshot_delegate_ = screenshot_delegate.Pass();
1188}
1189
1190////////////////////////////////////////////////////////////////////////////////
1191// AcceleratorController, ui::AcceleratorTarget implementation:
1192
1193bool 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
1201void 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
1215void AcceleratorController::SetKeyboardBrightnessControlDelegate(
1216    scoped_ptr<KeyboardBrightnessControlDelegate>
1217    keyboard_brightness_control_delegate) {
1218  keyboard_brightness_control_delegate_ =
1219      keyboard_brightness_control_delegate.Pass();
1220}
1221
1222bool AcceleratorController::CanHandleAccelerators() const {
1223  return true;
1224}
1225
1226}  // namespace ash
1227