Alphabetise AcceleratorController::PerformAction()

ash/accelerators/accelerator_controller.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ash/accelerators/accelerator_controller.h"
 
 #include <algorithm>
 #include <cmath>
 #include <string>
 
 #include "ash/accelerators/accelerator_commands.h"
-#include "ash/accelerators/accelerator_table.h"
 #include "ash/accelerators/debug_commands.h"
 #include "ash/ash_switches.h"
 #include "ash/debug.h"
 #include "ash/display/display_controller.h"
 #include "ash/display/display_manager.h"
 #include "ash/focus_cycler.h"
 #include "ash/gpu_support.h"
 #include "ash/ime_control_delegate.h"
 #include "ash/magnifier/magnification_controller.h"
 #include "ash/magnifier/partial_magnification_controller.h"
@@ skipping 97 matching lines @@
 
 bool HandleCycleForwardMRU(const ui::Accelerator& accelerator) {
   if (accelerator.key_code() == ui::VKEY_TAB)
     base::RecordAction(base::UserMetricsAction("Accel_NextWindow_Tab"));
 
   Shell::GetInstance()->window_cycle_controller()->HandleCycleWindow(
       WindowCycleController::FORWARD);
   return true;
 }
 
-bool ToggleOverview(const ui::Accelerator& accelerator) {
-  base::RecordAction(base::UserMetricsAction("Accel_Overview_F5"));
-  Shell::GetInstance()->window_selector_controller()->ToggleOverview();
+bool HandleRotatePaneFocus(Shell::Direction direction) {
+  Shell* shell = Shell::GetInstance();
+  switch (direction) {
+    // TODO(stevet): Not sure if this is the same as IDC_FOCUS_NEXT_PANE.
+    case Shell::FORWARD: {
+      base::RecordAction(UserMetricsAction("Accel_Focus_Next_Pane"));
+      shell->focus_cycler()->RotateFocus(FocusCycler::FORWARD);
+      break;
+    }
+    case Shell::BACKWARD: {
+      base::RecordAction(UserMetricsAction("Accel_Focus_Previous_Pane"));
+      shell->focus_cycler()->RotateFocus(FocusCycler::BACKWARD);
+      break;
+    }
+  }
   return true;
 }
 
 bool HandleFocusShelf() {
   Shell* shell = Shell::GetInstance();
   base::RecordAction(base::UserMetricsAction("Accel_Focus_Shelf"));
   return shell->focus_cycler()->FocusWidget(
       Shelf::ForPrimaryDisplay()->shelf_widget());
 }
 
@@ skipping 97 matching lines @@
   if (ime_control_delegate)
     ime_control_delegate->HandleNextIme();
 }
 
 bool HandleOpenFeedbackPage() {
   base::RecordAction(UserMetricsAction("Accel_Open_Feedback_Page"));
   ash::Shell::GetInstance()->new_window_delegate()->OpenFeedbackPage();
   return true;
 }
 
-bool HandlePositionCenter() {
-  base::RecordAction(UserMetricsAction("Accel_Window_Position_Center"));
-  aura::Window* window = wm::GetActiveWindow();
-  // Docked windows do not support centering and ignore accelerator.
-  if (window && !wm::GetWindowState(window)->IsDocked()) {
-    wm::CenterWindow(window);
-    return true;
-  }
-  return false;
-}
-
 bool HandlePreviousIme(ImeControlDelegate* ime_control_delegate,
                        const ui::Accelerator& accelerator) {
   base::RecordAction(UserMetricsAction("Accel_Previous_Ime"));
   if (ime_control_delegate)
     return ime_control_delegate->HandlePreviousIme(accelerator);
   return false;
 }
 
 bool HandleRestoreTab() {
   base::RecordAction(base::UserMetricsAction("Accel_Restore_Tab"));
   Shell::GetInstance()->new_window_delegate()->RestoreTab();
   return true;
 }
 
-bool HandleRotatePaneFocus(Shell::Direction direction) {
-  Shell* shell = Shell::GetInstance();
-  switch (direction) {
-    // TODO(stevet): Not sure if this is the same as IDC_FOCUS_NEXT_PANE.
-    case Shell::FORWARD: {
-      base::RecordAction(UserMetricsAction("Accel_Focus_Next_Pane"));
-      shell->focus_cycler()->RotateFocus(FocusCycler::FORWARD);
-      break;
-    }
-    case Shell::BACKWARD: {
-      base::RecordAction(UserMetricsAction("Accel_Focus_Previous_Pane"));
-      shell->focus_cycler()->RotateFocus(FocusCycler::BACKWARD);
-      break;
-    }
-  }
-  return true;
-}
-
-// Rotate the active window.
-bool HandleRotateActiveWindow() {
-  base::RecordAction(UserMetricsAction("Accel_Rotate_Window"));
-  aura::Window* active_window = wm::GetActiveWindow();
-  if (active_window) {
-    // The rotation animation bases its target transform on the current
-    // rotation and position. Since there could be an animation in progress
-    // right now, queue this animation so when it starts it picks up a neutral
-    // rotation and position. Use replace so we only enqueue one at a time.
-    active_window->layer()->GetAnimator()->
-        set_preemption_strategy(ui::LayerAnimator::REPLACE_QUEUED_ANIMATIONS);
-    active_window->layer()->GetAnimator()->StartAnimation(
-        new ui::LayerAnimationSequence(
-            new ash::ScreenRotation(360, active_window->layer())));
-  }
-  return true;
-}
-
 gfx::Display::Rotation GetNextRotation(gfx::Display::Rotation current) {
   switch (current) {
     case gfx::Display::ROTATE_0:
       return gfx::Display::ROTATE_90;
     case gfx::Display::ROTATE_90:
       return gfx::Display::ROTATE_180;
     case gfx::Display::ROTATE_180:
       return gfx::Display::ROTATE_270;
     case gfx::Display::ROTATE_270:
       return gfx::Display::ROTATE_0;
   }
   NOTREACHED() << "Unknown rotation:" << current;
   return gfx::Display::ROTATE_0;
 }
 
 // Rotates the screen.
 bool HandleRotateScreen() {
   base::RecordAction(UserMetricsAction("Accel_Rotate_Window"));
   gfx::Point point = Shell::GetScreen()->GetCursorScreenPoint();
   gfx::Display display = Shell::GetScreen()->GetDisplayNearestPoint(point);
   const DisplayInfo& display_info =
       Shell::GetInstance()->display_manager()->GetDisplayInfo(display.id());
   Shell::GetInstance()->display_manager()->SetDisplayRotation(
       display.id(), GetNextRotation(display_info.rotation()));
   return true;
 }
 
