ash / wm / window_cycle / window_cycle_controller.cc [blame]

// Copyright 2014 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "ash/wm/window_cycle/window_cycle_controller.h"

#include "ash/accessibility/accessibility_controller.h"
#include "ash/constants/ash_pref_names.h"
#include "ash/events/event_rewriter_controller_impl.h"
#include "ash/metrics/task_switch_metrics_recorder.h"
#include "ash/metrics/task_switch_source.h"
#include "ash/metrics/user_metrics_recorder.h"
#include "ash/session/session_controller_impl.h"
#include "ash/shell.h"
#include "ash/strings/grit/ash_strings.h"
#include "ash/wallpaper/wallpaper_controller_impl.h"
#include "ash/wm/desks/desk.h"
#include "ash/wm/desks/desk_bar_controller.h"
#include "ash/wm/desks/desks_util.h"
#include "ash/wm/mru_window_tracker.h"
#include "ash/wm/overview/overview_controller.h"
#include "ash/wm/screen_pinning_controller.h"
#include "ash/wm/snap_group/snap_group.h"
#include "ash/wm/snap_group/snap_group_controller.h"
#include "ash/wm/window_cycle/window_cycle_event_filter.h"
#include "ash/wm/window_cycle/window_cycle_list.h"
#include "ash/wm/window_util.h"
#include "base/check.h"
#include "base/containers/contains.h"
#include "base/functional/bind.h"
#include "base/metrics/histogram_functions.h"
#include "base/metrics/user_metrics.h"
#include "components/prefs/pref_service.h"
#include "ui/base/l10n/l10n_util.h"

