Add ShellAcceleratorController that managers global keyboard accelerators.

ui/aura_shell/shell.cc

 // Copyright (c) 2011 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 "ui/aura_shell/shell.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "ui/aura/aura_switches.h"
 #include "ui/aura/desktop.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_types.h"
 #include "ui/aura_shell/default_container_event_filter.h"
 #include "ui/aura_shell/default_container_layout_manager.h"
 #include "ui/aura_shell/desktop_event_filter.h"
 #include "ui/aura_shell/desktop_layout_manager.h"
 #include "ui/aura_shell/launcher/launcher.h"
 #include "ui/aura_shell/shelf_layout_controller.h"
 #include "ui/aura_shell/shell_delegate.h"
 #include "ui/aura_shell/shell_factory.h"
 #include "ui/aura_shell/shell_window_ids.h"
 #include "ui/aura_shell/stacking_controller.h"
 #include "ui/aura_shell/toplevel_layout_manager.h"
 #include "ui/aura_shell/toplevel_window_event_filter.h"
 #include "ui/aura_shell/workspace_controller.h"
+#include "ui/base/accelerator_manager.h"
 #include "ui/gfx/compositor/layer.h"
 #include "ui/gfx/compositor/layer_animator.h"
 #include "views/widget/native_widget_aura.h"
 #include "views/widget/widget.h"
 
 namespace aura_shell {
 
 namespace {
 
 using views::Widget;
 
+// Acceleraters handled by Shell.
+struct AcceleratorData {
+  ui::KeyboardCode keycode;
+  bool shift;
+  bool ctrl;
+  bool alt;
+} kAcceleratorData[] = {
+  { ui::VKEY_F11, false, false, false },
+  { ui::VKEY_HOME, false, true, false },
+};
+
 // Creates each of the special window containers that holds windows of various
 // types in the shell UI. They are added to |containers| from back to front in
 // the z-index.
 void CreateSpecialContainers(aura::Window::Windows* containers) {
   aura::Window* background_container = new aura::Window(NULL);
   background_container->set_id(
       internal::kShellWindowId_DesktopBackgroundContainer);
   containers->push_back(background_container);
 
   aura::Window* default_container = new aura::Window(NULL);
@@ skipping 20 matching lines @@
 
   aura::Window* status_container = new aura::Window(NULL);
   status_container->set_id(internal::kShellWindowId_StatusContainer);
   containers->push_back(status_container);
 
   aura::Window* menu_container = new aura::Window(NULL);
   menu_container->set_id(internal::kShellWindowId_MenusAndTooltipsContainer);
   containers->push_back(menu_container);
 }
 
+void RegisterAccelerators(Shell* shell) {
+  ui::AcceleratorManager* accelerator_manager = shell->accelerator_manager();
+  for (size_t i = 0; i < arraysize(kAcceleratorData); ++i) {
+    accelerator_manager->Register(ui::Accelerator(kAcceleratorData[i].keycode,
+                                                  kAcceleratorData[i].shift,
+                                                  kAcceleratorData[i].ctrl,
+                                                  kAcceleratorData[i].alt),
+                                  shell);
+  }
+}
+
 }  // namespace
 
 // static
 Shell* Shell::instance_ = NULL;
 
 ////////////////////////////////////////////////////////////////////////////////
 // Shell, public:
 
 Shell::Shell(ShellDelegate* delegate)
     : ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)),
-      delegate_(delegate) {
+      delegate_(delegate),
+      accelerator_manager_(new ui::AcceleratorManager) {
   aura::Desktop::GetInstance()->SetEventFilter(
       new internal::DesktopEventFilter);
   aura::Desktop::GetInstance()->SetStackingClient(
       new internal::StackingController);
 }
 
 Shell::~Shell() {
   DCHECK(instance_ == this);
   instance_ = NULL;
 
@@ skipping 62 matching lines @@
 
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kAuraWindows)) {
     EnableWorkspaceManager();
   } else {
     internal::ToplevelLayoutManager* toplevel_layout_manager =
         new internal::ToplevelLayoutManager();
     default_container->SetLayoutManager(toplevel_layout_manager);
     toplevel_layout_manager->set_shelf(shelf_layout_controller_.get());
   }
 
+  RegisterAccelerators(this);
+
   // Force a layout.
   desktop_layout->OnWindowResized();
 }
 
 aura::Window* Shell::GetContainer(int container_id) {
   return const_cast<aura::Window*>(
       const_cast<const aura_shell::Shell*>(this)->GetContainer(container_id));
 }
 
 const aura::Window* Shell::GetContainer(int container_id) const {
   return aura::Desktop::GetInstance()->GetChildById(container_id);
 }
 
 void Shell::ToggleOverview() {
   if (workspace_controller_.get())
     workspace_controller_->ToggleOverview();
 }
 
+bool Shell::AcceleratorPressed(const ui::Accelerator& accelerator) {
+#if !defined(NDEBUG)
+  if (accelerator.key_code() == ui::VKEY_F11) {
+    aura::Desktop::GetInstance()->ToggleFullScreen();
+    return true;
+  } else if (accelerator.key_code() == ui::VKEY_HOME &&
+             accelerator.IsCtrlDown()) {
+    aura::Desktop::GetInstance()->Rotate();
+    return true;
+  }
+#endif
+  return false;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // Shell, private:
 
 void Shell::EnableWorkspaceManager() {
   aura::Window* default_container =
       GetContainer(internal::kShellWindowId_DefaultContainer);
 
   workspace_controller_.reset(
       new internal::WorkspaceController(default_container));
   workspace_controller_->SetLauncherModel(launcher_->model());
   default_container->SetEventFilter(
       new internal::DefaultContainerEventFilter(default_container));
   default_container->SetLayoutManager(
       new internal::DefaultContainerLayoutManager(
           workspace_controller_->workspace_manager()));
 }
 
 }  // namespace aura_shell