Add ShellAcceleratorController that managers global keyboard accelerators.

ui/aura/desktop.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/desktop.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/string_number_conversions.h"
 #include "base/string_split.h"
 #include "ui/aura/aura_switches.h"
 #include "ui/aura/client/stacking_client.h"
 #include "ui/aura/desktop_host.h"
 #include "ui/aura/desktop_observer.h"
 #include "ui/aura/event.h"
 #include "ui/aura/event_filter.h"
 #include "ui/aura/focus_manager.h"
 #include "ui/aura/screen_aura.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/base/hit_test.h"
 #include "ui/gfx/compositor/compositor.h"
 #include "ui/gfx/compositor/layer.h"
-#include "ui/gfx/compositor/layer_animation_sequence.h"
 #include "ui/gfx/compositor/layer_animator.h"
-#include "ui/gfx/compositor/screen_rotation.h"
-#include "ui/gfx/interpolated_transform.h"
 
 using std::string;
 using std::vector;
 
 namespace aura {
 
 namespace {
 
 // Default bounds for the host window.
 static const int kDefaultHostWindowX = 200;
@@ skipping 45 matching lines @@
 
 void GetEventFiltersToNotify(Window* target, EventFilters* filters) {
   Window* window = target->parent();
   while (window) {
     if (window->event_filter())
       filters->push_back(window->event_filter());
     window = window->parent();
   }
 }
 
-#if !defined(NDEBUG)
-bool MaybeFullScreen(DesktopHost* host, KeyEvent* event) {
-  if (event->key_code() == ui::VKEY_F11) {
-    host->ToggleFullScreen();
-    return true;
-  }
-  return false;
-}
-
-bool MaybeRotate(Desktop* desktop, KeyEvent* event) {
-  if ((event->flags() & ui::EF_CONTROL_DOWN) &&
-      event->key_code() == ui::VKEY_HOME) {
-    static int i = 0;
-    int delta = 0;
-    switch (i) {
-      case 0: delta = 90; break;
-      case 1: delta = 90; break;
-      case 2: delta = 90; break;
-      case 3: delta = 90; break;
-      case 4: delta = -90; break;
-      case 5: delta = -90; break;
-      case 6: delta = -90; break;
-      case 7: delta = -90; break;
-      case 8: delta = -90; break;
-      case 9: delta = 180; break;
-      case 10: delta = 180; break;
-      case 11: delta = 90; break;
-      case 12: delta = 180; break;
-      case 13: delta = 180; break;
-    }
-    i = (i + 1) % 14;
-    desktop->layer()->GetAnimator()->set_preemption_strategy(
-        ui::LayerAnimator::REPLACE_QUEUED_ANIMATIONS);
-    scoped_ptr<ui::LayerAnimationSequence> screen_rotation(
-        new ui::LayerAnimationSequence(new ui::ScreenRotation(delta)));
-    screen_rotation->AddObserver(desktop);
-    desktop->layer()->GetAnimator()->ScheduleAnimation(
-        screen_rotation.release());
-    return true;
-  }
-  return false;
-}
-#endif
-
 }  // namespace
 
 Desktop* Desktop::instance_ = NULL;
 bool Desktop::use_fullscreen_host_window_ = false;
 
 Desktop::Desktop()
     : Window(NULL),
       host_(aura::DesktopHost::Create(GetInitialHostWindowBounds())),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           stacking_client_(new DefaultStackingClient(this))),
@@ skipping 115 matching lines @@
     Window::ConvertPointToWindow(this, target, &location_in_window);
     if (IsNonClientLocation(target, location_in_window))
       flags |= ui::EF_IS_NON_CLIENT;
     MouseEvent translated_event(*event, this, target, event->type(), flags);
     return ProcessMouseEvent(target, &translated_event);
   }
   return false;
 }
 
 bool Desktop::DispatchKeyEvent(KeyEvent* event) {
-#if !defined(NDEBUG)
-  // TODO(beng): replace this hack with global keyboard event handlers.
-  if (event->type() == ui::ET_KEY_PRESSED) {
-    if (MaybeFullScreen(host_.get(), event) || MaybeRotate(this, event))
-      return true;
-  }
-#endif
-
   if (focused_window_) {
     KeyEvent translated_event(*event);
     return ProcessKeyEvent(focused_window_, &translated_event);
   }
   return false;
 }
 
 bool Desktop::DispatchTouchEvent(TouchEvent* event) {
   event->UpdateForTransform(layer()->transform());
   bool handled = false;
@@ skipping 145 matching lines @@
 
 void Desktop::SetTransform(const ui::Transform& transform) {
   Window::SetTransform(transform);
 
   // If the layer is not animating, then we need to update the host size
   // immediately.
   if (!layer()->GetAnimator()->is_animating())
     OnHostResized(host_->GetSize());
 }
 
+#if !defined(NDEBUG)
+void Desktop::ToggleFullScreen() {
+  host_->ToggleFullScreen();
+}
+#endif
+
 void Desktop::HandleMouseMoved(const MouseEvent& event, Window* target) {
   if (target == mouse_moved_handler_)
     return;
 
   // Send an exited event.
   if (mouse_moved_handler_ && mouse_moved_handler_->delegate()) {
     MouseEvent translated_event(event, this, mouse_moved_handler_,
                                 ui::ET_MOUSE_EXITED, event.flags());
     ProcessMouseEvent(mouse_moved_handler_, &translated_event);
   }
@@ skipping 146 matching lines @@
       base::StringToInt(parts[1], &parsed_height) && parsed_height > 0) {
     bounds.set_size(gfx::Size(parsed_width, parsed_height));
   } else if (use_fullscreen_host_window_) {
     bounds = gfx::Rect(DesktopHost::GetNativeDisplaySize());
   }
 
   return bounds;
 }
 
 }  // namespace aura