Creating multi profile animations for switching users and teleporting of windows.

chrome/browser/ui/ash/multi_user/multi_user_window_manager_chromeos.cc

 // 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 "chrome/browser/ui/ash/multi_user/multi_user_window_manager_chromeos.h"
 
 #include "apps/shell_window.h"
 #include "apps/shell_window_registry.h"
 #include "ash/ash_switches.h"
+#include "ash/desktop_background/user_wallpaper_delegate.h"
 #include "ash/multi_profile_uma.h"
+#include "ash/root_window_controller.h"
 #include "ash/session_state_delegate.h"
+#include "ash/shelf/shelf.h"
+#include "ash/shelf/shelf_layout_manager.h"
 #include "ash/shell.h"
 #include "ash/shell_delegate.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/mru_window_tracker.h"
 #include "ash/wm/window_positioner.h"
 #include "ash/wm/window_state.h"
 #include "base/auto_reset.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_util.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/login/user_manager.h"
+#include "chrome/browser/chromeos/login/wallpaper_manager.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
+#include "chrome/browser/ui/ash/launcher/chrome_launcher_controller.h"
 #include "chrome/browser/ui/ash/multi_user/multi_user_notification_blocker_chromeos.h"
 #include "chrome/browser/ui/ash/multi_user/multi_user_util.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "content/public/browser/notification_service.h"
 #include "google_apis/gaia/gaia_auth_util.h"
 #include "ui/aura/client/activation_client.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
 #include "ui/base/ui_base_types.h"
 #include "ui/events/event.h"
 #include "ui/message_center/message_center.h"
 #include "ui/views/corewm/transient_window_manager.h"
