Moves NewWindowDelegate to ash/common

ash/common/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/common/accelerators/accelerator_controller.h"
 
 #include "ash/common/accelerators/accelerator_commands.h"
 #include "ash/common/accelerators/accelerator_controller_delegate.h"
 #include "ash/common/accelerators/debug_commands.h"
 #include "ash/common/accessibility_delegate.h"
 #include "ash/common/accessibility_types.h"
 #include "ash/common/focus_cycler.h"
 #include "ash/common/ime_control_delegate.h"
 #include "ash/common/media_delegate.h"
 #include "ash/common/multi_profile_uma.h"
+#include "ash/common/new_window_delegate.h"
 #include "ash/common/session/session_state_delegate.h"
 #include "ash/common/shell_delegate.h"
 #include "ash/common/system/brightness_control_delegate.h"
 #include "ash/common/system/keyboard_brightness_control_delegate.h"
 #include "ash/common/system/tray/system_tray_delegate.h"
 #include "ash/common/system/tray/system_tray_notifier.h"
 #include "ash/common/system/volume_control_delegate.h"
 #include "ash/common/wm/mru_window_tracker.h"
 #include "ash/common/wm/overview/window_selector_controller.h"
 #include "ash/common/wm/window_cycle_controller.h"
@@ skipping 72 matching lines @@
 }
 
 void HandleMediaPlayPause() {
   WmShell::Get()->media_delegate()->HandleMediaPlayPause();
 }
 
 void HandleMediaPrevTrack() {
   WmShell::Get()->media_delegate()->HandleMediaPrevTrack();
 }
 
+bool CanHandleNewIncognitoWindow() {
+  return WmShell::Get()->delegate()->IsIncognitoAllowed();
+}
+
+void HandleNewIncognitoWindow() {
+  base::RecordAction(UserMetricsAction("Accel_New_Incognito_Window"));
+  WmShell::Get()->new_window_delegate()->NewWindow(true /* is_incognito */);
+}
+
+void HandleNewTab(const ui::Accelerator& accelerator) {
+  if (accelerator.key_code() == ui::VKEY_T)
+    base::RecordAction(UserMetricsAction("Accel_NewTab_T"));
+  WmShell::Get()->new_window_delegate()->NewTab();
+}
+
+void HandleNewWindow() {
+  base::RecordAction(UserMetricsAction("Accel_New_Window"));
+  WmShell::Get()->new_window_delegate()->NewWindow(false /* is_incognito */);
+}
+
 bool CanHandleNextIme(ImeControlDelegate* ime_control_delegate) {
   return ime_control_delegate && ime_control_delegate->CanCycleIme();
 }
 
 // We must avoid showing the Deprecated NEXT_IME notification erronously.
 bool ShouldShowDeprecatedNextImeNotification(
     const ui::Accelerator& previous_accelerator) {
   // We only show the deprecation notification if the previous accelerator key
   // is ONLY either Shift, or Alt.
   const ui::KeyboardCode previous_key_code = previous_accelerator.key_code();
   switch (previous_key_code) {
     case ui::VKEY_SHIFT:
     case ui::VKEY_LSHIFT:
     case ui::VKEY_RSHIFT:
     case ui::VKEY_MENU:
     case ui::VKEY_LMENU:
     case ui::VKEY_RMENU:
       return true;
 
     default:
       return false;
   }
 }
 
 void HandleNextIme(ImeControlDelegate* ime_control_delegate) {
   base::RecordAction(UserMetricsAction("Accel_Next_Ime"));
   ime_control_delegate->HandleNextIme();
 }
 
+void HandleOpenFeedbackPage() {
+  base::RecordAction(UserMetricsAction("Accel_Open_Feedback_Page"));
+  WmShell::Get()->new_window_delegate()->OpenFeedbackPage();
+}
+
 bool CanHandlePreviousIme(ImeControlDelegate* ime_control_delegate) {
   return ime_control_delegate && ime_control_delegate->CanCycleIme();
 }
 
 void HandlePreviousIme(ImeControlDelegate* ime_control_delegate,
                        const ui::Accelerator& accelerator) {
   base::RecordAction(UserMetricsAction("Accel_Previous_Ime"));
   if (accelerator.type() == ui::ET_KEY_PRESSED)
     ime_control_delegate->HandlePreviousIme();
   // Else: consume the Ctrl+Space ET_KEY_RELEASED event but do not do anything.
 }
 
