mash: Migrate AccessibilityDelegate access to WmShell.

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 <algorithm>
 #include <cmath>
 #include <string>
 #include <utility>
@@ skipping 87 matching lines @@
 // help page when the notification is clicked.
 class DeprecatedAcceleratorNotificationDelegate
     : public message_center::NotificationDelegate {
  public:
   DeprecatedAcceleratorNotificationDelegate() {}
 
   // message_center::NotificationDelegate:
   bool HasClickedListener() override { return true; }
 
   void Click() override {
-    if (!Shell::GetInstance()->session_state_delegate()->IsUserSessionBlocked())
+    if (!WmShell::Get()->GetSessionStateDelegate()->IsUserSessionBlocked())
       Shell::GetInstance()->delegate()->OpenKeyboardShortcutHelpPage();
   }
 
  private:
   // Private destructor since NotificationDelegate is ref-counted.
   ~DeprecatedAcceleratorNotificationDelegate() override {}
 
   DISALLOW_COPY_AND_ASSIGN(DeprecatedAcceleratorNotificationDelegate);
 };
 
@@ skipping 119 matching lines @@
 }
 
 bool CanHandleMagnifyScreen() {
   Shell* shell = Shell::GetInstance();
   return shell->magnification_controller()->IsEnabled() ||
          shell->partial_magnification_controller()->is_enabled();
 }
 
 // Magnify the screen
 void HandleMagnifyScreen(int delta_index) {
-  if (ash::Shell::GetInstance()->magnification_controller()->IsEnabled()) {
+  if (Shell::GetInstance()->magnification_controller()->IsEnabled()) {
     // TODO(yoshiki): Move the following logic to MagnificationController.
-    float scale =
-        ash::Shell::GetInstance()->magnification_controller()->GetScale();
+    float scale = Shell::GetInstance()->magnification_controller()->GetScale();
     // Calculate rounded logarithm (base kMagnificationScaleFactor) of scale.
     int scale_index =
         std::floor(std::log(scale) / std::log(kMagnificationScaleFactor) + 0.5);
 
     int new_scale_index = std::max(0, std::min(8, scale_index + delta_index));
 
-    ash::Shell::GetInstance()->magnification_controller()->SetScale(
+    Shell::GetInstance()->magnification_controller()->SetScale(
         std::pow(kMagnificationScaleFactor, new_scale_index), true);
-  } else if (ash::Shell::GetInstance()
+  } else if (Shell::GetInstance()
                  ->partial_magnification_controller()
                  ->is_enabled()) {
     float scale = delta_index > 0 ? kDefaultPartialMagnifiedScale : 1;
-    ash::Shell::GetInstance()->partial_magnification_controller()->SetScale(
-        scale);
+    Shell::GetInstance()->partial_magnification_controller()->SetScale(scale);
   }
 }
 
 void HandleMediaNextTrack() {
   Shell::GetInstance()->media_delegate()->HandleMediaNextTrack();
 }
 
 void HandleMediaPlayPause() {
   Shell::GetInstance()->media_delegate()->HandleMediaPlayPause();
 }
@@ skipping 48 matching lines @@
   }
 }
 
 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"));
-  ash::Shell::GetInstance()->new_window_delegate()->OpenFeedbackPage();
+  Shell::GetInstance()->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)
@@ skipping 25 matching lines @@
 void HandleRotateScreen() {
   if (Shell::GetInstance()->display_manager()->IsInUnifiedMode())
     return;
 
   base::RecordAction(UserMetricsAction("Accel_Rotate_Window"));
   gfx::Point point = display::Screen::GetScreen()->GetCursorScreenPoint();
   display::Display display =
       display::Screen::GetScreen()->GetDisplayNearestPoint(point);
   const DisplayInfo& display_info =
       Shell::GetInstance()->display_manager()->GetDisplayInfo(display.id());
-  ash::ScreenRotationAnimator(display.id())
+  ScreenRotationAnimator(display.id())
       .Rotate(GetNextRotation(display_info.GetActiveRotation()),
               display::Display::ROTATION_SOURCE_USER);
 }
 
 // Rotate the active window.
 void HandleRotateActiveWindow() {
   base::RecordAction(UserMetricsAction("Accel_Rotate_Window"));
   aura::Window* active_window = wm::GetActiveWindow();
   if (active_window) {
     // 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(
-            new ash::WindowRotation(360, active_window->layer())));
+            new WindowRotation(360, active_window->layer())));
   }
 }
 
 void HandleShowKeyboardOverlay() {
   base::RecordAction(UserMetricsAction("Accel_Show_Keyboard_Overlay"));
-  ash::Shell::GetInstance()->new_window_delegate()->ShowKeyboardOverlay();
+  Shell::GetInstance()->new_window_delegate()->ShowKeyboardOverlay();
 }
 
 bool CanHandleShowMessageCenterBubble() {
   RootWindowController* controller =
       RootWindowController::ForTargetRootWindow();
   StatusAreaWidget* status_area_widget =
       controller->shelf_widget()->status_area_widget();
   return status_area_widget &&
          status_area_widget->web_notification_tray()->visible();
 }
