Move even more from WmShell to Shell

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 <utility>
 
 #include "ash/common/accelerators/accelerator_commands.h"
 #include "ash/common/accelerators/accelerator_controller_delegate.h"
@@ skipping 202 matching lines @@
   base::RecordAction(UserMetricsAction("Accel_Launch_App"));
   WmShelf::LaunchShelfItem(n);
 }
 
 void HandleLaunchLastApp() {
   base::RecordAction(UserMetricsAction("Accel_Launch_Last_App"));
   WmShelf::LaunchShelfItem(-1);
 }
 
 void HandleMediaNextTrack() {
-  WmShell::Get()->media_controller()->HandleMediaNextTrack();
+  Shell::Get()->media_controller()->HandleMediaNextTrack();
 }
 
 void HandleMediaPlayPause() {
-  WmShell::Get()->media_controller()->HandleMediaPlayPause();
+  Shell::Get()->media_controller()->HandleMediaPlayPause();
 }
 
 void HandleMediaPrevTrack() {
-  WmShell::Get()->media_controller()->HandleMediaPrevTrack();
+  Shell::Get()->media_controller()->HandleMediaPrevTrack();
 }
 
 bool CanHandleNewIncognitoWindow() {
   return Shell::Get()->shell_delegate()->IsIncognitoAllowed();
 }
 
 void HandleNewIncognitoWindow() {
   base::RecordAction(UserMetricsAction("Accel_New_Incognito_Window"));
-  WmShell::Get()->new_window_controller()->NewWindow(true /* is_incognito */);
+  Shell::Get()->new_window_controller()->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_controller()->NewTab();
+  Shell::Get()->new_window_controller()->NewTab();
 }
 
 void HandleNewWindow() {
   base::RecordAction(UserMetricsAction("Accel_New_Window"));
-  WmShell::Get()->new_window_controller()->NewWindow(false /* is_incognito */);
+  Shell::Get()->new_window_controller()->NewWindow(false /* is_incognito */);
 }
 
 bool CanHandleNextIme(ImeControlDelegate* ime_control_delegate) {
   return ime_control_delegate && ime_control_delegate->CanCycleIme();
 }
 
 bool CanHandleCycleMru(const ui::Accelerator& accelerator) {
   // Don't do anything when Alt+Tab is hit while a virtual keyboard is showing.
   // Touchscreen users have better window switching options. It would be
   // preferable if we could tell whether this event actually came from a virtual
   // keyboard, but there's no easy way to do so, thus we block Alt+Tab when the
   // virtual keyboard is showing, even if it came from a real keyboard. See
   // http://crbug.com/638269
   keyboard::KeyboardController* keyboard_controller =
       keyboard::KeyboardController::GetInstance();
   return !(keyboard_controller && keyboard_controller->keyboard_visible());
 }
 
 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_controller()->OpenFeedbackPage();
+  Shell::Get()->new_window_controller()->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.key_state() == ui::Accelerator::KeyState::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_controller()->RestoreTab();
+  Shell::Get()->new_window_controller()->RestoreTab();
 }
 
 // Rotate the active window.
 void HandleRotateActiveWindow() {
   base::RecordAction(UserMetricsAction("Accel_Rotate_Active_Window"));
   aura::Window* active_window = wm::GetActiveWindow();
   if (!active_window)
     return;
   // The rotation animation bases its target transform on the current
   // rotation and position. Since there could be an animation in progress
   // right now, queue this animation so when it starts it picks up a neutral
   // rotation and position. Use replace so we only enqueue one at a time.
   active_window->layer()->GetAnimator()->set_preemption_strategy(
       ui::LayerAnimator::REPLACE_QUEUED_ANIMATIONS);
   active_window->layer()->GetAnimator()->StartAnimation(
       new ui::LayerAnimationSequence(
           base::MakeUnique<WindowRotation>(360, active_window->layer())));
 }
 
 void HandleShowKeyboardOverlay() {
   base::RecordAction(UserMetricsAction("Accel_Show_Keyboard_Overlay"));
-  WmShell::Get()->new_window_controller()->ShowKeyboardOverlay();
+  Shell::Get()->new_window_controller()->ShowKeyboardOverlay();
 }
 
 bool CanHandleShowMessageCenterBubble() {
   WmWindow* target_root = Shell::GetWmRootWindowForNewWindows();
   StatusAreaWidget* status_area_widget =
       WmShelf::ForWindow(target_root)->shelf_widget()->status_area_widget();
   return status_area_widget &&
          status_area_widget->web_notification_tray()->visible();
 }
 