+void HandleRestoreTab() {
+  base::RecordAction(UserMetricsAction("Accel_Restore_Tab"));
+  WmShell::Get()->new_window_delegate()->RestoreTab();
+}
+
+void HandleShowKeyboardOverlay() {
+  base::RecordAction(UserMetricsAction("Accel_Show_Keyboard_Overlay"));
+  WmShell::Get()->new_window_delegate()->ShowKeyboardOverlay();
+}
+
+void HandleShowTaskManager() {
+  base::RecordAction(UserMetricsAction("Accel_Show_Task_Manager"));
+  WmShell::Get()->new_window_delegate()->ShowTaskManager();
+}
+
 bool CanHandleSwitchIme(ImeControlDelegate* ime_control_delegate,
                         const ui::Accelerator& accelerator) {
   return ime_control_delegate &&
          ime_control_delegate->CanSwitchIme(accelerator);
 }
 
 void HandleSwitchIme(ImeControlDelegate* ime_control_delegate,
                      const ui::Accelerator& accelerator) {
   base::RecordAction(UserMetricsAction("Accel_Switch_Ime"));
   ime_control_delegate->HandleSwitchIme(accelerator);
@@ skipping 45 matching lines @@
   WmWindow* active_window = WmShell::Get()->GetActiveWindow();
   return (active_window && !active_window->GetWindowState()->IsDocked());
 }
 
 void HandlePositionCenter() {
   base::RecordAction(UserMetricsAction("Accel_Window_Position_Center"));
   wm::CenterWindow(WmShell::Get()->GetActiveWindow());
 }
 
 #if defined(OS_CHROMEOS)
+void HandleCrosh() {
+  base::RecordAction(UserMetricsAction("Accel_Open_Crosh"));
+
+  WmShell::Get()->new_window_delegate()->OpenCrosh();
+}
+
 bool CanHandleDisableCapsLock(const ui::Accelerator& previous_accelerator) {
   ui::KeyboardCode previous_key_code = previous_accelerator.key_code();
   if (previous_accelerator.type() == ui::ET_KEY_RELEASED ||
       (previous_key_code != ui::VKEY_LSHIFT &&
        previous_key_code != ui::VKEY_SHIFT &&
        previous_key_code != ui::VKEY_RSHIFT)) {
     // If something else was pressed between the Shift key being pressed
     // and released, then ignore the release of the Shift key.
     return false;
   }
   chromeos::input_method::InputMethodManager* ime =
       chromeos::input_method::InputMethodManager::Get();
   chromeos::input_method::ImeKeyboard* keyboard =
       ime ? ime->GetImeKeyboard() : NULL;
   return (keyboard && keyboard->CapsLockIsEnabled());
 }
 
 void HandleDisableCapsLock() {
   base::RecordAction(UserMetricsAction("Accel_Disable_Caps_Lock"));
   chromeos::input_method::InputMethodManager* ime =
       chromeos::input_method::InputMethodManager::Get();
   ime->GetImeKeyboard()->SetCapsLockEnabled(false);
 }
 
