Changing the ominbar text colors according to spec. This change was marked as 'optional' and

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 "ash/caps_lock_delegate.h"
 #include "ash/ime_control_delegate.h"
 #include "ash/launcher/launcher.h"
 #include "ash/launcher/launcher_model.h"
 #include "ash/screenshot_delegate.h"
 #include "ash/shell.h"
 #include "ash/shell_delegate.h"
 #include "ash/shell_window_ids.h"
 #include "ash/system/brightness/brightness_control_delegate.h"
 #include "ash/volume_control_delegate.h"
 #include "ash/wm/window_cycle_controller.h"
 #include "ash/wm/window_util.h"
+#include "ui/aura/client/activation_client.h"
 #include "ui/aura/event.h"
 #include "ui/aura/root_window.h"
 #include "ui/base/accelerators/accelerator.h"
 #include "ui/base/accelerators/accelerator_manager.h"
 #include "ui/gfx/compositor/debug_utils.h"
 #include "ui/gfx/compositor/layer_animation_sequence.h"
 #include "ui/gfx/compositor/layer_animator.h"
 #include "ui/gfx/compositor/screen_rotation.h"
 
 namespace {
@@ skipping 16 matching lines @@
 #if defined(OS_CHROMEOS)
   LOCK_SCREEN,
 #endif
 #if !defined(NDEBUG)
   PRINT_LAYER_HIERARCHY,
   PRINT_WINDOW_HIERARCHY,
   ROTATE_SCREEN,
   TOGGLE_DESKTOP_BACKGROUND_MODE,
   TOGGLE_ROOT_WINDOW_FULL_SCREEN,
 #endif
+  SELECT_WIN_0,
+  SELECT_WIN_1,
+  SELECT_WIN_2,
+  SELECT_WIN_3,
+  SELECT_WIN_4,
+  SELECT_WIN_5,
+  SELECT_WIN_6,
+  SELECT_WIN_7,
+  SELECT_WIN_8,
 };
 
 // Accelerators handled by AcceleratorController.
 const struct AcceleratorData {
   ui::EventType type;
   ui::KeyboardCode keycode;
   bool shift;
   bool ctrl;
   bool alt;
   AcceleratorAction action;
@@ skipping 47 matching lines @@
     VOLUME_MUTE },
   { ui::ET_TRANSLATED_KEY_PRESS, ui::VKEY_VOLUME_MUTE, false, false, false,
     VOLUME_MUTE },
   { ui::ET_TRANSLATED_KEY_PRESS, ui::VKEY_F9, false, false, false,
     VOLUME_DOWN },
   { ui::ET_TRANSLATED_KEY_PRESS, ui::VKEY_VOLUME_DOWN, false, false, false,
     VOLUME_DOWN },
   { ui::ET_TRANSLATED_KEY_PRESS, ui::VKEY_F10, false, false, false, VOLUME_UP },
   { ui::ET_TRANSLATED_KEY_PRESS, ui::VKEY_VOLUME_UP, false, false, false,
     VOLUME_UP },