@@ skipping 65 matching lines @@
     // being pressed and released, then ignore the release of the
     // Search key.
     if (previous_accelerator.type() != ui::ET_KEY_PRESSED ||
         previous_accelerator.key_code() != ui::VKEY_LWIN) {
       return false;
     }
 
     // When spoken feedback is enabled, we should neither toggle the list nor
     // consume the key since Search+Shift is one of the shortcuts the a11y
     // feature uses. crbug.com/132296
-    if (Shell::GetInstance()
-            ->accessibility_delegate()
-            ->IsSpokenFeedbackEnabled()) {
+    if (WmShell::Get()->GetAccessibilityDelegate()->IsSpokenFeedbackEnabled())
       return false;
-    }
   }
   return true;
 }
 
 void HandleToggleAppList(const ui::Accelerator& accelerator) {
   if (accelerator.key_code() == ui::VKEY_LWIN)
     base::RecordAction(base::UserMetricsAction("Accel_Search_LWin"));
-  ash::Shell::GetInstance()->ToggleAppList(NULL);
+  Shell::GetInstance()->ToggleAppList(NULL);
 }
 
 void HandleToggleFullscreen(const ui::Accelerator& accelerator) {
   if (accelerator.key_code() == ui::VKEY_MEDIA_LAUNCH_APP2)
     base::RecordAction(UserMetricsAction("Accel_Fullscreen_F4"));
   accelerators::ToggleFullscreen();
 }
 
 void HandleToggleOverview() {
   base::RecordAction(base::UserMetricsAction("Accel_Overview_F5"));
@@ skipping 88 matching lines @@
     delegate->HandleKeyboardBrightnessDown(accelerator);
 }
 
 void HandleKeyboardBrightnessUp(KeyboardBrightnessControlDelegate* delegate,
                                 const ui::Accelerator& accelerator) {
   if (delegate)
     delegate->HandleKeyboardBrightnessUp(accelerator);
 }
 
 bool CanHandleLock() {
-  return Shell::GetInstance()->session_state_delegate()->CanLockScreen();
+  return WmShell::Get()->GetSessionStateDelegate()->CanLockScreen();
 }
 
 void HandleLock() {
   base::RecordAction(UserMetricsAction("Accel_LockScreen_L"));
-  Shell::GetInstance()->session_state_delegate()->LockScreen();
+  WmShell::Get()->GetSessionStateDelegate()->LockScreen();
 }
 
 void HandleSuspend() {
   base::RecordAction(UserMetricsAction("Accel_Suspend"));
   chromeos::DBusThreadManager::Get()->GetPowerManagerClient()->RequestSuspend();
 }
 
 void HandleCrosh() {
   base::RecordAction(UserMetricsAction("Accel_Open_Crosh"));
 
@@ skipping 12 matching lines @@
 
 void HandleSwapPrimaryDisplay() {
   base::RecordAction(UserMetricsAction("Accel_Swap_Primary_Display"));
   Shell::GetInstance()->display_configuration_controller()->SetPrimaryDisplayId(
       ScreenUtil::GetSecondaryDisplay().id(), true /* user_action */);
 }
 
 bool CanHandleCycleUser() {
   Shell* shell = Shell::GetInstance();
   return shell->delegate()->IsMultiProfilesEnabled() &&
-         shell->session_state_delegate()->NumberOfLoggedInUsers() > 1;
+         WmShell::Get()->GetSessionStateDelegate()->NumberOfLoggedInUsers() > 1;
 }
 
 void HandleCycleUser(SessionStateDelegate::CycleUser cycle_user) {
   MultiProfileUMA::RecordSwitchActiveUser(
       MultiProfileUMA::SWITCH_ACTIVE_USER_BY_ACCELERATOR);
   switch (cycle_user) {
     case SessionStateDelegate::CYCLE_TO_NEXT_USER:
       base::RecordAction(UserMetricsAction("Accel_Switch_To_Next_User"));
       break;
     case SessionStateDelegate::CYCLE_TO_PREVIOUS_USER:
       base::RecordAction(UserMetricsAction("Accel_Switch_To_Previous_User"));
       break;
   }
-  Shell::GetInstance()->session_state_delegate()->CycleActiveUser(cycle_user);
+  WmShell::Get()->GetSessionStateDelegate()->CycleActiveUser(cycle_user);
 }
 
 bool CanHandleToggleCapsLock(const ui::Accelerator& accelerator,
                              const ui::Accelerator& previous_accelerator) {
   if (accelerator.key_code() == ui::VKEY_LWIN) {
     // If something else was pressed between the Search key (LWIN)
     // being pressed and released, then ignore the release of the
     // Search key.
     // TODO(danakj): Releasing Alt first breaks this: crbug.com/166495
     if (previous_accelerator.type() == ui::ET_KEY_RELEASED ||
@@ skipping 16 matching lines @@
 void HandleToggleMirrorMode() {
   base::RecordAction(UserMetricsAction("Accel_Toggle_Mirror_Mode"));
   bool mirror = !Shell::GetInstance()->display_manager()->IsInMirrorMode();
   Shell::GetInstance()->display_configuration_controller()->SetMirrorMode(
       mirror, true /* user_action */);
 }
 
 void HandleToggleSpokenFeedback() {
   base::RecordAction(UserMetricsAction("Accel_Toggle_Spoken_Feedback"));
 
-  Shell::GetInstance()->accessibility_delegate()->ToggleSpokenFeedback(
+  WmShell::Get()->GetAccessibilityDelegate()->ToggleSpokenFeedback(
       A11Y_NOTIFICATION_SHOW);
 }
 
 bool CanHandleTouchHud() {
   return RootWindowController::ForTargetRootWindow()->touch_hud_debug();
 }
 
 void HandleTouchHudClear() {
   RootWindowController::ForTargetRootWindow()->touch_hud_debug()->Clear();
 }
@@ skipping 691 matching lines @@
   return true;
 }
 
 AcceleratorController::AcceleratorProcessingRestriction
 AcceleratorController::GetAcceleratorProcessingRestriction(int action) {
   if (WmShell::Get()->IsPinned() &&
       actions_allowed_in_pinned_mode_.find(action) ==
           actions_allowed_in_pinned_mode_.end()) {
     return RESTRICTION_PREVENT_PROCESSING_AND_PROPAGATION;
   }
-  ash::Shell* shell = ash::Shell::GetInstance();
-  if (!shell->session_state_delegate()->IsActiveUserSessionStarted() &&
+  Shell* shell = Shell::GetInstance();
+  WmShell* wm_shell = WmShell::Get();
+  if (!wm_shell->GetSessionStateDelegate()->IsActiveUserSessionStarted() &&
       actions_allowed_at_login_screen_.find(action) ==
           actions_allowed_at_login_screen_.end()) {
     return RESTRICTION_PREVENT_PROCESSING;
   }
-  if (shell->session_state_delegate()->IsScreenLocked() &&
+  if (wm_shell->GetSessionStateDelegate()->IsScreenLocked() &&
       actions_allowed_at_lock_screen_.find(action) ==
           actions_allowed_at_lock_screen_.end()) {
     return RESTRICTION_PREVENT_PROCESSING;
   }
   if (shell->delegate()->IsRunningInForcedAppMode() &&
       actions_allowed_in_app_mode_.find(action) ==
           actions_allowed_in_app_mode_.end()) {
     return RESTRICTION_PREVENT_PROCESSING;
   }
   if (WmShell::Get()->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 (shell->mru_window_tracker()->BuildMruWindowList().empty() &&
       actions_needing_window_.find(action) != actions_needing_window_.end()) {
-    Shell::GetInstance()->accessibility_delegate()->TriggerAccessibilityAlert(
+    wm_shell->GetAccessibilityDelegate()->TriggerAccessibilityAlert(
         A11Y_ALERT_WINDOW_NEEDED);
     return RESTRICTION_PREVENT_PROCESSING_AND_PROPAGATION;
   }
   return RESTRICTION_NONE;
 }
 
 void AcceleratorController::SetKeyboardBrightnessControlDelegate(
     std::unique_ptr<KeyboardBrightnessControlDelegate>
         keyboard_brightness_control_delegate) {
   keyboard_brightness_control_delegate_ =
       std::move(keyboard_brightness_control_delegate);
 }
 
 }  // namespace ash