+// Rotate the active window.
+bool HandleRotateActiveWindow() {
+  base::RecordAction(UserMetricsAction("Accel_Rotate_Window"));
+  aura::Window* active_window = wm::GetActiveWindow();
+  if (active_window) {
+    // The rotation animation bases its target transform on the current
+    // rotation and position. Since there could be an animation in progress
+    // right now, queue this animation so when it starts it picks up a neutral
+    // rotation and position. Use replace so we only enqueue one at a time.
+    active_window->layer()->GetAnimator()->
+        set_preemption_strategy(ui::LayerAnimator::REPLACE_QUEUED_ANIMATIONS);
+    active_window->layer()->GetAnimator()->StartAnimation(
+        new ui::LayerAnimationSequence(
+            new ash::ScreenRotation(360, active_window->layer())));
+  }
+  return true;
+}
+
 bool HandleScaleReset() {
   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
   int64 display_id = display_manager->GetDisplayIdForUIScaling();
   if (display_id == gfx::Display::kInvalidDisplayID)
     return false;
 
   base::RecordAction(UserMetricsAction("Accel_Scale_Ui_Reset"));
 
   float ui_scale =
       display_manager->GetDisplayInfo(display_id).configured_ui_scale();
@@ skipping 15 matching lines @@
   } else {
     base::RecordAction(UserMetricsAction("Accel_Scale_Ui_Down"));
   }
 
   const DisplayInfo& display_info = display_manager->GetDisplayInfo(display_id);
   float next_scale = DisplayManager::GetNextUIScale(display_info, up);
   display_manager->SetDisplayUIScale(display_id, next_scale);
   return true;
 }
 
-#if defined(OS_CHROMEOS)
-bool HandleSwapPrimaryDisplay() {
-  base::RecordAction(UserMetricsAction("Accel_Swap_Primary_Display"));
-  Shell::GetInstance()->display_controller()->SwapPrimaryDisplay();
-  return true;
-}
-#endif
-
 bool HandleShowKeyboardOverlay() {
   base::RecordAction(UserMetricsAction("Accel_Show_Keyboard_Overlay"));
   ash::Shell::GetInstance()->new_window_delegate()->ShowKeyboardOverlay();
 
   return true;
 }
 
 bool HandleShowMessageCenterBubble() {
   base::RecordAction(UserMetricsAction("Accel_Show_Message_Center_Bubble"));
   RootWindowController* controller =
@@ skipping 21 matching lines @@
   }
   return false;
 }
 
 bool HandleShowTaskManager() {
   base::RecordAction(UserMetricsAction("Accel_Show_Task_Manager"));
   Shell::GetInstance()->new_window_delegate()->ShowTaskManager();
   return true;
 }
 
-#if defined(OS_CHROMEOS)
-void HandleSilenceSpokenFeedback() {
-  base::RecordAction(UserMetricsAction("Accel_Silence_Spoken_Feedback"));
-
-  AccessibilityDelegate* delegate =
-      Shell::GetInstance()->accessibility_delegate();
-  if (!delegate->IsSpokenFeedbackEnabled())
-    return;
-  delegate->SilenceSpokenFeedback();
-}
-#endif
-
 bool HandleSwitchIme(ImeControlDelegate* ime_control_delegate,
                      const ui::Accelerator& accelerator) {
   base::RecordAction(UserMetricsAction("Accel_Switch_Ime"));
   if (ime_control_delegate)
     return ime_control_delegate->HandleSwitchIme(accelerator);
   return false;
 }
 
 bool HandleTakePartialScreenshot(ScreenshotDelegate* screenshot_delegate) {
   base::RecordAction(UserMetricsAction("Accel_Take_Partial_Screenshot"));
@@ skipping 41 matching lines @@
 }
 
 bool HandleToggleFullscreen(ui::KeyboardCode key_code) {
   if (key_code == ui::VKEY_MEDIA_LAUNCH_APP2) {
     base::RecordAction(UserMetricsAction("Accel_Fullscreen_F4"));
   }
   accelerators::ToggleFullscreen();
   return true;
 }
 