+#include "ui/views/corewm/window_animations.h"
 #include "ui/views/corewm/window_util.h"
 
 namespace {
 
+// The animation time in milliseconds for a single window which is fading
+// in / out.
+static int kAnimationTimeMS = 100;
+
+// The animation time in millseconds for the fade in and / or out when switching
+// users.
+static int kUserFadeTimeMS = 110;
+
+// The animation time in ms for a window which get teleported to another screen.
+static int kTeleportAnimationTimeMS = 300;
+
 // Checks if a given event is a user event.
 bool IsUserEvent(ui::Event* e) {
   if (e) {
     ui::EventType type = e->type();
     if (type != ui::ET_CANCEL_MODE &&
         type != ui::ET_UMA_DATA &&
         type != ui::ET_UNKNOWN)
       return true;
   }
   return false;
@@ skipping 69 matching lines @@
       }
     }
   }
   ash::MultiProfileUMA::RecordTeleportWindowType(window_type);
 }
 
 }  // namespace
 
 namespace chrome {
 
+// A class to temporarily change the animation properties for a window.
+class AnimationSetter {
+ public:
+  AnimationSetter(aura::Window* window, int animation_time_in_ms)
+      : window_(window),
+        previous_animation_type_(
+            views::corewm::GetWindowVisibilityAnimationType(window_)),
+        previous_animation_time_(
+            views::corewm::GetWindowVisibilityAnimationDuration(*window_)) {
+    views::corewm::SetWindowVisibilityAnimationType(
+        window_,
+        views::corewm::WINDOW_VISIBILITY_ANIMATION_TYPE_FADE);
+    views::corewm::SetWindowVisibilityAnimationDuration(
+        window_,
+        base::TimeDelta::FromMilliseconds(animation_time_in_ms));
+  }
+
+  ~AnimationSetter() {
+    views::corewm::SetWindowVisibilityAnimationType(window_,
+                                                    previous_animation_type_);
+    views::corewm::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_;
+
+  DISALLOW_COPY_AND_ASSIGN(AnimationSetter);
+};
+
 // logic while the user gets switched.
 class UserChangeActionDisabler {
  public:
   UserChangeActionDisabler() {
     ash::WindowPositioner::DisableAutoPositioning(true);
     ash::Shell::GetInstance()->mru_window_tracker()->SetIgnoreActivations(true);
   }
 
   ~UserChangeActionDisabler() {
     ash::WindowPositioner::DisableAutoPositioning(false);
@@ skipping 30 matching lines @@
   std::string user_id_;
 
   DISALLOW_COPY_AND_ASSIGN(AppObserver);
 };
 
 MultiUserWindowManagerChromeOS::MultiUserWindowManagerChromeOS(
     const std::string& current_user_id)
     : current_user_id_(current_user_id),
       notification_blocker_(new MultiUserNotificationBlockerChromeOS(
           message_center::MessageCenter::Get(), this)),
-      suppress_visibility_changes_(false) {
+      suppress_visibility_changes_(false),
+      animations_disabled_(false) {
   // Add a session state observer to be able to monitor session changes.
   if (ash::Shell::HasInstance())
     ash::Shell::GetInstance()->session_state_delegate()->
         AddSessionStateObserver(this);
 
   // The BrowserListObserver would have been better to use then the old
   // notification system, but that observer fires before the window got created.
   registrar_.Add(this, NOTIFICATION_BROWSER_WINDOW_READY,
                  content::NotificationService::AllSources());
 
@@ skipping 57 matching lines @@
   // 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);
 
   // Right now only |notification_blocker_| needs to know when the list of
   // owners may change.
   // TODO(skuhne): replace this by observer when another one needs this event.
   notification_blocker_->UpdateWindowOwners();
 
   if (!IsWindowOnDesktopOfUser(window, current_user_id_))
-    SetWindowVisibility(window, false);
+    SetWindowVisibility(window, false, 0);
 }
 
 const std::string& MultiUserWindowManagerChromeOS::GetWindowOwner(
     aura::Window* window) {
   WindowToEntryMap::iterator it = window_to_entry_.find(window);
   return it != window_to_entry_.end() ? it->second->owner()
                                       : base::EmptyString();
 }
 
 void MultiUserWindowManagerChromeOS::ShowWindowForUser(
@@ skipping 21 matching lines @@
     RecordUMAForTransferredWindowType(window);
   }
 
   WindowToEntryMap::iterator it = window_to_entry_.find(window);
   it->second->set_show_for_user(user_id);
 
   // Show the window if the added user is the current one.
   if (user_id == current_user_id_) {
     // Only show the window if it should be shown according to its state.
     if (it->second->show())
-      SetWindowVisibility(window, true);
+      SetWindowVisibility(window, true, kTeleportAnimationTimeMS);
   } else {
-    SetWindowVisibility(window, false);
+    SetWindowVisibility(window, false, kTeleportAnimationTimeMS);
   }
 
   // TODO(skuhne): replace this by observer when another one needs this event.
   notification_blocker_->UpdateWindowOwners();
 }
 
 bool MultiUserWindowManagerChromeOS::AreWindowsSharedAmongUsers() {
   WindowToEntryMap::iterator it = window_to_entry_.begin();
   for (; it != window_to_entry_.end(); ++it) {
     if (it->second->owner() != it->second->show_for_user())
@@ skipping 51 matching lines @@
   BrowserList::const_iterator browser_it = browser_list->begin();
   for (; browser_it != browser_list->end(); ++browser_it) {
     if ((*browser_it)->profile()->GetOriginalProfile() == profile)
       AddBrowserWindow(*browser_it);
   }
 }
 
 void MultiUserWindowManagerChromeOS::ActiveUserChanged(
     const std::string& user_id) {
   DCHECK(user_id != current_user_id_);
-  std::string old_user = current_user_id_;
   current_user_id_ = user_id;
-  // Disable the window position manager and the MRU window tracker temporarily.
-  scoped_ptr<UserChangeActionDisabler> disabler(new UserChangeActionDisabler);
+  // If there is an animation in progress finish the pending switch which also
+  // kills the timer (if there is one).
+  if (user_changed_animation_timer_.get())
+    TransitionUser(SHOW_NEW_USER);
 
-  // We need to show/hide the windows in the same order as they were created in
-  // their parent window(s) to keep the layer / window hierarchy in sync. To
-  // achieve that we first collect all parent windows and then enumerate all
-  // windows in those parent windows and show or hide them accordingly.
+  // Start the animation by hiding the old user.
+  TransitionUser(HIDE_OLD_USER);
 
-  // Create a list of all parent windows we have to check and their parents.
-  std::set<aura::Window*> parent_list;
-  for (WindowToEntryMap::iterator it = window_to_entry_.begin();
-       it != window_to_entry_.end(); ++it) {
-    aura::Window* parent = it->first->parent();
-    if (parent_list.find(parent) == parent_list.end())
-      parent_list.insert(parent);
+  // If animations are disabled we immediately switch to the new user, otherwise
+  // we create a timer which will fade in the new user once the other user has
+  // been faded away.
+  if (animations_disabled_) {
+    TransitionUser(SHOW_NEW_USER);
+  } else {
+    user_changed_animation_timer_.reset(new base::Timer(
+        FROM_HERE,
+        base::TimeDelta::FromMilliseconds(kUserFadeTimeMS),
+        base::Bind(&MultiUserWindowManagerChromeOS::TransitionUser,
+                   base::Unretained(this),
+                   SHOW_NEW_USER),
+        false));
+    user_changed_animation_timer_->Reset();
   }
-
-  // Traverse the found parent windows to handle their child windows in order of
-  // their appearance.
-  for (std::set<aura::Window*>::iterator it_parents = parent_list.begin();
-       it_parents != parent_list.end(); ++it_parents) {
-    const aura::Window::Windows window_list = (*it_parents)->children();
-    for (aura::Window::Windows::const_iterator it_window = window_list.begin();
-         it_window != window_list.end(); ++it_window) {
-      aura::Window* window = *it_window;
-      WindowToEntryMap::iterator it_map = window_to_entry_.find(window);
-      if (it_map != window_to_entry_.end()) {
-        bool should_be_visible = it_map->second->show_for_user() == user_id &&
-                                 it_map->second->show();
-        bool is_visible = window->IsVisible();
-        if (should_be_visible != is_visible)
-          SetWindowVisibility(window, should_be_visible);
-      }
-    }
-  }
-
-  // Finally we need to restore the previously active window.
-  ash::MruWindowTracker::WindowList mru_list =
-      ash::Shell::GetInstance()->mru_window_tracker()->BuildMruWindowList();
-  if (mru_list.size()) {
-    aura::Window* window = mru_list[0];
-    ash::wm::WindowState* window_state = ash::wm::GetWindowState(window);
-    if (IsWindowOnDesktopOfUser(window, user_id) &&
-        !window_state->IsMinimized()) {
-      aura::client::ActivationClient* client =
-          aura::client::GetActivationClient(window->GetRootWindow());
-      // Several unit tests come here without an activation client.
-      if (client)
-        client->ActivateWindow(window);
-    }
-  }
-
-  // This is called directly here to make sure notification_blocker will see the
-  // new window status.
-  notification_blocker_->ActiveUserChanged(user_id);
 }
 
 void MultiUserWindowManagerChromeOS::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;
   }
   ash::wm::GetWindowState(window)->RemoveObserver(this);
@@ skipping 29 matching lines @@
   }
 }
 
 void MultiUserWindowManagerChromeOS::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_user_id_)) {
-    SetWindowVisibility(window, false);
+    SetWindowVisibility(window, false, 0);
     return;
   }
   aura::Window* owned_parent = GetOwningWindowInTransientChain(window);
   if (owned_parent && owned_parent != window && visible &&
       !IsWindowOnDesktopOfUser(owned_parent, current_user_id_))
