Handle Caps Lock short cut (Shift+Search) in ash [part 1 of 2].

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/launcher/launcher.h"
 #include "ash/launcher/launcher_model.h"
 #include "ash/screenshot_delegate.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/window_cycle_controller.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 {
 
 enum AcceleratorAction {
   CYCLE_BACKWARD,
   CYCLE_FORWARD,
   TAKE_SCREENSHOT,
+  TOGGLE_CAPS_LOCK,
 #if !defined(NDEBUG)
   ROTATE_SCREEN,
   PRINT_LAYER_HIERARCHY,
   TOGGLE_ROOT_WINDOW_FULL_SCREEN,
 #endif
 };
 
 // Accelerators handled by AcceleratorController.
 struct AcceleratorData {
   ui::KeyboardCode keycode;
   bool shift;
   bool ctrl;
   bool alt;
   AcceleratorAction action;
 } kAcceleratorData[] = {
   { ui::VKEY_TAB, false, false, true, CYCLE_FORWARD },
   { ui::VKEY_TAB, true, false, true, CYCLE_BACKWARD },
   { ui::VKEY_F5, false, false, false, CYCLE_FORWARD },
   { ui::VKEY_F5, true, false, false, CYCLE_BACKWARD },
   { ui::VKEY_F5, false, true, false, TAKE_SCREENSHOT },
   { ui::VKEY_PRINT, false, false, false, TAKE_SCREENSHOT },
+  // On Chrome OS, Search key is mapped to LWIN.
+  { ui::VKEY_LWIN, true, false, false, TOGGLE_CAPS_LOCK },
 #if !defined(NDEBUG)
   { ui::VKEY_HOME, false, true, false, ROTATE_SCREEN },
   { ui::VKEY_F11, false, true, false, TOGGLE_ROOT_WINDOW_FULL_SCREEN },
   { ui::VKEY_L, false, false, true, PRINT_LAYER_HIERARCHY },
   // For testing on systems where Alt-Tab is already mapped.
   { ui::VKEY_W, false, false, true, CYCLE_FORWARD },
   { ui::VKEY_W, true, false, true, CYCLE_BACKWARD },
 #endif
 };
 
@@ skipping 96 matching lines @@
 
 bool AcceleratorController::Process(const ui::Accelerator& accelerator) {
   return accelerator_manager_->Process(accelerator);
 }
 
 void AcceleratorController::SetScreenshotDelegate(
     ScreenshotDelegate* screenshot_delegate) {
   screenshot_delegate_.reset(screenshot_delegate);
 }
 
+void AcceleratorController::SetCapsLockDelegate(
+    scoped_ptr<CapsLockDelegate> caps_lock_delegate) {
+  caps_lock_delegate_.swap(caps_lock_delegate);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // 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());
   switch (static_cast<AcceleratorAction>(it->second)) {
     case CYCLE_BACKWARD:
       return HandleCycleWindow(WindowCycleController::BACKWARD,
                                accelerator.IsAltDown());
     case CYCLE_FORWARD:
       return HandleCycleWindow(WindowCycleController::FORWARD,
                                accelerator.IsAltDown());
     case TAKE_SCREENSHOT:
       if (screenshot_delegate_.get())
         screenshot_delegate_->HandleTakeScreenshot();
       // Return true to prevent propagation of the key event.
       return true;
+    case TOGGLE_CAPS_LOCK:
+      if (caps_lock_delegate_.get())
+        return caps_lock_delegate_->HandleToggleCapsLock();
+      break;
 #if !defined(NDEBUG)
     case ROTATE_SCREEN:
       return HandleRotateScreen();
     case TOGGLE_ROOT_WINDOW_FULL_SCREEN:
       return HandleToggleRootWindowFullScreen();
     case PRINT_LAYER_HIERARCHY:
       return HandlePrintLayerHierarchy();
 #endif
     default:
       NOTREACHED() << "Unhandled action " << it->second;;
   }
   return false;
 }
 
 bool AcceleratorController::CanHandleAccelerators() const {
   return true;
 }
 
 }  // namespace ash