namespace ash {

namespace {

constexpr char kAltTabDesksSwitchDistanceHistogramName[] =
    "Ash.WindowCycleController.DesksSwitchDistance";
constexpr char kAltTabInitialModeHistogramName[] =
    "Ash.WindowCycleController.InitialMode";
constexpr char kAltTabItemsHistogramName[] = "Ash.WindowCycleController.Items";
constexpr char kAltTabSwitchModeHistogramName[] =
    "Ash.WindowCycleController.SwitchMode";
constexpr char kAltTabModeSwitchSourceHistogramName[] =
    "Ash.WindowCycleController.ModeSwitchSource";
constexpr char kSameAppWindowCycleIsSameAppHistogramName[] =
    "Ash.WindowCycleController.SameApp.IsSameApp";
constexpr char kSameAppWindowCycleDeskModeHistogramName[] =
    "Ash.WindowCycleController.SameApp.DeskMode";

// Enumeration of the alt-tab modes to record initial mode and mode switch.
// Note that these values are persisted to histograms so existing values should
// remain unchanged and new values should be added to the end.
enum class AltTabMode {
  // The window list includes all windows from all desks.
  kAllDesks,
  // The window list only includes windows from the active desk.
  kCurrentDesk,
  kMaxValue = kCurrentDesk,
};

// Returns the most recently active window from the |window_list| or nullptr
// if the list is empty.
aura::Window* GetActiveWindow(
    const WindowCycleController::WindowList& window_list) {
  return window_list.empty() ? nullptr : window_list[0];
}

void ReportPossibleDesksSwitchStats(int active_desk_container_id_before_cycle) {
  // Report only for users who have 2 or more desks, since we're only interested
  // in seeing how users of Virtual Desks use window cycling.
  auto* desks_controller = DesksController::Get();
  if (!desks_controller)
    return;

  if (desks_controller->desks().size() < 2)
    return;

  // Note that this functions is called while a potential desk switch animation
  // is starting, in this case we want the target active desk (i.e. the soon-to-
  // be active desk after the animation finishes).
  const int active_desk_container_id_after_cycle =
      desks_controller->GetTargetActiveDesk()->container_id();
  DCHECK_NE(active_desk_container_id_before_cycle, kShellWindowId_Invalid);
  DCHECK_NE(active_desk_container_id_after_cycle, kShellWindowId_Invalid);

  // Note that the desks containers IDs are consecutive. See
  // |ash::ShellWindowId|.
  const int desks_switch_distance =
      std::abs(active_desk_container_id_after_cycle -
               active_desk_container_id_before_cycle);
  base::UmaHistogramExactLinear(kAltTabDesksSwitchDistanceHistogramName,
                                desks_switch_distance,
                                desks_util::kDesksUpperLimit);
}

}  // namespace

//////////////////////////////////////////////////////////////////////////////
// WindowCycleController, public:

WindowCycleController::WindowCycleController() {
  Shell::Get()->session_controller()->AddObserver(this);
}

WindowCycleController::~WindowCycleController() {
  Shell::Get()->session_controller()->RemoveObserver(this);
}

// static
bool WindowCycleController::CanCycle() {
  return !Shell::Get()->session_controller()->IsScreenLocked() &&
         !Shell::IsSystemModalWindowOpen() &&
         !Shell::Get()->screen_pinning_controller()->IsPinned() &&
         !window_util::IsAnyWindowDragged() &&
         !Shell::Get()->desks_controller()->AreDesksBeingModified();
}

// static
void WindowCycleController::RegisterProfilePrefs(PrefRegistrySimple* registry) {
  registry->RegisterBooleanPref(prefs::kAltTabPerDesk, DesksMruType::kAllDesks);
}

void WindowCycleController::HandleCycleWindow(WindowCyclingDirection direction,
                                              bool same_app_only) {
  if (!CanCycle())
    return;

  const bool should_start_alt_tab = !IsCycling();
  if (should_start_alt_tab)
    StartCycling(same_app_only);

  Step(direction, /*starting_alt_tab_or_switching_mode=*/should_start_alt_tab);
}

void WindowCycleController::HandleKeyboardNavigation(
    KeyboardNavDirection direction) {
  // If the UI is not shown yet, discard the event.
  if (!CanCycle() || !IsCycling() || !window_cycle_list_->cycle_view() ||
      !IsValidKeyboardNavigation(direction)) {
    return;
  }

  switch (direction) {
    // Pressing the Up arrow key moves the focus from the window cycle list
    // to the tab slider button.
    case KeyboardNavDirection::kUp:
      DCHECK(!IsTabSliderFocused() && IsInteractiveAltTabModeAllowed());
      window_cycle_list_->SetFocusTabSlider(true);
      // Focusing the alt-tab mode button announces the current mode.
      Shell::Get()
          ->accessibility_controller()
          ->TriggerAccessibilityAlertWithMessage(l10n_util::GetStringUTF8(
              IsAltTabPerActiveDesk()
                  ? IDS_ASH_ALT_TAB_CURRENT_DESK_MODE_SELECTED_TITLE
                  : IDS_ASH_ALT_TAB_ALL_DESKS_MODE_SELECTED_TITLE));
      break;
    // Pressing the Down arrow key does the opposite of the Up arrow key.
    case KeyboardNavDirection::kDown: {
      DCHECK(IsTabSliderFocused());
      window_cycle_list_->SetFocusTabSlider(false);
      aura::Window* target_window = window_cycle_list_->GetTargetWindow();
      // Cannot press the Down arrow key if there is no window.
      DCHECK(target_window);
      // Announce the selected window in the window cycle list.
      Shell::Get()
          ->accessibility_controller()
          ->TriggerAccessibilityAlertWithMessage(
              l10n_util::GetStringFUTF8(IDS_ASH_ALT_TAB_WINDOW_SELECTED_TITLE,
                                        target_window->GetTitle()));
      break;
    }
    // Pressing the Left or Right arrow keys cycles through the window list
    // or switches alt-tab mode depending on which component is focused.
    case KeyboardNavDirection::kRight:
    case KeyboardNavDirection::kLeft:
      if (!IsTabSliderFocused()) {
        // Cycling through the window list if focusing the window.
        HandleCycleWindow(direction == KeyboardNavDirection::kRight
                              ? WindowCyclingDirection::kForward
                              : WindowCyclingDirection::kBackward);
      } else {
        // Switch the mode if focusing the button. Navigating right triggers
        // the right button corresponding to the active desk mode. On the other
        // hand, navigating left enables the all-desk mode.
        OnModeChanged(direction == KeyboardNavDirection::kRight,
                      ModeSwitchSource::kKeyboard);
      }
      break;
    case KeyboardNavDirection::kInvalid:
    default:
      NOTREACHED();
  }
}

void WindowCycleController::Drag(float delta_x) {
  DCHECK(window_cycle_list_);
  window_cycle_list_->Drag(delta_x);
}

void WindowCycleController::StartFling(float velocity_x) {
  DCHECK(window_cycle_list_);
  window_cycle_list_->StartFling(velocity_x);
}

void WindowCycleController::StartCycling(bool same_app_only) {
  Shell* shell = Shell::Get();

  // Close the wallpaper preview if it is open to prevent visual glitches where
  // the window view item for the preview is transparent
  // (http://crbug.com/895265).
  shell->wallpaper_controller()->MaybeClosePreviewWallpaper();
  shell->event_rewriter_controller()->SetAltDownRemappingEnabled(false);

  // End overview as the window cycle list takes over window switching.
  shell->overview_controller()->EndOverview(
      OverviewEndAction::kStartedWindowCycle);

  // Close all desk bars as the window cycle list takes over window switching.
  if (auto* desk_bar_controller =
          shell->desks_controller()->desk_bar_controller()) {
    desk_bar_controller->CloseAllDeskBars();
  }

  WindowCycleController::WindowList window_list = CreateWindowList();
  SaveCurrentActiveDeskAndWindow(window_list);
  window_cycle_list_ =
      std::make_unique<WindowCycleList>(window_list, same_app_only);
  event_filter_ = std::make_unique<WindowCycleEventFilter>();
  base::UmaHistogramBoolean(kSameAppWindowCycleIsSameAppHistogramName,
                            same_app_only);
  if (!same_app_only) {
    base::RecordAction(base::UserMetricsAction("WindowCycleController_Cycle"));
    base::UmaHistogramCounts100(kAltTabItemsHistogramName, window_list.size());
    if (IsInteractiveAltTabModeAllowed()) {
      // When alt-tab interactive mode is available, report the initial alt-tab
      // mode which indicates the user's preferred mode.
      base::UmaHistogramEnumeration(kAltTabInitialModeHistogramName,
                                    IsAltTabPerActiveDesk()
                                        ? AltTabMode::kCurrentDesk
                                        : AltTabMode::kAllDesks);
    }
  }

  desks_observation_.Observe(DesksController::Get());
}

void WindowCycleController::CompleteCycling() {
  DCHECK(window_cycle_list_);
  window_cycle_list_->set_user_did_accept(true);
  StopCycling();
}

void WindowCycleController::CancelCycling() {
  StopCycling();
}

void WindowCycleController::MaybeResetCycleList() {
  if (!IsCycling())
    return;

  WindowCycleController::WindowList window_list = CreateWindowList();
  SaveCurrentActiveDeskAndWindow(window_list);

  DCHECK(window_cycle_list_);
  window_cycle_list_->ReplaceWindows(window_list);
}

void WindowCycleController::SetFocusedWindow(aura::Window* window) {
  if (!IsCycling())
    return;

  DCHECK(window_cycle_list_);
  window_cycle_list_->SetFocusedWindow(window);
}

bool WindowCycleController::IsEventInCycleView(
    const ui::LocatedEvent* event) const {
  return window_cycle_list_ && window_cycle_list_->IsEventInCycleView(event);
}

aura::Window* WindowCycleController::GetWindowAtPoint(
    const ui::LocatedEvent* event) {
  return window_cycle_list_ ? window_cycle_list_->GetWindowAtPoint(event)
                            : nullptr;
}

bool WindowCycleController::IsEventInTabSliderContainer(
    const ui::LocatedEvent* event) const {
  return window_cycle_list_ &&
         window_cycle_list_->IsEventInTabSliderContainer(event);
}

bool WindowCycleController::IsWindowListVisible() const {
  return window_cycle_list_ && window_cycle_list_->ShouldShowUi();
}

bool WindowCycleController::IsInteractiveAltTabModeAllowed() const {
  return Shell::Get()->desks_controller()->GetNumberOfDesks() > 1;
}

bool WindowCycleController::IsAltTabPerActiveDesk() const {
  return IsInteractiveAltTabModeAllowed() && active_user_pref_service_ &&
         active_user_pref_service_->GetBoolean(prefs::kAltTabPerDesk);
}

bool WindowCycleController::IsSwitchingMode() const {
  return IsInteractiveAltTabModeAllowed() && is_switching_mode_;
}

bool WindowCycleController::IsTabSliderFocused() const {
  return IsInteractiveAltTabModeAllowed() &&
         window_cycle_list_->IsTabSliderFocused();
}

void WindowCycleController::OnModeChanged(bool per_desk,
                                          ModeSwitchSource source) {
  DCHECK(IsInteractiveAltTabModeAllowed() && IsCycling());
  // Save to the active user prefs.
  auto* prefs = Shell::Get()->session_controller()->GetActivePrefService();
  if (!prefs) {
    // Can be null in tests.
    return;
  }
  // Avoid an unnecessary update if any.
  if (per_desk == prefs->GetBoolean(prefs::kAltTabPerDesk))
    return;
  prefs->SetBoolean(prefs::kAltTabPerDesk, per_desk);

  // Report the alt-tab mode the user switches to and the source of switch.
  if (!window_cycle_list_->same_app_only()) {
    base::UmaHistogramEnumeration(
        kAltTabSwitchModeHistogramName,
        per_desk ? AltTabMode::kCurrentDesk : AltTabMode::kAllDesks);
    base::UmaHistogramEnumeration(kAltTabModeSwitchSourceHistogramName, source);
  }

  // Announce the new mode and the updated window selection via ChromeVox.
  aura::Window* target_window = window_cycle_list_->GetTargetWindow();
  const std::string mode_switched_string = l10n_util::GetStringUTF8(
      per_desk ? IDS_ASH_ALT_TAB_CURRENT_DESK_MODE_SELECTED_TITLE
               : IDS_ASH_ALT_TAB_ALL_DESKS_MODE_SELECTED_TITLE);
  // A ChromeVox string announcing the selected window in the window cycle list
  // or no recent items if there's no window in the list.
  const std::string window_selected_string =
      target_window
          ? l10n_util::GetStringFUTF8(IDS_ASH_ALT_TAB_WINDOW_SELECTED_TITLE,
                                      target_window->GetTitle())
          : l10n_util::GetStringUTF8(IDS_ASH_OVERVIEW_NO_RECENT_ITEMS);
  switch (source) {
    case ModeSwitchSource::kClick:
      Shell::Get()
          ->accessibility_controller()
          ->TriggerAccessibilityAlertWithMessage(base::JoinString(
              {mode_switched_string, window_selected_string}, " "));
      // If the user clicks the mode button, remove the focus from it.
      window_cycle_list_->SetFocusTabSlider(false);
      break;
    case ModeSwitchSource::kKeyboard:
      // Additionally, during keyboard navigation, notify that the user can
      // press the Down arrow key to navigate among the cycle windows if the
      // list is not empty.
      Shell::Get()
          ->accessibility_controller()
          ->TriggerAccessibilityAlertWithMessage(base::JoinString(
              {mode_switched_string, window_selected_string,
               target_window ? l10n_util::GetStringUTF8(
                                   IDS_ASH_ALT_TAB_FOCUS_WINDOW_LIST_TITLE)
                             : std::string()},
              " "));
      break;
    default:
      NOTREACHED();
  }
}

void WindowCycleController::OnActiveUserPrefServiceChanged(
    PrefService* pref_service) {
  active_user_pref_service_ = pref_service;
  InitFromUserPrefs();
}

void WindowCycleController::OnDeskAdded(const Desk* desk, bool from_undo) {
  CancelCycling();
}

void WindowCycleController::OnDeskRemoved(const Desk* desk) {
  CancelCycling();
}

//////////////////////////////////////////////////////////////////////////////
// WindowCycleController, private:

WindowCycleController::WindowList WindowCycleController::CreateWindowList() {
  WindowList window_list = BuildWindowListForWindowCycling(
      IsAltTabPerActiveDesk() ? kActiveDesk : kAllDesks);

  // Window cycle list windows will handle showing their transient related
  // windows, so if a window in |window_list| has a transient root also in
  // |window_list|, we can remove it as the transient root will handle showing
  // the window.
  window_util::EnsureTransientRoots(&window_list);
  return window_list;
}

MruWindowTracker::WindowList
WindowCycleController::BuildWindowListForWindowCycling(
    DesksMruType desks_mru_type) {
  const auto window_list =
      Shell::Get()->mru_window_tracker()->BuildWindowForCycleWithPipList(
          desks_mru_type);

  SnapGroupController* snap_group_controller = SnapGroupController::Get();
  if (!snap_group_controller) {
    return window_list;
  }

  MruWindowTracker::WindowList adjusted_window_list;
  for (aura::Window* window : window_list) {
    // The latter-activated window in a snap group should have been added. Skip
    // inserting to avoid duplicates.
    if (base::Contains(adjusted_window_list, window)) {
      continue;
    }

    if (SnapGroup* snap_group =
            snap_group_controller->GetSnapGroupForGivenWindow(window)) {
      // Insert the windows if they belong to a group following the order of the
      // actual window layout, i.e. primary snapped window comes first followed
      // by the secondary snapped window.
      adjusted_window_list.push_back(
          snap_group->GetPhysicallyLeftOrTopWindow());
      adjusted_window_list.push_back(
          snap_group->GetPhysicallyRightOrBottomWindow());
    } else {
      adjusted_window_list.push_back(window);
    }
  }

  return adjusted_window_list;
}

void WindowCycleController::SaveCurrentActiveDeskAndWindow(
    const WindowCycleController::WindowList& window_list) {
  active_desk_container_id_before_cycle_ =
      desks_util::GetActiveDeskContainerId();
  active_window_before_window_cycle_ = GetActiveWindow(window_list);
}

void WindowCycleController::Step(WindowCyclingDirection direction,
                                 bool starting_alt_tab_or_switching_mode) {
  DCHECK(window_cycle_list_);
  window_cycle_list_->Step(direction, starting_alt_tab_or_switching_mode);
}

void WindowCycleController::StopCycling() {
  // There's an edge case where `StopCycling()` is already triggered via an alt
  // release event, but user doesn't release the tap on the
  // `window_cycle_list_`. If we reset `window_cycle_list_` first,
  // `WindowEventDispatcher::DispatchSyntheticTouchEvent` will be triggered
  // because of the availability changed for the `window_cycle_list_`. Thus
  // `event_filter_` will still receive the event and try to handle the event
  // even though it's in the process of stopping cycling. To avoid this, we
  // should remove our event filter first. Please check
  // https://crbug.com/1228381 for more details.
  event_filter_.reset();

  desks_observation_.Reset();
  const bool was_same_app_only = window_cycle_list_->same_app_only();
  window_cycle_list_.reset();

  // We can't use the MRU window list here to get the active window, since
  // cycling can activate a window on a different desk, leading to a desk-switch
  // animation launching. Getting the MRU window list for the active desk now
  // will always be for the current active desk, not the target active desk.
  aura::Window* active_window_after_window_cycle =
      window_util::GetActiveWindow();

  if (was_same_app_only) {
    base::UmaHistogramEnumeration(kSameAppWindowCycleDeskModeHistogramName,
                                  IsAltTabPerActiveDesk()
                                      ? AltTabMode::kCurrentDesk
                                      : AltTabMode::kAllDesks);
  } else if (active_window_after_window_cycle != nullptr &&
             active_window_before_window_cycle_ !=
                 active_window_after_window_cycle) {
    Shell::Get()->metrics()->task_switch_metrics_recorder().OnTaskSwitch(
        TaskSwitchSource::WINDOW_CYCLE_CONTROLLER);

    ReportPossibleDesksSwitchStats(active_desk_container_id_before_cycle_);
  }

  active_window_before_window_cycle_ = nullptr;
  active_desk_container_id_before_cycle_ = kShellWindowId_Invalid;
  Shell::Get()->event_rewriter_controller()->SetAltDownRemappingEnabled(true);
}

void WindowCycleController::InitFromUserPrefs() {
  DCHECK(active_user_pref_service_);

  pref_change_registrar_ = std::make_unique<PrefChangeRegistrar>();
  pref_change_registrar_->Init(active_user_pref_service_);
  pref_change_registrar_->Add(
      prefs::kAltTabPerDesk,
      base::BindRepeating(&WindowCycleController::OnAltTabModePrefChanged,
                          base::Unretained(this)));

  OnAltTabModePrefChanged();
}

void WindowCycleController::OnAltTabModePrefChanged() {
  // Only update UI for alt-tab mode if the user is using alt-tab with the
  // interactive alt-tab mode supported.
  if (!IsInteractiveAltTabModeAllowed() || !IsCycling())
    return;

  is_switching_mode_ = true;

  // Update the window cycle list.
  MaybeResetCycleList();

  // After the cycle is reset, imitate the same forward cycling behavior as
  // starting alt-tab with `Step()`, which makes sure the correct window is
  // selected and focused.
  Step(WindowCyclingDirection::kForward,
       /*starting_alt_tab_or_switching_mode=*/true);

  // Update tab slider button UI.
  window_cycle_list_->OnModePrefsChanged();

  is_switching_mode_ = false;
}

bool WindowCycleController::IsValidKeyboardNavigation(
    KeyboardNavDirection direction) const {
  // Only allow Left and Right arrow keys if interactive alt-tab mode is not
  // in use.
  if (!IsInteractiveAltTabModeAllowed()) {
    return direction == KeyboardNavDirection::kLeft ||
           direction == KeyboardNavDirection::kRight;
  }

  // If the focus is on the window cycle list, the user can navigate up to
  // focus the mode buttons, or left and right to change the window selection.
  if (!IsTabSliderFocused())
    return direction != KeyboardNavDirection::kDown;

  // If the focus is on the tab slider button, the user can navigate down to
  // focus the non-empty list, determined by non-null target window. The user
  // can only navigate left while focusing the right button and vice versa.
  const bool per_desk = IsAltTabPerActiveDesk();
  return (direction == KeyboardNavDirection::kDown &&
          window_cycle_list_->GetTargetWindow()) ||
         (per_desk && direction == KeyboardNavDirection::kLeft) ||
         (!per_desk && direction == KeyboardNavDirection::kRight);
}

}  // namespace ash