-    SetWindowVisibility(window, false);
+    SetWindowVisibility(window, false, 0);
 }
 
 void MultiUserWindowManagerChromeOS::OnTransientChildAdded(
     aura::Window* window,
     aura::Window* transient_window) {
   if (!GetWindowOwner(window).empty()) {
     AddTransientOwnerRecursive(transient_window, window);
     return;
   }
   aura::Window* owned_parent =
@@ skipping 28 matching lines @@
 }
 
 void MultiUserWindowManagerChromeOS::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   if (type == NOTIFICATION_BROWSER_WINDOW_READY)
     AddBrowserWindow(content::Source<Browser>(source).ptr());
 }
 
+void MultiUserWindowManagerChromeOS::SetAnimationsForTest(bool disable) {
+  animations_disabled_ = disable;
+}
+
+bool MultiUserWindowManagerChromeOS::IsAnimationRunningForTest() {
+  return user_changed_animation_timer_.get() != NULL;
+}
+
+void MultiUserWindowManagerChromeOS::TransitionUser(
+    MultiUserWindowManagerChromeOS::AnimationStep animation_step) {
+  TransitionWallpaper(animation_step);
+  TransitionUserShelf(animation_step);
+
+  // Disable the window position manager and the MRU window tracker temporarily.
+  scoped_ptr<UserChangeActionDisabler> disabler(new UserChangeActionDisabler);
+
+  // We need to show/hide the windows in the same order as they were created in
+  // their parent window(s) to keep the layer / window hierarchy in sync. To
+  // achieve that we first collect all parent windows and then enumerate all
+  // windows in those parent windows and show or hide them accordingly.
+
+  // Create a list of all parent windows we have to check and their parents.
+  std::set<aura::Window*> parent_list;
+  for (WindowToEntryMap::iterator it = window_to_entry_.begin();
+       it != window_to_entry_.end(); ++it) {
+    aura::Window* parent = it->first->parent();
+    if (parent_list.find(parent) == parent_list.end())
+      parent_list.insert(parent);
+  }
+
+  // Traverse the found parent windows to handle their child windows in order of
+  // their appearance.
+  for (std::set<aura::Window*>::iterator it_parents = parent_list.begin();
+       it_parents != parent_list.end(); ++it_parents) {
+    const aura::Window::Windows window_list = (*it_parents)->children();
+    for (aura::Window::Windows::const_iterator it_window = window_list.begin();
+         it_window != window_list.end(); ++it_window) {
+      aura::Window* window = *it_window;
+      WindowToEntryMap::iterator it_map = window_to_entry_.find(window);
+      if (it_map != window_to_entry_.end()) {
+        bool should_be_visible =
+            it_map->second->show_for_user() == current_user_id_ &&
+            it_map->second->show();
+        bool is_visible = window->IsVisible();
+        if (should_be_visible != is_visible &&
+            should_be_visible == (animation_step == SHOW_NEW_USER))
+          SetWindowVisibility(window, should_be_visible, kUserFadeTimeMS);
+      }
+    }
+  }
+
+  // Activation and real switch are happening after the other user gets shown.
+  if (animation_step == SHOW_NEW_USER) {
+    // Finally we need to restore the previously active window.
+    ash::MruWindowTracker::WindowList mru_list =
+        ash::Shell::GetInstance()->mru_window_tracker()->BuildMruWindowList();
+    if (mru_list.size()) {
+      aura::Window* window = mru_list[0];
+      ash::wm::WindowState* window_state = ash::wm::GetWindowState(window);
+      if (IsWindowOnDesktopOfUser(window, current_user_id_) &&
+          !window_state->IsMinimized()) {
+        aura::client::ActivationClient* client =
+            aura::client::GetActivationClient(window->GetRootWindow());
+        // Several unit tests come here without an activation client.
+        if (client)
+          client->ActivateWindow(window);
+      }
+    }
+
+    // This is called directly here to make sure notification_blocker will see
+    // the new window status.
+    notification_blocker_->ActiveUserChanged(current_user_id_);
+
+    // We can reset the timer at this point.
+    // Note: The timer can be destroyed while it is performing its task.
+    user_changed_animation_timer_.reset();
+  }
+}
+
+void MultiUserWindowManagerChromeOS::TransitionWallpaper(
+    MultiUserWindowManagerChromeOS::AnimationStep animation_step) {
+  // Handle the wallpaper switch.
+  if (chromeos::WallpaperManager::Get()) {
+    ash::UserWallpaperDelegate* wallpaper_delegate =
+        ash::Shell::GetInstance()->user_wallpaper_delegate();
+    if (animation_step == HIDE_OLD_USER) {
+      // Set the wallpaper cross dissolve animation duration to our complete
+      // animation cycle for a fade in and fade out.
+      wallpaper_delegate->SetAnimationDurationOverride(2 * kUserFadeTimeMS);
+      chromeos::WallpaperManager::Get()->SetUserWallpaperDelayed(
+          current_user_id_);
+    } else {
+      // Revert the wallpaper cross dissolve animation duration back to the
+      // default.
+      wallpaper_delegate->SetAnimationDurationOverride(0);
+    }
+  }
+}
+
+void MultiUserWindowManagerChromeOS::TransitionUserShelf(
+    MultiUserWindowManagerChromeOS::AnimationStep animation_step) {
+  // The shelf animation duration override.
+  int duration_override = kUserFadeTimeMS;
+  // Handle the shelf order of items. This is done once the old user is hidden.
+  if (animation_step == SHOW_NEW_USER) {
+    // Some unit tests have no ChromeLauncherController.
+    if (ChromeLauncherController::instance())
+      ChromeLauncherController::instance()->ActiveUserChanged(current_user_id_);
+    // We kicked off the shelf animation in the command above. As such we can
+    // disable the override now again.
+    duration_override = 0;
+  }
+
+  if (animations_disabled_)
+    return;
+
+  ash::Shell::RootWindowControllerList controller =
+      ash::Shell::GetInstance()->GetAllRootWindowControllers();
+  for (ash::Shell::RootWindowControllerList::iterator it1 = controller.begin();
+       it1 != controller.end(); ++it1) {
+    (*it1)->GetShelfLayoutManager()->SetAnimationDurationOverride(
+        duration_override);
+  }
+
+  // For each root window hide the shelf.
+  if (animation_step == HIDE_OLD_USER) {
+    aura::Window::Windows root_windows = ash::Shell::GetAllRootWindows();
+    for (aura::Window::Windows::const_iterator iter = root_windows.begin();
+         iter != root_windows.end(); ++iter) {
+      ash::Shell::GetInstance()->SetShelfAutoHideBehavior(
+          ash::SHELF_AUTO_HIDE_ALWAYS_HIDDEN, *iter);
+    }
+  }
+}
+
 void MultiUserWindowManagerChromeOS::AddBrowserWindow(Browser* browser) {
   // A unit test (e.g. CrashRestoreComplexTest.RestoreSessionForThreeUsers) can
   // come here with no valid window.
   if (!browser->window() || !browser->window()->GetNativeWindow())
     return;
   SetWindowOwner(browser->window()->GetNativeWindow(),
                  multi_user_util::GetUserIDFromProfile(browser->profile()));
 }
 
 void MultiUserWindowManagerChromeOS::SetWindowVisibility(
-    aura::Window* window, bool visible) {
+    aura::Window* window, bool visible, int animation_time_in_ms) {
   if (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()) {
     // Get the system modal container for the window's root window.
     aura::Window* system_modal_container =
@@ skipping 13 matching lines @@
           user_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);
+    ShowWithTransientChildrenRecursive(window, animation_time_in_ms);
   } else {
     if (window->HasFocus())
       window->Blur();
-    window->Hide();
+    SetWindowVisible(window, false, animation_time_in_ms);
   }
 }
 
 void MultiUserWindowManagerChromeOS::ShowWithTransientChildrenRecursive(
-    aura::Window* window) {
+    aura::Window* window, int animation_time_in_ms) {
   aura::Window::Windows::const_iterator it =
       views::corewm::GetTransientChildren(window).begin();
   for (; it != views::corewm::GetTransientChildren(window).end(); ++it)
-    ShowWithTransientChildrenRecursive(*it);
+    ShowWithTransientChildrenRecursive(*it, animation_time_in_ms);
 
   // We show all children which were not explicitly hidden.
   TransientWindowToVisibility::iterator it2 =
       transient_window_to_visibility_.find(window);
   if (it2 == transient_window_to_visibility_.end() || it2->second)
-    window->Show();
+    SetWindowVisible(window, true, animation_time_in_ms);
 }
 
 aura::Window* MultiUserWindowManagerChromeOS::GetOwningWindowInTransientChain(
     aura::Window* window) {
   if (!GetWindowOwner(window).empty())
     return NULL;
   aura::Window* parent = views::corewm::GetTransientParent(window);
   while (parent) {
     if (!GetWindowOwner(parent).empty())
       return parent;
@@ skipping 21 matching lines @@
   transient_window_to_visibility_[window] = window->IsVisible();
 
   // Add observers to track state changes.
   window->AddObserver(this);
   views::corewm::TransientWindowManager::Get(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_user_id_))
-    SetWindowVisibility(window, false);
+    SetWindowVisibility(window, false, kAnimationTimeMS);
 }
 
 void MultiUserWindowManagerChromeOS::RemoveTransientOwnerRecursive(
     aura::Window* window) {
   // First remove all child windows.
   aura::Window::Windows::const_iterator it =
       views::corewm::GetTransientChildren(window).begin();
   for (; it != views::corewm::GetTransientChildren(window).end(); ++it)
     RemoveTransientOwnerRecursive(*it);
 
@@ skipping 11 matching lines @@
   if (unowned_view_state && !window->IsVisible()) {
     // 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 MultiUserWindowManagerChromeOS::SetWindowVisible(
+    aura::Window* window,
+    bool visible,
+    int animation_time_in_ms) {
+  AnimationSetter animation_setter(
+      window,
+      animations_disabled_ ? 0 : animation_time_in_ms);
+
+  if (visible)
+    window->Show();
+  else
+    window->Hide();
+
+  // Make sure that animations have no influence on the window state after the
+  // call.
+  DCHECK_EQ(visible, window->IsVisible());
+}
+
 }  // namespace chrome