123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560 |
- // Copyright 2013 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/multi_user/multi_user_window_manager_impl.h"
- #include <set>
- #include <vector>
- #include "ash/media/media_controller_impl.h"
- #include "ash/multi_user/user_switch_animator.h"
- #include "ash/public/cpp/multi_user_window_manager_delegate.h"
- #include "ash/public/cpp/shell_window_ids.h"
- #include "ash/session/session_controller_impl.h"
- #include "ash/shell.h"
- #include "ash/wm/desks/desks_util.h"
- #include "ash/wm/tablet_mode/tablet_mode_controller.h"
- #include "base/auto_reset.h"
- #include "ui/aura/client/aura_constants.h"
- #include "ui/aura/window.h"
- #include "ui/base/ui_base_types.h"
- #include "ui/events/event.h"
- #include "ui/wm/core/transient_window_manager.h"
- #include "ui/wm/core/window_animations.h"
- #include "ui/wm/core/window_util.h"
- namespace ash {
- namespace {
- // The animation time for a single window that is fading in / out.
- constexpr base::TimeDelta kAnimationTime = base::Milliseconds(100);
- // The animation time for the fade in and / or out when switching users.
- constexpr base::TimeDelta kUserFadeTime = base::Milliseconds(110);
- // The animation time in ms for a window which get teleported to another screen.
- constexpr base::TimeDelta kTeleportAnimationTime = base::Milliseconds(300);
- MultiUserWindowManagerImpl* g_instance = nullptr;
- bool HasSystemModalTransientChildWindow(aura::Window* window) {
- if (window == nullptr)
- return false;
- aura::Window* system_modal_container = window->GetRootWindow()->GetChildById(
- ash::kShellWindowId_SystemModalContainer);
- if (window->parent() == system_modal_container)
- return true;
- for (aura::Window* transient_child : ::wm::GetTransientChildren(window)) {
- if (HasSystemModalTransientChildWindow(transient_child))
- return true;
- }
- return false;
- }
- } // namespace
- // A class to temporarily change the animation properties for a window.
- class AnimationSetter {
- public:
- AnimationSetter(aura::Window* window, base::TimeDelta animation_time)
- : window_(window),
- previous_animation_type_(
- ::wm::GetWindowVisibilityAnimationType(window_)),
- previous_animation_time_(
- ::wm::GetWindowVisibilityAnimationDuration(*window_)) {
- ::wm::SetWindowVisibilityAnimationType(
- window_, ::wm::WINDOW_VISIBILITY_ANIMATION_TYPE_FADE);
- ::wm::SetWindowVisibilityAnimationDuration(window_, animation_time);
- }
- AnimationSetter(const AnimationSetter&) = delete;
- AnimationSetter& operator=(const AnimationSetter&) = delete;
- ~AnimationSetter() {
- ::wm::SetWindowVisibilityAnimationType(window_, previous_animation_type_);
- ::wm::SetWindowVisibilityAnimationDuration(window_,
- previous_animation_time_);
- }
- private:
- // The window which gets used.
- aura::Window* window_;
- // Previous animation type.
- const int previous_animation_type_;
- // Previous animation time.
- const base::TimeDelta previous_animation_time_;
- };
- MultiUserWindowManagerImpl::WindowEntry::WindowEntry(
- const AccountId& account_id)
- : owner_(account_id), show_for_user_(account_id) {}
- MultiUserWindowManagerImpl::WindowEntry::~WindowEntry() = default;
- MultiUserWindowManagerImpl::MultiUserWindowManagerImpl(
- MultiUserWindowManagerDelegate* delegate,
- const AccountId& account_id)
- : delegate_(delegate), current_account_id_(account_id) {
- DCHECK(delegate_);
- g_instance = this;
- Shell::Get()->tablet_mode_controller()->AddObserver(this);
- Shell::Get()->session_controller()->AddObserver(this);
- }
- MultiUserWindowManagerImpl::~MultiUserWindowManagerImpl() {
- // When the MultiUserWindowManager gets destroyed, ash::Shell is mostly gone.
- // As such we should not try to finalize any outstanding user animations.
- // Note that the destruction of the object can be done later.
- if (animation_.get())
- animation_->CancelAnimation();
- // Remove all window observers.
- while (!window_to_entry_.empty()) {
- // Explicitly remove this from window observer list since OnWindowDestroyed
- // no longer does that.
- aura::Window* window = window_to_entry_.begin()->first;
- window->RemoveObserver(this);
- OnWindowDestroyed(window);
- }
- Shell::Get()->session_controller()->RemoveObserver(this);
- Shell::Get()->tablet_mode_controller()->RemoveObserver(this);
- g_instance = nullptr;
- }
- // static
- MultiUserWindowManagerImpl* MultiUserWindowManagerImpl::Get() {
- return g_instance;
- }
- void MultiUserWindowManagerImpl::SetWindowOwner(aura::Window* window,
- const AccountId& account_id) {
- // Make sure the window is valid and there was no owner yet.
- DCHECK(window);
- DCHECK(account_id.is_valid());
- if (GetWindowOwner(window) == account_id)
- return;
- // Transient window ownership is tracked by the parent window's ownership.
- if (GetOwningWindowInTransientChain(window))
- return;
- DCHECK(GetWindowOwner(window).empty());
- std::unique_ptr<WindowEntry> window_entry_ptr =
- std::make_unique<WindowEntry>(account_id);
- WindowEntry* window_entry = window_entry_ptr.get();
- window_to_entry_[window] = std::move(window_entry_ptr);
- // Remember the initial visibility of the window.
- window_entry->set_show(window->TargetVisibility());
- // Add observers to track state changes.
- window->AddObserver(this);
- ::wm::TransientWindowManager::GetOrCreate(window)->AddObserver(this);
- // Check if this window was created due to a user interaction. If it was,
- // transfer it to the current user.
- const bool show_for_current_user =
- window->GetProperty(aura::client::kCreatedByUserGesture);
- if (show_for_current_user)
- window_entry->set_show_for_user(current_account_id_);
- // Add all transient children to our set of windows. Note that the function
- // will add the children but not the owner to the transient children map.
- AddTransientOwnerRecursive(window, window);
- if (!IsWindowOnDesktopOfUser(window, current_account_id_))
- SetWindowVisibility(window, false);
- }
- void MultiUserWindowManagerImpl::ShowWindowForUser(
- aura::Window* window,
- const AccountId& account_id) {
- DCHECK(window);
- const AccountId previous_owner(GetUserPresentingWindow(window));
- if (!ShowWindowForUserIntern(window, account_id))
- return;
- // The window switched to a new desktop and we have to switch to that desktop,
- // but only when it was on the visible desktop and the the target is not the
- // visible desktop.
- if (account_id == current_account_id_ ||
- previous_owner != current_account_id_)
- return;
- Shell::Get()->session_controller()->SwitchActiveUser(account_id);
- }
- const AccountId& MultiUserWindowManagerImpl::GetWindowOwner(
- const aura::Window* window) const {
- WindowToEntryMap::const_iterator it =
- window_to_entry_.find(const_cast<aura::Window*>(window));
- return it != window_to_entry_.end() ? it->second->owner() : EmptyAccountId();
- }
- bool MultiUserWindowManagerImpl::AreWindowsSharedAmongUsers() const {
- for (auto& window_pair : window_to_entry_) {
- if (window_pair.second->owner() != window_pair.second->show_for_user())
- return true;
- }
- return false;
- }
- std::set<AccountId> MultiUserWindowManagerImpl::GetOwnersOfVisibleWindows()
- const {
- std::set<AccountId> result;
- for (auto& window_pair : window_to_entry_) {
- if (window_pair.first->IsVisible())
- result.insert(window_pair.second->owner());
- }
- return result;
- }
- const AccountId& MultiUserWindowManagerImpl::GetUserPresentingWindow(
- const aura::Window* window) const {
- auto iter = window_to_entry_.find(const_cast<aura::Window*>(window));
- // If the window is not owned by anyone it is shown on all desktops and we
- // return the empty string.
- return (iter == window_to_entry_.end()) ? EmptyAccountId()
- : iter->second->show_for_user();
- }
- const AccountId& MultiUserWindowManagerImpl::CurrentAccountId() const {
- return current_account_id_;
- }
- bool MultiUserWindowManagerImpl::IsWindowOnDesktopOfUser(
- aura::Window* window,
- const AccountId& account_id) const {
- const AccountId& presenting_user = GetUserPresentingWindow(window);
- return (!presenting_user.is_valid()) || presenting_user == account_id;
- }
- const AccountId& MultiUserWindowManagerImpl::GetUserPresentingWindow(
- aura::Window* window) const {
- WindowToEntryMap::const_iterator it = window_to_entry_.find(window);
- // If the window is not owned by anyone it is shown on all desktops and we
- // return the empty string.
- if (it == window_to_entry_.end())
- return EmptyAccountId();
- // Otherwise we ask the object for its desktop.
- return it->second->show_for_user();
- }
- void MultiUserWindowManagerImpl::OnActiveUserSessionChanged(
- const AccountId& account_id) {
- // MultiUserWindowManagerImpl is created with an account before the change has
- // potentially made it to SessionController. This means
- // MultiUserWindowManagerImpl may be notified of a switch to the current user.
- // Ignore this. Ignoring this is especially important in tests, which may be
- // impacted by running the animation (when the animation closes, observers are
- // notified, which may have side effects in downstream code).
- if (account_id == current_account_id_)
- return;
- // This needs to be set before the animation starts.
- current_account_id_ = account_id;
- // Here to avoid a very nasty race condition, we must destruct any previously
- // created animation before creating a new one. Otherwise, the newly
- // constructed will hide all windows of the old user in the first step of the
- // animation only to be reshown again by the destructor of the old animation.
- animation_.reset();
- animation_ = std::make_unique<UserSwitchAnimator>(
- this, current_account_id_, GetAdjustedAnimationTime(kUserFadeTime));
- // Call RequestCaptureState here instead of having MediaClient observe
- // ActiveUserChanged because it must happen after
- // MultiUserWindowManagerImpl is notified.
- Shell::Get()->media_controller()->RequestCaptureState();
- }
- void MultiUserWindowManagerImpl::OnWindowDestroyed(aura::Window* window) {
- if (GetWindowOwner(window).empty()) {
- // This must be a window in the transient chain - remove it and its
- // children from the owner.
- RemoveTransientOwnerRecursive(window);
- return;
- }
- ::wm::TransientWindowManager::GetOrCreate(window)->RemoveObserver(this);
- window_to_entry_.erase(window);
- }
- void MultiUserWindowManagerImpl::OnWindowVisibilityChanging(
- aura::Window* window,
- bool visible) {
- // This command gets called first and immediately when show or hide gets
- // called. We remember here the desired state for restoration IF we were
- // not ourselves issuing the call.
- // Note also that using the OnWindowVisibilityChanged callback cannot be
- // used for this.
- if (suppress_visibility_changes_)
- return;
- WindowToEntryMap::iterator it = window_to_entry_.find(window);
- // If the window is not owned by anyone it is shown on all desktops.
- if (it != window_to_entry_.end()) {
- // Remember what was asked for so that we can restore this when the user's
- // desktop gets restored.
- it->second->set_show(visible);
- } else {
- TransientWindowToVisibility::iterator it =
- transient_window_to_visibility_.find(window);
- if (it != transient_window_to_visibility_.end())
- it->second = visible;
- }
- }
- void MultiUserWindowManagerImpl::OnWindowVisibilityChanged(aura::Window* window,
- bool visible) {
- if (suppress_visibility_changes_)
- return;
- // Don't allow to make the window visible if it shouldn't be.
- if (visible && !IsWindowOnDesktopOfUser(window, current_account_id_)) {
- SetWindowVisibility(window, false);
- return;
- }
- aura::Window* owned_parent = GetOwningWindowInTransientChain(window);
- if (owned_parent && owned_parent != window && visible &&
- !IsWindowOnDesktopOfUser(owned_parent, current_account_id_))
- SetWindowVisibility(window, false);
- }
- void MultiUserWindowManagerImpl::OnTransientChildAdded(
- aura::Window* window,
- aura::Window* transient_window) {
- if (!GetWindowOwner(window).empty()) {
- AddTransientOwnerRecursive(transient_window, window);
- return;
- }
- aura::Window* owned_parent =
- GetOwningWindowInTransientChain(transient_window);
- if (!owned_parent)
- return;
- AddTransientOwnerRecursive(transient_window, owned_parent);
- }
- void MultiUserWindowManagerImpl::OnTransientChildRemoved(
- aura::Window* window,
- aura::Window* transient_window) {
- // Remove the transient child if the window itself is owned, or one of the
- // windows in its transient parents chain.
- if (!GetWindowOwner(window).empty() ||
- GetOwningWindowInTransientChain(window)) {
- RemoveTransientOwnerRecursive(transient_window);
- }
- }
- void MultiUserWindowManagerImpl::OnTabletModeStarted() {
- for (auto& entry : window_to_entry_)
- Shell::Get()->tablet_mode_controller()->AddWindow(entry.first);
- }
- void MultiUserWindowManagerImpl::SetAnimationSpeedForTest(
- MultiUserWindowManagerImpl::AnimationSpeed speed) {
- animation_speed_ = speed;
- }
- bool MultiUserWindowManagerImpl::IsAnimationRunningForTest() {
- return animation_ && !animation_->IsAnimationFinished();
- }
- const AccountId& MultiUserWindowManagerImpl::GetCurrentUserForTest() const {
- return current_account_id_;
- }
- bool MultiUserWindowManagerImpl::ShowWindowForUserIntern(
- aura::Window* window,
- const AccountId& account_id) {
- // If there is either no owner, or the owner is the current user, no action
- // is required.
- const AccountId& owner = GetWindowOwner(window);
- if ((!owner.is_valid()) ||
- (owner == account_id && IsWindowOnDesktopOfUser(window, account_id)))
- return false;
- bool minimized = wm::WindowStateIs(window, ui::SHOW_STATE_MINIMIZED);
- // Check that we are not trying to transfer ownership of a minimized window.
- if (account_id != owner && minimized)
- return false;
- WindowEntry* window_entry = window_to_entry_[window].get();
- window_entry->set_show_for_user(account_id);
- const bool teleported = !IsWindowOnDesktopOfUser(window, owner);
- // Show the window if the added user is the current one.
- if (account_id == current_account_id_) {
- // Only show the window if it should be shown according to its state.
- if (window_entry->show())
- SetWindowVisibility(window, true, kTeleportAnimationTime);
- } else {
- SetWindowVisibility(window, false, kTeleportAnimationTime);
- }
- delegate_->OnWindowOwnerEntryChanged(window, account_id, minimized,
- teleported);
- return true;
- }
- void MultiUserWindowManagerImpl::SetWindowVisibility(
- aura::Window* window,
- bool visible,
- base::TimeDelta animation_time) {
- if (desks_util::BelongsToActiveDesk(window) && window->IsVisible() == visible)
- return;
- // Hiding a system modal dialog should not be allowed. Instead we switch to
- // the user which is showing the system modal window.
- // Note that in some cases (e.g. unit test) windows might not have a root
- // window.
- if (!visible && window->GetRootWindow()) {
- if (HasSystemModalTransientChildWindow(window)) {
- // The window is system modal and we need to find the parent which owns
- // it so that we can switch to the desktop accordingly.
- AccountId account_id = GetUserPresentingWindow(window);
- if (!account_id.is_valid()) {
- aura::Window* owning_window = GetOwningWindowInTransientChain(window);
- DCHECK(owning_window);
- account_id = GetUserPresentingWindow(owning_window);
- DCHECK(account_id.is_valid());
- }
- Shell::Get()->session_controller()->SwitchActiveUser(account_id);
- return;
- }
- }
- // To avoid that these commands are recorded as any other commands, we are
- // suppressing any window entry changes while this is going on.
- base::AutoReset<bool> suppressor(&suppress_visibility_changes_, true);
- if (visible)
- ShowWithTransientChildrenRecursive(window, animation_time);
- else
- SetWindowVisible(window, false, animation_time);
- }
- void MultiUserWindowManagerImpl::ShowWithTransientChildrenRecursive(
- aura::Window* window,
- base::TimeDelta animation_time) {
- for (aura::Window* transient_child : ::wm::GetTransientChildren(window))
- ShowWithTransientChildrenRecursive(transient_child, animation_time);
- // We show all children which were not explicitly hidden.
- TransientWindowToVisibility::iterator it =
- transient_window_to_visibility_.find(window);
- if (it == transient_window_to_visibility_.end() || it->second)
- SetWindowVisible(window, true, animation_time);
- }
- aura::Window* MultiUserWindowManagerImpl::GetOwningWindowInTransientChain(
- aura::Window* window) const {
- if (!GetWindowOwner(window).empty())
- return nullptr;
- aura::Window* parent = ::wm::GetTransientParent(window);
- while (parent) {
- if (!GetWindowOwner(parent).empty())
- return parent;
- parent = ::wm::GetTransientParent(parent);
- }
- return nullptr;
- }
- void MultiUserWindowManagerImpl::AddTransientOwnerRecursive(
- aura::Window* window,
- aura::Window* owned_parent) {
- // First add all child windows.
- for (aura::Window* transient_child : ::wm::GetTransientChildren(window))
- AddTransientOwnerRecursive(transient_child, owned_parent);
- // If this window is the owned window, we do not have to handle it again.
- if (window == owned_parent)
- return;
- // Remember the current visibility.
- DCHECK(transient_window_to_visibility_.find(window) ==
- transient_window_to_visibility_.end());
- transient_window_to_visibility_[window] = window->IsVisible();
- // Add observers to track state changes.
- window->AddObserver(this);
- ::wm::TransientWindowManager::GetOrCreate(window)->AddObserver(this);
- // Hide the window if it should not be shown. Note that this hide operation
- // will hide recursively this and all children - but we have already collected
- // their initial view state.
- if (!IsWindowOnDesktopOfUser(owned_parent, current_account_id_))
- SetWindowVisibility(window, false, kAnimationTime);
- }
- void MultiUserWindowManagerImpl::RemoveTransientOwnerRecursive(
- aura::Window* window) {
- // First remove all child windows.
- for (aura::Window* transient_child : ::wm::GetTransientChildren(window))
- RemoveTransientOwnerRecursive(transient_child);
- // Find from transient window storage the visibility for the given window,
- // set the visibility accordingly and delete the window from the map.
- TransientWindowToVisibility::iterator visibility_item =
- transient_window_to_visibility_.find(window);
- DCHECK(visibility_item != transient_window_to_visibility_.end());
- window->RemoveObserver(this);
- ::wm::TransientWindowManager::GetOrCreate(window)->RemoveObserver(this);
- bool unowned_view_state = visibility_item->second;
- transient_window_to_visibility_.erase(visibility_item);
- if (unowned_view_state && !window->IsVisible() &&
- desks_util::BelongsToActiveDesk(window)) {
- // To prevent these commands from being recorded as any other commands, we
- // are suppressing any window entry changes while this is going on.
- // Instead of calling SetWindowVisible, only show gets called here since all
- // dependents have been shown previously already.
- base::AutoReset<bool> suppressor(&suppress_visibility_changes_, true);
- window->Show();
- }
- }
- void MultiUserWindowManagerImpl::SetWindowVisible(
- aura::Window* window,
- bool visible,
- base::TimeDelta animation_time) {
- // The TabletModeWindowManager will not handle invisible windows since they
- // are not user activatable. Since invisible windows are not being tracked,
- // we tell it to maximize / track this window now before it gets shown, to
- // reduce animation jank from multiple resizes.
- if (visible)
- Shell::Get()->tablet_mode_controller()->AddWindow(window);
- AnimationSetter animation_setter(window,
- GetAdjustedAnimationTime(animation_time));
- if (visible)
- window->Show();
- else
- window->Hide();
- }
- base::TimeDelta MultiUserWindowManagerImpl::GetAdjustedAnimationTime(
- base::TimeDelta default_time) const {
- return animation_speed_ == ANIMATION_SPEED_NORMAL
- ? default_time
- : (animation_speed_ == ANIMATION_SPEED_FAST
- ? base::Milliseconds(10)
- : base::TimeDelta());
- }
- // static
- std::unique_ptr<MultiUserWindowManager> MultiUserWindowManager::Create(
- MultiUserWindowManagerDelegate* delegate,
- const AccountId& account_id) {
- return std::make_unique<MultiUserWindowManagerImpl>(delegate, account_id);
- }
- } // namespace ash
|