+  { ui::ET_TRANSLATED_KEY_PRESS, ui::VKEY_1, false, false, true,
+    SELECT_WIN_0 },
+  { ui::ET_TRANSLATED_KEY_PRESS, ui::VKEY_2, false, false, true,
+    SELECT_WIN_1 },
+  { ui::ET_TRANSLATED_KEY_PRESS, ui::VKEY_3, false, false, true,
+    SELECT_WIN_2 },
+  { ui::ET_TRANSLATED_KEY_PRESS, ui::VKEY_4, false, false, true,
+    SELECT_WIN_3 },
+  { ui::ET_TRANSLATED_KEY_PRESS, ui::VKEY_5, false, false, true,
+    SELECT_WIN_4 },
+  { ui::ET_TRANSLATED_KEY_PRESS, ui::VKEY_6, false, false, true,
+    SELECT_WIN_5 },
+  { ui::ET_TRANSLATED_KEY_PRESS, ui::VKEY_7, false, false, true,
+    SELECT_WIN_6 },
+  { ui::ET_TRANSLATED_KEY_PRESS, ui::VKEY_8, false, false, true,
+    SELECT_WIN_7 },
+  { ui::ET_TRANSLATED_KEY_PRESS, ui::VKEY_9, false, false, true,
+    SELECT_WIN_8 },
+
 #if !defined(NDEBUG)
   { ui::ET_TRANSLATED_KEY_PRESS, ui::VKEY_HOME, false, true, false,
     ROTATE_SCREEN },
   { ui::ET_TRANSLATED_KEY_PRESS, ui::VKEY_B, false, true, true,
     TOGGLE_DESKTOP_BACKGROUND_MODE },
   { ui::ET_TRANSLATED_KEY_PRESS, ui::VKEY_F11, false, true, false,
     TOGGLE_ROOT_WINDOW_FULL_SCREEN },
   { ui::ET_TRANSLATED_KEY_PRESS, ui::VKEY_L, false, false, true,
     PRINT_LAYER_HIERARCHY },
   { ui::ET_TRANSLATED_KEY_PRESS, ui::VKEY_L, true, false, true,
@@ skipping 177 matching lines @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // 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());
+  unsigned int window = 0;
   switch (static_cast<AcceleratorAction>(it->second)) {
     case CYCLE_BACKWARD:
       return HandleCycleWindow(WindowCycleController::BACKWARD,
                                accelerator.IsAltDown());
     case CYCLE_FORWARD:
       return HandleCycleWindow(WindowCycleController::FORWARD,
                                accelerator.IsAltDown());
 #if defined(OS_CHROMEOS)
     case LOCK_SCREEN:
       return HandleLock();
@@ skipping 43 matching lines @@
         return ime_control_delegate_->HandleNextIme();
       break;
     case PREVIOUS_IME:
       if (ime_control_delegate_.get())
         return ime_control_delegate_->HandlePreviousIme();
       break;
     case SWITCH_IME:
       if (ime_control_delegate_.get())
         return ime_control_delegate_->HandleSwitchIme(accelerator);
       break;
+    case SELECT_WIN_8:
+      window++;
+      // Fallthrough.
+    case SELECT_WIN_7:
+      window++;
+      // Fallthrough.
+    case SELECT_WIN_6:
+      window++;
+      // Fallthrough.
+    case SELECT_WIN_5:
+      window++;
+      // Fallthrough.
+    case SELECT_WIN_4:
+      window++;
+      // Fallthrough.
+    case SELECT_WIN_3:
+      window++;
+      // Fallthrough.
+    case SELECT_WIN_2:
+      window++;
+      // Fallthrough.
+    case SELECT_WIN_1:
+      window++;
+      // Fallthrough.
+    case SELECT_WIN_0:
+      SwitchToWindow(window);
+      break;
 #if !defined(NDEBUG)
     case ROTATE_SCREEN:
       return HandleRotateScreen();
     case TOGGLE_DESKTOP_BACKGROUND_MODE:
       return HandleToggleDesktopBackgroundMode();
     case TOGGLE_ROOT_WINDOW_FULL_SCREEN:
       return HandleToggleRootWindowFullScreen();
     case PRINT_LAYER_HIERARCHY:
       return HandlePrintLayerHierarchy();
     case PRINT_WINDOW_HIERARCHY:
       return HandlePrintWindowHierarchy();
 #endif
     default:
       NOTREACHED() << "Unhandled action " << it->second;
   }
   return false;
 }
 
+void AcceleratorController::SwitchToWindow(const unsigned int window) {
+  const std::vector<aura::Window*>& windows =
+      Shell::GetInstance()->delegate()->GetCycleWindowList(
+        ShellDelegate::SOURCE_LAUNCHER,
+        ShellDelegate::ORDER_LINEAR);
+  if (window < windows.size()) {
+    aura::client::ActivationClient* activation_client =
+        aura::client::GetActivationClient(Shell::GetRootWindow());
+    aura::Window* window_to_activate = windows[window];
+    aura::Window* current_window = wm::GetActiveWindow();
+    if (window_to_activate != current_window) {
+      bool maximized = wm::IsWindowMaximized(current_window);
+      if (maximized) {
+        wm::RestoreWindow(current_window);
+      }
+      activation_client->ActivateWindow(window_to_activate);
+      if (maximized) {
+        wm::MaximizeWindow(window_to_activate);
+      }
+    }
+  }
+}
+
 bool AcceleratorController::CanHandleAccelerators() const {
   return true;
 }
 
 }  // namespace ash