Makes Ctrl-Shift-L work in AppList

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_delegate.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,
+#if defined(OS_CHROMEOS)
+  LOCK_SCREEN,
+#endif
   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 },
+#if defined(OS_CHROMEOS)
+  { ui::VKEY_L, true, true, false, LOCK_SCREEN },
+#endif
   { 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
 };
 
 bool HandleCycleWindow(ash::WindowCycleController::Direction direction,
                        bool is_alt_down) {
   ash::Shell::GetInstance()->
       window_cycle_controller()->HandleCycleWindow(direction, is_alt_down);
   // Always report we handled the key, even if the window didn't change.
   return true;
 }
 
+#if defined(OS_CHROMEOS)
+bool HandleLock() {
+  ash::ShellDelegate* delegate = ash::Shell::GetInstance()->delegate();
+  if (!delegate)
+    return false;
+  delegate->LockScreen();
+  return true;
+}
+#endif
+
 #if !defined(NDEBUG)
 // Rotates the screen.
 bool HandleRotateScreen() {
   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;
@@ skipping 107 matching lines @@
                                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(OS_CHROMEOS)
+    case LOCK_SCREEN:
+      return HandleLock();
+#endif
 #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