-bool HandleWindowSnapOrDock(int action) {
+bool HandleToggleOverview(const ui::Accelerator& accelerator) {
+  base::RecordAction(base::UserMetricsAction("Accel_Overview_F5"));
+  Shell::GetInstance()->window_selector_controller()->ToggleOverview();
+  return true;
+}
+
+bool HandleWindowSnapOrDock(AcceleratorAction action) {
   wm::WindowState* window_state = wm::GetActiveWindowState();
   // Disable window snapping shortcut key for full screen window due to
   // http://crbug.com/135487.
   if (!window_state ||
       (window_state->window()->type() != ui::wm::WINDOW_TYPE_NORMAL &&
       window_state->window()->type() != ui::wm::WINDOW_TYPE_PANEL) ||
       window_state->IsFullscreen()) {
     return false;
   }
 
   if (action == WINDOW_CYCLE_SNAP_DOCK_LEFT)
     base::RecordAction(UserMetricsAction("Accel_Window_Snap_Left"));
   else
     base::RecordAction(UserMetricsAction("Accel_Window_Snap_Right"));
 
   const wm::WMEvent event(action == WINDOW_CYCLE_SNAP_DOCK_LEFT ?
                           wm::WM_EVENT_CYCLE_SNAP_DOCK_LEFT :
                           wm::WM_EVENT_CYCLE_SNAP_DOCK_RIGHT);
   window_state->OnWMEvent(&event);
   return true;
 }
 
 bool HandleWindowMinimize() {
   base::RecordAction(
       base::UserMetricsAction("Accel_Toggle_Minimized_Minus"));
   return accelerators::ToggleMinimized();
 }
 
+bool HandlePositionCenter() {
+  base::RecordAction(UserMetricsAction("Accel_Window_Position_Center"));
+  aura::Window* window = wm::GetActiveWindow();
+  // Docked windows do not support centering and ignore accelerator.
+  if (window && !wm::GetWindowState(window)->IsDocked()) {
+    wm::CenterWindow(window);
+    return true;
+  }
+  return false;
+}
+
 #if defined(OS_CHROMEOS)
+bool HandleDisableCapsLock(ui::KeyboardCode key_code,
+                           ui::EventType previous_event_type,
+                           ui::KeyboardCode previous_key_code) {
+  if (previous_event_type == ui::ET_KEY_RELEASED ||
+      (previous_key_code != ui::VKEY_LSHIFT &&
+       previous_key_code != ui::VKEY_SHIFT &&
+       previous_key_code != ui::VKEY_RSHIFT)) {
+    // If something else was pressed between the Shift key being pressed
+    // and released, then ignore the release of the Shift key.
+    return false;
+  }
+  base::RecordAction(UserMetricsAction("Accel_Disable_Caps_Lock"));
+  chromeos::input_method::InputMethodManager* ime =
+      chromeos::input_method::InputMethodManager::Get();
+  chromeos::input_method::ImeKeyboard* keyboard =
+      ime ? ime->GetImeKeyboard() : NULL;
+  if (keyboard && keyboard->CapsLockIsEnabled()) {
+    keyboard->SetCapsLockEnabled(false);
+    return true;
+  }
+  return false;
+}
+
+bool HandleLock(ui::KeyboardCode key_code) {
+  base::RecordAction(UserMetricsAction("Accel_LockScreen_L"));
+  Shell::GetInstance()->session_state_delegate()->LockScreen();
+  return true;
+}
+
 bool HandleCrosh() {
   base::RecordAction(UserMetricsAction("Accel_Open_Crosh"));
 
   Shell::GetInstance()->new_window_delegate()->OpenCrosh();
   return true;
 }
 
 bool HandleFileManager() {
   base::RecordAction(UserMetricsAction("Accel_Open_File_Manager"));
 
   Shell::GetInstance()->new_window_delegate()->OpenFileManager();
   return true;
 }
 
-bool HandleLock(ui::KeyboardCode key_code) {
-  base::RecordAction(UserMetricsAction("Accel_LockScreen_L"));
-  Shell::GetInstance()->session_state_delegate()->LockScreen();
+void HandleSilenceSpokenFeedback() {
+  base::RecordAction(UserMetricsAction("Accel_Silence_Spoken_Feedback"));
+
+  AccessibilityDelegate* delegate =
+      Shell::GetInstance()->accessibility_delegate();
+  if (!delegate->IsSpokenFeedbackEnabled())
+    return;
+  delegate->SilenceSpokenFeedback();
+}
+
+bool HandleSwapPrimaryDisplay() {
+  base::RecordAction(UserMetricsAction("Accel_Swap_Primary_Display"));
+  Shell::GetInstance()->display_controller()->SwapPrimaryDisplay();
   return true;
 }
 
 bool HandleCycleUser(SessionStateDelegate::CycleUser cycle_user) {
   if (!Shell::GetInstance()->delegate()->IsMultiProfilesEnabled())
     return false;
   ash::SessionStateDelegate* delegate =
       ash::Shell::GetInstance()->session_state_delegate();
   if (delegate->NumberOfLoggedInUsers() <= 1)
     return false;
   MultiProfileUMA::RecordSwitchActiveUser(
       MultiProfileUMA::SWITCH_ACTIVE_USER_BY_ACCELERATOR);
   switch (cycle_user) {
     case SessionStateDelegate::CYCLE_TO_NEXT_USER:
       base::RecordAction(UserMetricsAction("Accel_Switch_To_Next_User"));
       break;
     case SessionStateDelegate::CYCLE_TO_PREVIOUS_USER:
       base::RecordAction(UserMetricsAction("Accel_Switch_To_Previous_User"));
       break;
   }
   delegate->CycleActiveUser(cycle_user);
   return true;
 }
 
+bool HandleToggleCapsLock(ui::KeyboardCode key_code,
+                          ui::EventType previous_event_type,
+                          ui::KeyboardCode previous_key_code) {
+  if (key_code == ui::VKEY_LWIN) {
+    // If something else was pressed between the Search key (LWIN)
+    // being pressed and released, then ignore the release of the
+    // Search key.
+    // TODO(danakj): Releasing Alt first breaks this: crbug.com/166495
+    if (previous_event_type == ui::ET_KEY_RELEASED ||
+        previous_key_code != ui::VKEY_LWIN)
+      return false;
+  }
+  base::RecordAction(UserMetricsAction("Accel_Toggle_Caps_Lock"));
+  chromeos::input_method::InputMethodManager* ime =
+      chromeos::input_method::InputMethodManager::Get();
+  chromeos::input_method::ImeKeyboard* keyboard =
+      ime ? ime->GetImeKeyboard() : NULL;
+  if (keyboard)
+    keyboard->SetCapsLockEnabled(!keyboard->CapsLockIsEnabled());
+  return true;
+}
+
 bool HandleToggleMirrorMode() {
   base::RecordAction(UserMetricsAction("Accel_Toggle_Mirror_Mode"));
   Shell::GetInstance()->display_controller()->ToggleMirrorMode();
   return true;
 }
 
 bool HandleToggleSpokenFeedback() {
   base::RecordAction(UserMetricsAction("Accel_Toggle_Spoken_Feedback"));
 
   Shell::GetInstance()->accessibility_delegate()->
@@ skipping 27 matching lines @@
 bool HandleTouchHudModeChange() {
   RootWindowController* controller =
       RootWindowController::ForTargetRootWindow();
   if (controller->touch_hud_debug()) {
     controller->touch_hud_debug()->ChangeToNextMode();
     return true;
   }
   return false;
 }
 
-bool HandleDisableCapsLock(ui::KeyboardCode key_code,
-                           ui::EventType previous_event_type,
-                           ui::KeyboardCode previous_key_code) {
-  if (previous_event_type == ui::ET_KEY_RELEASED ||
-      (previous_key_code != ui::VKEY_LSHIFT &&
-       previous_key_code != ui::VKEY_SHIFT &&
-       previous_key_code != ui::VKEY_RSHIFT)) {
-    // If something else was pressed between the Shift key being pressed
-    // and released, then ignore the release of the Shift key.
-    return false;
-  }
-  base::RecordAction(UserMetricsAction("Accel_Disable_Caps_Lock"));
-  chromeos::input_method::InputMethodManager* ime =
-      chromeos::input_method::InputMethodManager::Get();
-  chromeos::input_method::ImeKeyboard* keyboard =
-      ime ? ime->GetImeKeyboard() : NULL;
-  if (keyboard && keyboard->CapsLockIsEnabled()) {
-    keyboard->SetCapsLockEnabled(false);
-    return true;
-  }
-  return false;
-}
-
-bool HandleToggleCapsLock(ui::KeyboardCode key_code,
-                          ui::EventType previous_event_type,
-                          ui::KeyboardCode previous_key_code) {
-  if (key_code == ui::VKEY_LWIN) {
-    // If something else was pressed between the Search key (LWIN)
-    // being pressed and released, then ignore the release of the
-    // Search key.
-    // TODO(danakj): Releasing Alt first breaks this: crbug.com/166495
-    if (previous_event_type == ui::ET_KEY_RELEASED ||
-        previous_key_code != ui::VKEY_LWIN)
-      return false;
-  }
-  base::RecordAction(UserMetricsAction("Accel_Toggle_Caps_Lock"));
-  chromeos::input_method::InputMethodManager* ime =
-      chromeos::input_method::InputMethodManager::Get();
-  chromeos::input_method::ImeKeyboard* keyboard =
-      ime ? ime->GetImeKeyboard() : NULL;
-  if (keyboard)
-    keyboard->SetCapsLockEnabled(!keyboard->CapsLockIsEnabled());
-  return true;
-}
-
 #endif  // defined(OS_CHROMEOS)
 
 class AutoSet {
  public:
   AutoSet(ui::Accelerator* scoped, ui::Accelerator new_value)
       : scoped_(scoped), new_value_(new_value) {}
   ~AutoSet() { *scoped_ = new_value_; }
 
  private:
   ui::Accelerator* scoped_;
   const ui::Accelerator new_value_;
 
   DISALLOW_COPY_AND_ASSIGN(AutoSet);
 };
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // AcceleratorController, public:
 
 AcceleratorController::AcceleratorController()
     : accelerator_manager_(new ui::AcceleratorManager) {
   Init();
 }
 
 AcceleratorController::~AcceleratorController() {
 }
 
-void AcceleratorController::Init() {
-  previous_accelerator_.set_type(ui::ET_UNKNOWN);
-  for (size_t i = 0; i < kActionsAllowedAtLoginOrLockScreenLength; ++i) {
-    actions_allowed_at_login_screen_.insert(
-        kActionsAllowedAtLoginOrLockScreen[i]);
-    actions_allowed_at_lock_screen_.insert(
-        kActionsAllowedAtLoginOrLockScreen[i]);
-  }
-  for (size_t i = 0; i < kActionsAllowedAtLockScreenLength; ++i)
-    actions_allowed_at_lock_screen_.insert(kActionsAllowedAtLockScreen[i]);
-  for (size_t i = 0; i < kActionsAllowedAtModalWindowLength; ++i)
-    actions_allowed_at_modal_window_.insert(kActionsAllowedAtModalWindow[i]);
-  for (size_t i = 0; i < kPreferredActionsLength; ++i)
-    preferred_actions_.insert(kPreferredActions[i]);
-  for (size_t i = 0; i < kReservedActionsLength; ++i)
-    reserved_actions_.insert(kReservedActions[i]);
-  for (size_t i = 0; i < kNonrepeatableActionsLength; ++i)
-    nonrepeatable_actions_.insert(kNonrepeatableActions[i]);
-  for (size_t i = 0; i < kActionsAllowedInAppModeLength; ++i)
-    actions_allowed_in_app_mode_.insert(kActionsAllowedInAppMode[i]);
-  for (size_t i = 0; i < kActionsNeedingWindowLength; ++i)
-    actions_needing_window_.insert(kActionsNeedingWindow[i]);
-
-  RegisterAccelerators(kAcceleratorData, kAcceleratorDataLength);
-
-  if (debug::DebugAcceleratorsEnabled()) {
-    RegisterAccelerators(kDebugAcceleratorData, kDebugAcceleratorDataLength);
-    // All debug accelerators are reserved.
-    for (size_t i = 0; i < kDebugAcceleratorDataLength; ++i)
-      reserved_actions_.insert(kDebugAcceleratorData[i].action);
-  }
-
-#if defined(OS_CHROMEOS)
-  keyboard_brightness_control_delegate_.reset(
-      new KeyboardBrightnessController());
-#endif
-}
-
 void AcceleratorController::Register(const ui::Accelerator& accelerator,
                                      ui::AcceleratorTarget* target) {
   accelerator_manager_->Register(accelerator,
                                  ui::AcceleratorManager::kNormalPriority,
                                  target);
 }
 
 void AcceleratorController::Unregister(const ui::Accelerator& accelerator,
                                        ui::AcceleratorTarget* target) {
   accelerator_manager_->Unregister(accelerator, target);
@@ skipping 16 matching lines @@
 bool AcceleratorController::IsRegistered(
     const ui::Accelerator& accelerator) const {
   return accelerator_manager_->GetCurrentTarget(accelerator) != NULL;
 }
 
 bool AcceleratorController::IsPreferred(
     const ui::Accelerator& accelerator) const {
   const ui::Accelerator remapped_accelerator = ime_control_delegate_.get() ?
       ime_control_delegate_->RemapAccelerator(accelerator) : accelerator;
 
-  std::map<ui::Accelerator, int>::const_iterator iter =
+  std::map<ui::Accelerator, AcceleratorAction>::const_iterator iter =
       accelerators_.find(remapped_accelerator);
   if (iter == accelerators_.end())
     return false;  // not an accelerator.
 
   return preferred_actions_.find(iter->second) != preferred_actions_.end();
 }
 
 bool AcceleratorController::IsReserved(
     const ui::Accelerator& accelerator) const {
   const ui::Accelerator remapped_accelerator = ime_control_delegate_.get() ?
       ime_control_delegate_->RemapAccelerator(accelerator) : accelerator;
 
-  std::map<ui::Accelerator, int>::const_iterator iter =
+  std::map<ui::Accelerator, AcceleratorAction>::const_iterator iter =
       accelerators_.find(remapped_accelerator);
   if (iter == accelerators_.end())
     return false;  // not an accelerator.
 
   return reserved_actions_.find(iter->second) != reserved_actions_.end();
 }
 
-bool AcceleratorController::PerformActionIfEnabled(int action) {
+bool AcceleratorController::PerformActionIfEnabled(AcceleratorAction action) {
   return PerformAction(action, ui::Accelerator());
 }
 
-bool AcceleratorController::PerformAction(int action,
+AcceleratorController::AcceleratorProcessingRestriction
+AcceleratorController::GetCurrentAcceleratorRestriction() {
+  return GetAcceleratorProcessingRestriction(-1);
+}
+
+void AcceleratorController::SetBrightnessControlDelegate(
+    scoped_ptr<BrightnessControlDelegate> brightness_control_delegate) {
+  brightness_control_delegate_ = brightness_control_delegate.Pass();
+}
+
+void AcceleratorController::SetImeControlDelegate(
+    scoped_ptr<ImeControlDelegate> ime_control_delegate) {
+  ime_control_delegate_ = ime_control_delegate.Pass();
+}
+
+void AcceleratorController::SetScreenshotDelegate(
+    scoped_ptr<ScreenshotDelegate> screenshot_delegate) {
+  screenshot_delegate_ = screenshot_delegate.Pass();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// AcceleratorController, ui::AcceleratorTarget implementation:
+
+bool AcceleratorController::AcceleratorPressed(
+    const ui::Accelerator& accelerator) {
+  std::map<ui::Accelerator, AcceleratorAction>::const_iterator it =
+      accelerators_.find(accelerator);
+  DCHECK(it != accelerators_.end());
+  return PerformAction(it->second, accelerator);
+}
+
+bool AcceleratorController::CanHandleAccelerators() const {
+  return true;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// AcceleratorController, private:
+
+void AcceleratorController::Init() {
+  previous_accelerator_.set_type(ui::ET_UNKNOWN);
+  for (size_t i = 0; i < kActionsAllowedAtLoginOrLockScreenLength; ++i) {
+    actions_allowed_at_login_screen_.insert(
+        kActionsAllowedAtLoginOrLockScreen[i]);
+    actions_allowed_at_lock_screen_.insert(
+        kActionsAllowedAtLoginOrLockScreen[i]);
+  }
+  for (size_t i = 0; i < kActionsAllowedAtLockScreenLength; ++i)
+    actions_allowed_at_lock_screen_.insert(kActionsAllowedAtLockScreen[i]);
+  for (size_t i = 0; i < kActionsAllowedAtModalWindowLength; ++i)
+    actions_allowed_at_modal_window_.insert(kActionsAllowedAtModalWindow[i]);
+  for (size_t i = 0; i < kPreferredActionsLength; ++i)
+    preferred_actions_.insert(kPreferredActions[i]);
+  for (size_t i = 0; i < kReservedActionsLength; ++i)
+    reserved_actions_.insert(kReservedActions[i]);
+  for (size_t i = 0; i < kNonrepeatableActionsLength; ++i)
+    nonrepeatable_actions_.insert(kNonrepeatableActions[i]);
+  for (size_t i = 0; i < kActionsAllowedInAppModeLength; ++i)
+    actions_allowed_in_app_mode_.insert(kActionsAllowedInAppMode[i]);
+  for (size_t i = 0; i < kActionsNeedingWindowLength; ++i)
+    actions_needing_window_.insert(kActionsNeedingWindow[i]);
+
+  RegisterAccelerators(kAcceleratorData, kAcceleratorDataLength);
+
+  if (debug::DebugAcceleratorsEnabled()) {
+    RegisterAccelerators(kDebugAcceleratorData, kDebugAcceleratorDataLength);
+    // All debug accelerators are reserved.
+    for (size_t i = 0; i < kDebugAcceleratorDataLength; ++i)
+      reserved_actions_.insert(kDebugAcceleratorData[i].action);
+  }
+
+#if defined(OS_CHROMEOS)
+  keyboard_brightness_control_delegate_.reset(
+      new KeyboardBrightnessController());
+#endif
+}
+
+void AcceleratorController::RegisterAccelerators(
+    const AcceleratorData accelerators[],
+    size_t accelerators_length) {
+  for (size_t i = 0; i < accelerators_length; ++i) {
+    ui::Accelerator accelerator(accelerators[i].keycode,
+                                accelerators[i].modifiers);
+    accelerator.set_type(accelerators[i].trigger_on_press ?
+                         ui::ET_KEY_PRESSED : ui::ET_KEY_RELEASED);
+    Register(accelerator, this);
+    accelerators_.insert(
+        std::make_pair(accelerator, accelerators[i].action));
+  }
+}
+
+bool AcceleratorController::PerformAction(AcceleratorAction action,
                                           const ui::Accelerator& accelerator) {
   ash::Shell* shell = ash::Shell::GetInstance();
   AcceleratorProcessingRestriction restriction =
       GetAcceleratorProcessingRestriction(action);
   if (restriction != RESTRICTION_NONE)
     return restriction == RESTRICTION_PREVENT_PROCESSING_AND_PROPAGATION;
 
   if (nonrepeatable_actions_.find(action) != nonrepeatable_actions_.end() &&
       accelerator.IsRepeat()) {
     return true;
@@ skipping 10 matching lines @@
   // and BrowserView::HandleKeyboardEvent, for a single accelerator press.
   //
   // If your accelerator invokes more than one line of code, please either
   // implement it in your module's controller code (like TOGGLE_MIRROR_MODE
   // below) or pull it into a HandleFoo() function above.
   switch (action) {
     case ACCESSIBLE_FOCUS_NEXT:
       return HandleAccessibleFocusCycle(false);
     case ACCESSIBLE_FOCUS_PREVIOUS:
       return HandleAccessibleFocusCycle(true);
-    case CYCLE_BACKWARD_MRU:
-      return HandleCycleBackwardMRU(accelerator);
-    case CYCLE_FORWARD_MRU:
-      return HandleCycleForwardMRU(accelerator);
-    case TOGGLE_OVERVIEW:
-      return ToggleOverview(accelerator);
-#if defined(OS_CHROMEOS)
-    case TOGGLE_MIRROR_MODE:
-      return HandleToggleMirrorMode();
-    case LOCK_SCREEN:
-      return HandleLock(key_code);
-    case OPEN_FILE_MANAGER:
-      return HandleFileManager();
-    case OPEN_CROSH:
-      return HandleCrosh();
-    case SILENCE_SPOKEN_FEEDBACK:
-      HandleSilenceSpokenFeedback();
-      return false;
-    case SWAP_PRIMARY_DISPLAY:
-      return HandleSwapPrimaryDisplay();
-    case SWITCH_TO_NEXT_USER:
-      return HandleCycleUser(SessionStateDelegate::CYCLE_TO_NEXT_USER);
-    case SWITCH_TO_PREVIOUS_USER:
-      return HandleCycleUser(SessionStateDelegate::CYCLE_TO_PREVIOUS_USER);
-    case TOGGLE_SPOKEN_FEEDBACK:
-      return HandleToggleSpokenFeedback();
-    case TOGGLE_TOUCH_VIEW_TESTING:
-      return HandleToggleTouchViewTesting();
-    case TOGGLE_WIFI:
-      Shell::GetInstance()->system_tray_notifier()->NotifyRequestToggleWifi();
-      return true;
-    case TOUCH_HUD_CLEAR:
-      return HandleTouchHudClear();
-    case TOUCH_HUD_MODE_CHANGE:
-      return HandleTouchHudModeChange();
-    case TOUCH_HUD_PROJECTION_TOGGLE:
-      accelerators::ToggleTouchHudProjection();
-      return true;
-    case DISABLE_GPU_WATCHDOG:
-      Shell::GetInstance()->gpu_support()->DisableGpuWatchdog();
-      return true;
-    case DISABLE_CAPS_LOCK:
-      return HandleDisableCapsLock(
-          key_code, previous_event_type, previous_key_code);
-    case TOGGLE_CAPS_LOCK:
-      return HandleToggleCapsLock(
-          key_code, previous_event_type, previous_key_code);
-#endif  // OS_CHROMEOS
-    case OPEN_FEEDBACK_PAGE:
-      return HandleOpenFeedbackPage();
-    case EXIT:
-      // UMA metrics are recorded in the handler.
-      exit_warning_handler_.HandleAccelerator();
-      return true;
-    case NEW_INCOGNITO_WINDOW:
-      return HandleNewIncognitoWindow();
-    case NEW_TAB:
-      return HandleNewTab(key_code);
-    case NEW_WINDOW:
-      return HandleNewWindow();
-    case RESTORE_TAB:
-      return HandleRestoreTab();
-    case TAKE_SCREENSHOT:
-      return HandleTakeScreenshot(screenshot_delegate_.get());
-    case TAKE_PARTIAL_SCREENSHOT:
-      return HandleTakePartialScreenshot(screenshot_delegate_.get());
-    case TOGGLE_APP_LIST:
-      return HandleToggleAppList(
-          key_code, previous_event_type, previous_key_code, accelerator);
     case BRIGHTNESS_DOWN:
       if (brightness_control_delegate_)
         return brightness_control_delegate_->HandleBrightnessDown(accelerator);
       return false;
     case BRIGHTNESS_UP:
       if (brightness_control_delegate_)
         return brightness_control_delegate_->HandleBrightnessUp(accelerator);
       return false;
-    case KEYBOARD_BRIGHTNESS_DOWN:
-      if (keyboard_brightness_control_delegate_)
-        return keyboard_brightness_control_delegate_->
-            HandleKeyboardBrightnessDown(accelerator);
-      return false;
-    case KEYBOARD_BRIGHTNESS_UP:
-      if (keyboard_brightness_control_delegate_)
-        return keyboard_brightness_control_delegate_->
-            HandleKeyboardBrightnessUp(accelerator);
-      return false;
-    case VOLUME_MUTE: {
-      ash::VolumeControlDelegate* volume_delegate =
-          shell->system_tray_delegate()->GetVolumeControlDelegate();
-      return volume_delegate && volume_delegate->HandleVolumeMute(accelerator);
-    }
-    case VOLUME_DOWN: {
-      ash::VolumeControlDelegate* volume_delegate =
-          shell->system_tray_delegate()->GetVolumeControlDelegate();
-      return volume_delegate && volume_delegate->HandleVolumeDown(accelerator);
-    }
-    case VOLUME_UP: {
-      ash::VolumeControlDelegate* volume_delegate =
-          shell->system_tray_delegate()->GetVolumeControlDelegate();
-      return volume_delegate && volume_delegate->HandleVolumeUp(accelerator);
-    }
-    case FOCUS_SHELF:
-      return HandleFocusShelf();
+    case CYCLE_BACKWARD_MRU:
+      return HandleCycleBackwardMRU(accelerator);
+    case CYCLE_FORWARD_MRU:
+      return HandleCycleForwardMRU(accelerator);
+    case DEBUG_PRINT_LAYER_HIERARCHY:
+    case DEBUG_PRINT_VIEW_HIERARCHY:
+    case DEBUG_PRINT_WINDOW_HIERARCHY:
+    case DEBUG_TOGGLE_DESKTOP_BACKGROUND_MODE:
+    case DEBUG_TOGGLE_DEVICE_SCALE_FACTOR:
+    case DEBUG_TOGGLE_ROOT_WINDOW_FULL_SCREEN:
+    case DEBUG_TOGGLE_SHOW_DEBUG_BORDERS:
+    case DEBUG_TOGGLE_SHOW_FPS_COUNTER:
+    case DEBUG_TOGGLE_SHOW_PAINT_RECTS:
+      return debug::PerformDebugAction(action);
+    case EXIT:
+      // UMA metrics are recorded in the handler.
+      exit_warning_handler_.HandleAccelerator();
+      return true;
     case FOCUS_NEXT_PANE:
       return HandleRotatePaneFocus(Shell::FORWARD);
     case FOCUS_PREVIOUS_PANE:
       return HandleRotatePaneFocus(Shell::BACKWARD);
-    case SHOW_KEYBOARD_OVERLAY:
-      return HandleShowKeyboardOverlay();
-    case SHOW_SYSTEM_TRAY_BUBBLE:
-      return HandleShowSystemTrayBubble();
-    case SHOW_MESSAGE_CENTER_BUBBLE:
-      return HandleShowMessageCenterBubble();
-    case SHOW_TASK_MANAGER:
-      return HandleShowTaskManager();
-    case NEXT_IME:
-      HandleNextIme(
-          ime_control_delegate_.get(), previous_event_type, previous_key_code);
-      // NEXT_IME is bound to Alt-Shift key up event. To be consistent with
-      // Windows behavior, do not consume the key event here.
-      return false;
-    case PREVIOUS_IME:
-      return HandlePreviousIme(ime_control_delegate_.get(), accelerator);
-    case PRINT_UI_HIERARCHIES:
-      debug::PrintUIHierarchies();
-      return true;
-    case SWITCH_IME:
-      return HandleSwitchIme(ime_control_delegate_.get(), accelerator);
+    case FOCUS_SHELF:
+      return HandleFocusShelf();
     case LAUNCH_APP_0:
       return HandleLaunchAppN(0);
     case LAUNCH_APP_1:
       return HandleLaunchAppN(1);
     case LAUNCH_APP_2:
       return HandleLaunchAppN(2);
     case LAUNCH_APP_3:
       return HandleLaunchAppN(3);
     case LAUNCH_APP_4:
       return HandleLaunchAppN(4);
     case LAUNCH_APP_5:
       return HandleLaunchAppN(5);
     case LAUNCH_APP_6:
       return HandleLaunchAppN(6);
     case LAUNCH_APP_7:
       return HandleLaunchAppN(7);
     case LAUNCH_LAST_APP:
       return HandleLaunchLastApp();
-    case WINDOW_CYCLE_SNAP_DOCK_LEFT:
-    case WINDOW_CYCLE_SNAP_DOCK_RIGHT:
-      return HandleWindowSnapOrDock(action);
-    case WINDOW_MINIMIZE:
-      return HandleWindowMinimize();
-    case TOGGLE_FULLSCREEN:
-      return HandleToggleFullscreen(key_code);
-    case TOGGLE_MAXIMIZED:
-      accelerators::ToggleMaximized();
-      return true;
-    case WINDOW_POSITION_CENTER:
-     return HandlePositionCenter();
-    case SCALE_UI_UP:
-      return HandleScaleUI(true /* up */);
-    case SCALE_UI_DOWN:
-      return HandleScaleUI(false /* down */);
-    case SCALE_UI_RESET:
-      return HandleScaleReset();
-    case ROTATE_WINDOW:
-      return HandleRotateActiveWindow();
-    case ROTATE_SCREEN:
-      return HandleRotateScreen();
     case MAGNIFY_SCREEN_ZOOM_IN:
       return HandleMagnifyScreen(1);
     case MAGNIFY_SCREEN_ZOOM_OUT:
       return HandleMagnifyScreen(-1);
     case MEDIA_NEXT_TRACK:
       return HandleMediaNextTrack();
     case MEDIA_PLAY_PAUSE:
        return HandleMediaPlayPause();
     case MEDIA_PREV_TRACK:
        return HandleMediaPrevTrack();
+    case NEW_INCOGNITO_WINDOW:
+      return HandleNewIncognitoWindow();
+    case NEW_TAB:
+      return HandleNewTab(key_code);
+    case NEW_WINDOW:
+      return HandleNewWindow();
+    case NEXT_IME:
+      HandleNextIme(
+          ime_control_delegate_.get(), previous_event_type, previous_key_code);
+      // NEXT_IME is bound to Alt-Shift key up event. To be consistent with
+      // Windows behavior, do not consume the key event here.
+      return false;
+    case OPEN_FEEDBACK_PAGE:
+      return HandleOpenFeedbackPage();
+    case PREVIOUS_IME:
+      return HandlePreviousIme(ime_control_delegate_.get(), accelerator);
+    case PRINT_UI_HIERARCHIES:
+      debug::PrintUIHierarchies();
+      return true;
+    case RESTORE_TAB:
+      return HandleRestoreTab();
+    case ROTATE_SCREEN:
+      return HandleRotateScreen();
+    case ROTATE_WINDOW:
+      return HandleRotateActiveWindow();
+    case SCALE_UI_DOWN:
+      return HandleScaleUI(false /* down */);
+    case SCALE_UI_RESET:
+      return HandleScaleReset();
+    case SCALE_UI_UP:
+      return HandleScaleUI(true /* up */);
+    case SHOW_KEYBOARD_OVERLAY:
+      return HandleShowKeyboardOverlay();
+    case SHOW_MESSAGE_CENTER_BUBBLE:
+      return HandleShowMessageCenterBubble();
+    case SHOW_SYSTEM_TRAY_BUBBLE:
+      return HandleShowSystemTrayBubble();
+    case SHOW_TASK_MANAGER:
+      return HandleShowTaskManager();
+    case SWITCH_IME:
+      return HandleSwitchIme(ime_control_delegate_.get(), accelerator);
+    case TAKE_PARTIAL_SCREENSHOT:
+      return HandleTakePartialScreenshot(screenshot_delegate_.get());
+    case TAKE_SCREENSHOT:
+      return HandleTakeScreenshot(screenshot_delegate_.get());
+    case TOGGLE_APP_LIST:
+      return HandleToggleAppList(
+          key_code, previous_event_type, previous_key_code, accelerator);
+    case TOGGLE_FULLSCREEN:
+      return HandleToggleFullscreen(key_code);
+    case TOGGLE_MAXIMIZED:
+      accelerators::ToggleMaximized();
+      return true;
+    case TOGGLE_OVERVIEW:
+      return HandleToggleOverview(accelerator);
+    case VOLUME_DOWN: {
+      ash::VolumeControlDelegate* volume_delegate =
+          shell->system_tray_delegate()->GetVolumeControlDelegate();
+      return volume_delegate && volume_delegate->HandleVolumeDown(accelerator);
+    }
+    case VOLUME_MUTE: {
+      ash::VolumeControlDelegate* volume_delegate =
+          shell->system_tray_delegate()->GetVolumeControlDelegate();
+      return volume_delegate && volume_delegate->HandleVolumeMute(accelerator);
+    }
+    case VOLUME_UP: {
+      ash::VolumeControlDelegate* volume_delegate =
+          shell->system_tray_delegate()->GetVolumeControlDelegate();
+      return volume_delegate && volume_delegate->HandleVolumeUp(accelerator);
+    }
+    case WINDOW_CYCLE_SNAP_DOCK_LEFT:
+    case WINDOW_CYCLE_SNAP_DOCK_RIGHT:
+      return HandleWindowSnapOrDock(action);
+    case WINDOW_MINIMIZE:
+      return HandleWindowMinimize();
+    case WINDOW_POSITION_CENTER:
+      return HandlePositionCenter();
+#if defined(OS_CHROMEOS)
+    case DEBUG_ADD_REMOVE_DISPLAY:
+      return debug::PerformDebugAction(action);
+    case DISABLE_CAPS_LOCK:
+      return HandleDisableCapsLock(
+          key_code, previous_event_type, previous_key_code);
+    case DISABLE_GPU_WATCHDOG:
+      Shell::GetInstance()->gpu_support()->DisableGpuWatchdog();
+      return true;
+    case KEYBOARD_BRIGHTNESS_DOWN:
+      if (keyboard_brightness_control_delegate_)
+        return keyboard_brightness_control_delegate_->
+            HandleKeyboardBrightnessDown(accelerator);
+      return false;
+    case KEYBOARD_BRIGHTNESS_UP:
+      if (keyboard_brightness_control_delegate_)
+        return keyboard_brightness_control_delegate_->
+            HandleKeyboardBrightnessUp(accelerator);
+      return false;
+    case LOCK_PRESSED:
+    case LOCK_RELEASED:
+      Shell::GetInstance()->power_button_controller()->
+          OnLockButtonEvent(action == LOCK_PRESSED, base::TimeTicks());
+      return true;
+    case LOCK_SCREEN:
+      return HandleLock(key_code);
+    case OPEN_CROSH:
+      return HandleCrosh();
+    case OPEN_FILE_MANAGER:
+      return HandleFileManager();
     case POWER_PRESSED:  // fallthrough
     case POWER_RELEASED:
-#if defined(OS_CHROMEOS)
       if (!base::SysInfo::IsRunningOnChromeOS()) {
         // There is no powerd in linux desktop, so call the
         // PowerButtonController here.
         Shell::GetInstance()->power_button_controller()->
             OnPowerButtonEvent(action == POWER_PRESSED, base::TimeTicks());
       }
-#endif
       // We don't do anything with these at present on the device,
       // (power button events are reported to us from powerm via
       // D-BUS), but we consume them to prevent them from getting
       // passed to apps -- see http://crbug.com/146609.
       return true;
-    case LOCK_PRESSED:
-    case LOCK_RELEASED:
-      Shell::GetInstance()->power_button_controller()->
-          OnLockButtonEvent(action == LOCK_PRESSED, base::TimeTicks());
+    case SILENCE_SPOKEN_FEEDBACK:
+      HandleSilenceSpokenFeedback();
+      return false;
+    case SWAP_PRIMARY_DISPLAY:
+      return HandleSwapPrimaryDisplay();
+    case SWITCH_TO_NEXT_USER:
+      return HandleCycleUser(SessionStateDelegate::CYCLE_TO_NEXT_USER);
+    case SWITCH_TO_PREVIOUS_USER:
+      return HandleCycleUser(SessionStateDelegate::CYCLE_TO_PREVIOUS_USER);
+    case TOGGLE_CAPS_LOCK:
+      return HandleToggleCapsLock(
+          key_code, previous_event_type, previous_key_code);
+    case TOGGLE_MIRROR_MODE:
+      return HandleToggleMirrorMode();
+    case TOGGLE_SPOKEN_FEEDBACK:
+      return HandleToggleSpokenFeedback();
+    case TOGGLE_TOUCH_VIEW_TESTING:
+      return HandleToggleTouchViewTesting();
+    case TOGGLE_WIFI:
+      Shell::GetInstance()->system_tray_notifier()->NotifyRequestToggleWifi();
       return true;
-    default:
-      DCHECK(debug::DebugAcceleratorsEnabled())
-          << "Unhandled action " << action;
+    case TOUCH_HUD_CLEAR:
+      return HandleTouchHudClear();
+    case TOUCH_HUD_MODE_CHANGE:
+      return HandleTouchHudModeChange();
+    case TOUCH_HUD_PROJECTION_TOGGLE:
+      accelerators::ToggleTouchHudProjection();
+      return true;
+#else
+    case DUMMY_FOR_RESERVED:
+      NOTREACHED();
+      return false;
+#endif  // OS_CHROMEOS
   }
-
-  // If |action| is a debug action, run it.
-  return debug::PerformDebugAction(action);
+  return false;
 }
 
 AcceleratorController::AcceleratorProcessingRestriction
-AcceleratorController::GetCurrentAcceleratorRestriction() {
-  return GetAcceleratorProcessingRestriction(-1);
-}
-
-AcceleratorController::AcceleratorProcessingRestriction
 AcceleratorController::GetAcceleratorProcessingRestriction(int action) {
   ash::Shell* shell = ash::Shell::GetInstance();
   if (!shell->session_state_delegate()->IsActiveUserSessionStarted() &&
       actions_allowed_at_login_screen_.find(action) ==
           actions_allowed_at_login_screen_.end()) {
     return RESTRICTION_PREVENT_PROCESSING;
   }
   if (shell->session_state_delegate()->IsScreenLocked() &&
       actions_allowed_at_lock_screen_.find(action) ==
           actions_allowed_at_lock_screen_.end()) {
@@ skipping 15 matching lines @@
   }
   if (MruWindowTracker::BuildWindowList(false).empty() &&
       actions_needing_window_.find(action) != actions_needing_window_.end()) {
     Shell::GetInstance()->accessibility_delegate()->TriggerAccessibilityAlert(
         ui::A11Y_ALERT_WINDOW_NEEDED);
     return RESTRICTION_PREVENT_PROCESSING_AND_PROPAGATION;
   }
   return RESTRICTION_NONE;
 }
 
-void AcceleratorController::SetBrightnessControlDelegate(
-    scoped_ptr<BrightnessControlDelegate> brightness_control_delegate) {
-  brightness_control_delegate_ = brightness_control_delegate.Pass();
-}
-
-void AcceleratorController::SetImeControlDelegate(
-    scoped_ptr<ImeControlDelegate> ime_control_delegate) {
-  ime_control_delegate_ = ime_control_delegate.Pass();
-}
-
-void AcceleratorController::SetScreenshotDelegate(
-    scoped_ptr<ScreenshotDelegate> screenshot_delegate) {
-  screenshot_delegate_ = screenshot_delegate.Pass();
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// AcceleratorController, ui::AcceleratorTarget implementation:
-
-bool AcceleratorController::AcceleratorPressed(
-    const ui::Accelerator& accelerator) {
-  std::map<ui::Accelerator, int>::const_iterator it =
-      accelerators_.find(accelerator);
-  DCHECK(it != accelerators_.end());
-  return PerformAction(static_cast<AcceleratorAction>(it->second), accelerator);
-}
-
-void AcceleratorController::RegisterAccelerators(
-    const AcceleratorData accelerators[],
-    size_t accelerators_length) {
-  for (size_t i = 0; i < accelerators_length; ++i) {
-    ui::Accelerator accelerator(accelerators[i].keycode,
-                                accelerators[i].modifiers);
-    accelerator.set_type(accelerators[i].trigger_on_press ?
-                         ui::ET_KEY_PRESSED : ui::ET_KEY_RELEASED);
-    Register(accelerator, this);
-    accelerators_.insert(
-        std::make_pair(accelerator, accelerators[i].action));
-  }
-}
-
 void AcceleratorController::SetKeyboardBrightnessControlDelegate(
     scoped_ptr<KeyboardBrightnessControlDelegate>
     keyboard_brightness_control_delegate) {
   keyboard_brightness_control_delegate_ =
       keyboard_brightness_control_delegate.Pass();
 }
 
-bool AcceleratorController::CanHandleAccelerators() const {
-  return true;
-}
-
 }  // namespace ash