@@ skipping 15 matching lines @@
   WmWindow* target_root = Shell::GetWmRootWindowForNewWindows();
   SystemTray* tray = target_root->GetRootWindowController()->GetSystemTray();
   if (!tray->HasSystemBubble()) {
     tray->ShowDefaultView(BUBBLE_CREATE_NEW);
     tray->ActivateBubble();
   }
 }
 
 void HandleShowTaskManager() {
   base::RecordAction(UserMetricsAction("Accel_Show_Task_Manager"));
-  WmShell::Get()->new_window_controller()->ShowTaskManager();
+  Shell::Get()->new_window_controller()->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) {
@@ skipping 93 matching lines @@
     if (ime_menu_tray && ime_menu_tray->visible() &&
         !ime_menu_tray->IsImeMenuBubbleShown()) {
       ime_menu_tray->ShowImeMenuBubble();
     }
   }
 }
 
 void HandleCrosh() {
   base::RecordAction(UserMetricsAction("Accel_Open_Crosh"));
 
-  WmShell::Get()->new_window_controller()->OpenCrosh();
+  Shell::Get()->new_window_controller()->OpenCrosh();
 }
 
 bool CanHandleDisableCapsLock(const ui::Accelerator& previous_accelerator) {
   ui::KeyboardCode previous_key_code = previous_accelerator.key_code();
   if (previous_accelerator.key_state() == ui::Accelerator::KeyState::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_controller()->OpenFileManager();
+  Shell::Get()->new_window_controller()->OpenFileManager();
 }
 
 void HandleGetHelp() {
-  WmShell::Get()->new_window_controller()->OpenGetHelp();
+  Shell::Get()->new_window_controller()->OpenGetHelp();
 }
 
 bool CanHandleLock() {
   return WmShell::Get()->session_controller()->CanLockScreen();
 }
 
 void HandleLock() {
   base::RecordAction(UserMetricsAction("Accel_LockScreen_L"));
   WmShell::Get()->session_controller()->LockScreen();
 }
@@ skipping 724 matching lines @@
   if (wm_shell->session_controller()->IsScreenLocked() &&
       actions_allowed_at_lock_screen_.find(action) ==
           actions_allowed_at_lock_screen_.end()) {
     return RESTRICTION_PREVENT_PROCESSING;
   }
   if (Shell::Get()->shell_delegate()->IsRunningInForcedAppMode() &&
       actions_allowed_in_app_mode_.find(action) ==
           actions_allowed_in_app_mode_.end()) {
     return RESTRICTION_PREVENT_PROCESSING;
   }
-  if (WmShell::Get()->IsSystemModalWindowOpen() &&
+  if (wm_shell->IsSystemModalWindowOpen() &&
       actions_allowed_at_modal_window_.find(action) ==
           actions_allowed_at_modal_window_.end()) {
     // Note we prevent the shortcut from propagating so it will not
     // be passed to the modal window. This is important for things like
     // Alt+Tab that would cause an undesired effect in the modal window by
     // cycling through its window elements.
     return RESTRICTION_PREVENT_PROCESSING_AND_PROPAGATION;
   }
-  if (wm_shell->mru_window_tracker()->BuildMruWindowList().empty() &&
+  if (Shell::Get()->mru_window_tracker()->BuildMruWindowList().empty() &&
       actions_needing_window_.find(action) != actions_needing_window_.end()) {
     Shell::GetInstance()->accessibility_delegate()->TriggerAccessibilityAlert(
         A11Y_ALERT_WINDOW_NEEDED);
     return RESTRICTION_PREVENT_PROCESSING_AND_PROPAGATION;
   }
   return RESTRICTION_NONE;
 }
 
 AcceleratorController::AcceleratorProcessingStatus
 AcceleratorController::MaybeDeprecatedAcceleratorPressed(
@@ skipping 27 matching lines @@
       data->uma_histogram_name, data->notification_message_id,
       data->old_shortcut_id, data->new_shortcut_id);
 
   if (!data->deprecated_enabled)
     return AcceleratorProcessingStatus::STOP;
 
   return AcceleratorProcessingStatus::PROCEED;
 }
 
 }  // namespace ash