+void HandleFileManager() {
+  base::RecordAction(UserMetricsAction("Accel_Open_File_Manager"));
+
+  WmShell::Get()->new_window_delegate()->OpenFileManager();
+}
+
+void HandleGetHelp() {
+  WmShell::Get()->new_window_delegate()->OpenGetHelp();
+}
+
 bool CanHandleLock() {
   return WmShell::Get()->GetSessionStateDelegate()->CanLockScreen();
 }
 
 void HandleLock() {
   base::RecordAction(UserMetricsAction("Accel_LockScreen_L"));
   WmShell::Get()->GetSessionStateDelegate()->LockScreen();
 }
 
 void HandleSuspend() {
@@ skipping 313 matching lines @@
       accelerator_history_->previous_accelerator();
 
   // True should be returned if running |action| does something. Otherwise,
   // false should be returned to give the web contents a chance at handling the
   // accelerator.
   switch (action) {
     case DEBUG_PRINT_LAYER_HIERARCHY:
     case DEBUG_PRINT_VIEW_HIERARCHY:
     case DEBUG_PRINT_WINDOW_HIERARCHY:
       return debug::DebugAcceleratorsEnabled();
+    case NEW_INCOGNITO_WINDOW:
+      return CanHandleNewIncognitoWindow();
     case NEXT_IME:
       return CanHandleNextIme(ime_control_delegate_.get());
     case PREVIOUS_IME:
       return CanHandlePreviousIme(ime_control_delegate_.get());
     case SWITCH_IME:
       return CanHandleSwitchIme(ime_control_delegate_.get(), accelerator);
     case WINDOW_CYCLE_SNAP_DOCK_LEFT:
     case WINDOW_CYCLE_SNAP_DOCK_RIGHT:
       return CanHandleWindowSnapOrDock();
     case WINDOW_POSITION_CENTER:
@@ skipping 15 matching lines @@
       return CanHandleToggleCapsLock(accelerator, previous_accelerator);
 #endif
     case CYCLE_BACKWARD_MRU:
     case CYCLE_FORWARD_MRU:
     case EXIT:
     case FOCUS_NEXT_PANE:
     case FOCUS_PREVIOUS_PANE:
     case MEDIA_NEXT_TRACK:
     case MEDIA_PLAY_PAUSE:
     case MEDIA_PREV_TRACK:
+    case NEW_TAB:
+    case NEW_WINDOW:
+    case OPEN_FEEDBACK_PAGE:
     case PRINT_UI_HIERARCHIES:
+    case RESTORE_TAB:
+    case SHOW_KEYBOARD_OVERLAY:
+    case SHOW_TASK_MANAGER:
     case TOGGLE_FULLSCREEN:
     case TOGGLE_MAXIMIZED:
     case TOGGLE_OVERVIEW:
     case WINDOW_MINIMIZE:
 #if defined(OS_CHROMEOS)
     case BRIGHTNESS_DOWN:
     case BRIGHTNESS_UP:
     case KEYBOARD_BRIGHTNESS_DOWN:
     case KEYBOARD_BRIGHTNESS_UP:
+    case OPEN_CROSH:
+    case OPEN_FILE_MANAGER:
+    case OPEN_GET_HELP:
     case SUSPEND:
     case TOGGLE_SPOKEN_FEEDBACK:
     case TOGGLE_WIFI:
     case VOLUME_DOWN:
     case VOLUME_MUTE:
     case VOLUME_UP:
 #else
     case DUMMY_FOR_RESERVED:
 #endif
       return true;
@@ skipping 41 matching lines @@
       break;
     case MEDIA_NEXT_TRACK:
       HandleMediaNextTrack();
       break;
     case MEDIA_PLAY_PAUSE:
       HandleMediaPlayPause();
       break;
     case MEDIA_PREV_TRACK:
       HandleMediaPrevTrack();
       break;
+    case NEW_INCOGNITO_WINDOW:
+      HandleNewIncognitoWindow();
+      break;
+    case NEW_TAB:
+      HandleNewTab(accelerator);
+      break;
+    case NEW_WINDOW:
+      HandleNewWindow();
+      break;
     case NEXT_IME:
       HandleNextIme(ime_control_delegate_.get());
       break;
+    case OPEN_FEEDBACK_PAGE:
+      HandleOpenFeedbackPage();
+      break;
     case PREVIOUS_IME:
       HandlePreviousIme(ime_control_delegate_.get(), accelerator);
       break;
     case PRINT_UI_HIERARCHIES:
       debug::PrintUIHierarchies();
       break;
+    case RESTORE_TAB:
+      HandleRestoreTab();
+      break;
+    case SHOW_KEYBOARD_OVERLAY:
+      HandleShowKeyboardOverlay();
+      break;
+    case SHOW_TASK_MANAGER:
+      HandleShowTaskManager();
+      break;
     case SWITCH_IME:
       HandleSwitchIme(ime_control_delegate_.get(), accelerator);
       break;
     case TOGGLE_FULLSCREEN:
       HandleToggleFullscreen(accelerator);
       break;
     case TOGGLE_MAXIMIZED:
       accelerators::ToggleMaximized();
       break;
     case TOGGLE_OVERVIEW:
@@ skipping 43 matching lines @@
     case KEYBOARD_BRIGHTNESS_UP: {
       KeyboardBrightnessControlDelegate* delegate =
           WmShell::Get()->keyboard_brightness_control_delegate();
       if (delegate)
         delegate->HandleKeyboardBrightnessUp(accelerator);
       break;
     }
     case LOCK_SCREEN:
       HandleLock();
       break;
+    case OPEN_CROSH:
+      HandleCrosh();
+      break;
+    case OPEN_FILE_MANAGER:
+      HandleFileManager();
+      break;
+    case OPEN_GET_HELP:
+      HandleGetHelp();
+      break;
     case SUSPEND:
       HandleSuspend();
       break;
     case SWITCH_TO_NEXT_USER:
       HandleCycleUser(SessionStateDelegate::CYCLE_TO_NEXT_USER);
       break;
     case SWITCH_TO_PREVIOUS_USER:
       HandleCycleUser(SessionStateDelegate::CYCLE_TO_PREVIOUS_USER);
       break;
     case TOGGLE_CAPS_LOCK:
@@ skipping 69 matching lines @@
   if (wm_shell->mru_window_tracker()->BuildMruWindowList().empty() &&
       actions_needing_window_.find(action) != actions_needing_window_.end()) {
     wm_shell->accessibility_delegate()->TriggerAccessibilityAlert(
         A11Y_ALERT_WINDOW_NEEDED);
     return RESTRICTION_PREVENT_PROCESSING_AND_PROPAGATION;
   }
   return RESTRICTION_NONE;
 }
 
 }  // namespace ash