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

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

 // 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.
 
 #ifndef CHROME_BROWSER_UI_ASH_MULTI_USER_MULTI_USER_WINDOW_MANAGER_CHROMEOS_H_
 #define CHROME_BROWSER_UI_ASH_MULTI_USER_MULTI_USER_WINDOW_MANAGER_CHROMEOS_H_
 
 #include <map>
 #include <string>
 
 #include "ash/session_state_observer.h"
 #include "ash/wm/window_state_observer.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/timer/timer.h"
 #include "chrome/browser/ui/ash/multi_user/multi_user_window_manager.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "ui/aura/window_observer.h"
 #include "ui/views/corewm/transient_window_observer.h"
 
 class Browser;
 class MultiUserNotificationBlockerChromeOS;
 class MultiUserNotificationBlockerChromeOSTest;
 class Profile;
@@ skipping 66 matching lines @@
   // Window .. overrides:
   virtual void OnWindowShowTypeChanged(
       ash::wm::WindowState* state,
       ash::wm::WindowShowType old_type) OVERRIDE;
 
   // content::NotificationObserver overrides:
   virtual void Observe(int type,
                const content::NotificationSource& source,
                const content::NotificationDetails& details) OVERRIDE;
 
+  // Disable any animations for unit tests.
+  void SetAnimationsForTest(bool disable);
+
+  // Returns true when a user switch animation is running. For unit tests.
+  bool IsAnimationRunningForTest();
+
  private:
   friend class ::MultiUserNotificationBlockerChromeOSTest;
 
   class WindowEntry {
    public:
     explicit WindowEntry(const std::string& user_id)
         : owner_(user_id),
           show_for_user_(user_id),
           show_(true) {}
     virtual ~WindowEntry() {}
@@ skipping 26 matching lines @@
     // True if the window should be visible for the user which shows the window.
     bool show_;
 
     DISALLOW_COPY_AND_ASSIGN(WindowEntry);
   };
 
   typedef std::map<aura::Window*, WindowEntry*> WindowToEntryMap;
   typedef std::map<std::string, AppObserver*> UserIDToShellWindowObserver;
   typedef std::map<aura::Window*, bool> TransientWindowToVisibility;
 
+  // The animation step for the user change animation. First the old user gets
+  // hidden and then the new one gets presented.
+  enum AnimationStep {
+    HIDE_OLD_USER,
+    SHOW_NEW_USER
+  };
+
+  // Start the user change animation required for |animation_step|.
+  // Note that a call with SHOW_NEW_USER will finalize the animation and kill
+  // the timer (if there is one).
+  void TransitionUser(AnimationStep animtion_step);
+
+  // Start the user wallpaper animations.
+  void TransitionWallpaper(AnimationStep animtion_step);
+
+  // Start the user shelf animations.
+  void TransitionUserShelf(AnimationStep animtion_step);
+
   // Add a browser window to the system so that the owner can be remembered.
   void AddBrowserWindow(Browser* browser);
 
   // Show / hide the given window. Note: By not doing this within the functions,
   // this allows to either switching to different ways to show/hide and / or to
   // distinguish state changes performed by this class vs. state changes
   // performed by the others. Note furthermore that system modal dialogs will
   // not get hidden. We will switch instead to the owners desktop.
-  void SetWindowVisibility(aura::Window* window, bool visible);
+  // The |animation_time_in_ms| is the time the animation should take. Set to 0
+  // if it should get set instantly.
+  void SetWindowVisibility(aura::Window* window,
+                           bool visible,
+                           int animation_time_in_ms);
 
   // Show the window and its transient children. However - if a transient child
   // was turned invisible by some other operation, it will stay invisible.
-  void ShowWithTransientChildrenRecursive(aura::Window* window);
+  // Use the given |animation_time_in_ms| for transitioning.
+  void ShowWithTransientChildrenRecursive(aura::Window* window,
+                                          int animation_time_in_ms);
 
   // Find the first owned window in the chain.
   // Returns NULL when the window itself is owned.
   aura::Window* GetOwningWindowInTransientChain(aura::Window* window);
 
   // A |window| and its children were attached as transient children to an
   // |owning_parent| and need to be registered. Note that the |owning_parent|
   // itself will not be registered, but its children will.
   void AddTransientOwnerRecursive(aura::Window* window,
                                   aura::Window* owning_parent);
 
   // A window and its children were removed from its parent and can be
   // unregistered.
   void RemoveTransientOwnerRecursive(aura::Window* window);
 
+  // Animate a |window| to be |visible| in |animation_time_in_ms|.
+  void SetWindowVisible(aura::Window* window,
+                        bool visible,
+                        int aimation_time_in_ms);
+
   // A lookup to see to which user the given window belongs to, where and if it
   // should get shown.
   WindowToEntryMap window_to_entry_;
 
   // A list of all known users and their shell window observers.
   UserIDToShellWindowObserver user_id_to_app_observer_;
 
   // A map which remembers for owned transient windows their own visibility.
   TransientWindowToVisibility transient_window_to_visibility_;
 
   // The currently selected active user. It is used to find the proper
   // visibility state in various cases. The state is stored here instead of
   // being read from the user manager to be in sync while a switch occurs.
   std::string current_user_id_;
 
   // The blocker which controls the desktop notification visibility based on the
   // current multi-user status.
   scoped_ptr<MultiUserNotificationBlockerChromeOS> notification_blocker_;
 
   // The notification registrar to track the creation of browser windows.
   content::NotificationRegistrar registrar_;
 
   // Suppress changes to the visibility flag while we are changing it ourselves.
   bool suppress_visibility_changes_;
 
   // Caching the current multi profile mode since the detection which mode is
   // used is quite expensive.
   static MultiProfileMode multi_user_mode_;
 
+  // A timer which watches to executes the second part of a "user changed"
+  // animation. Note that this timer exists only during such an animation.
+  scoped_ptr<base::Timer> user_changed_animation_timer_;
+
+  // If true, all animations will be suppressed.
+  bool animations_disabled_;
+
   DISALLOW_COPY_AND_ASSIGN(MultiUserWindowManagerChromeOS);
 };
 
 }  // namespace chrome
 
 #endif  // CHROME_BROWSER_UI_ASH_MULTI_USER_MULTI_USER_WINDOW_MANAGER_CHROMEOS_H_