Improving the user transition to add special cases for maximized windows and make the transition "m…

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>
 
@@ skipping 94 matching lines @@
 
   // Disable any animations for unit tests.
   void SetAnimationsForTest(bool disable);
 
   // Returns true when a user switch animation is running. For unit tests.
   bool IsAnimationRunningForTest();
 
   // Returns the current user for unit tests.
   const std::string& GetCurrentUserForTest();
 
+  // Returns the user id for which the wallpaper is currently shown.
+  // If a wallpaper is transitioning from A to B it will be returned as
+  // "A->B".
+  const std::string& GetWallaperUserIdForTest() { return wallpaper_user_id_; }
+
  private:
   friend class ::MultiUserNotificationBlockerChromeOSTest;
   friend class ash::test::MultiUserWindowManagerChromeOSTest;
 
   class WindowEntry {
    public:
     explicit WindowEntry(const std::string& user_id)
         : owner_(user_id),
           show_for_user_(user_id),
           show_(true) {}
@@ skipping 27 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*> UserIDToAppWindowObserver;
   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.
+  // The animation step for the user change animation.
   enum AnimationStep {
-    HIDE_OLD_USER,
-    SHOW_NEW_USER
+    ANIMATION_STEP_HIDE_OLD_USER,  // Hiding the old user (and shelf).
+    ANIMATION_STEP_SHOW_NEW_USER,  // Show the shelf of the new user.
+    ANIMATION_STEP_FINALIZE,       // All animations are done - final cleanup.
+    ANIMATION_STEP_ENDED           // The animation has ended.
+  };

[oshima, 2014/04/03 19:21:41]

I like this design.

+
+  // The window configuration of screen covering windows before an animation.
+  enum TransitioningScreenCover {
+    NO_USER_COVERS_SCREEN,   // No window covers the entire screen.
+    OLD_USER_COVERS_SCREEN,  // The current user has at least one window
+                             // covering the entire screen.
+    NEW_USER_COVERS_SCREEN,  // The user which becomes active has at least one
+                             // window covering the entire screen.
+    BOTH_USERS_COVER_SCREEN  // Both users have at least one window each
+                             // covering the entire screen.
   };
 
   // Show a window for a user without switching the user.
   // Returns true when the window moved to a new desktop.
   bool ShowWindowForUserIntern(aura::Window* window,
                                const std::string& user_id);
 
-  // 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.
   // The |animation_time_in_ms| is the time the animation should take. Set to 0
   // if it should get set instantly.
@@ skipping 19 matching lines @@
 
   // 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);
 
+  // Start a transition animation for the current user to the new |user_id|.
+  // Any ongoing transition animations get automatically finished first.
+  void StartUserTransitionAnimation(const std::string& user_id);
+
+  // Advances the user switch animation to the next step. It reads the current
+  // step from |animation_step_| and increments it thereafter. When
+  // |ANIMATION_STEP_FINALIZE| gets executed, the animation is finished and the
+  // timer (if one exists) will get destroyed.
+  void AdvanceUserTransitionAnimation();
+
+  // Execute the user wallpaper animations for |animation_step|.
+  void TransitionWallpaper(AnimationStep animtion_step);
+
+  // Execute the user shelf animations for |animation_step|.
+  void TransitionUserShelf(AnimationStep animtion_step);
+
+  // Execute the window animations for |animation_step|.
+  void TransitionWindows(AnimationStep animation_step);
+
+  // Check if a window is maximized / fullscreen / covering the entire screen.
+  // TODO(skuhne): We might want to do this on a per screen basis.
+  TransitioningScreenCover GetScreenCover();
+
+  // Check if a window is covering the entire work area of the screen it is on.
+  bool CoversScreen(aura::Window* window);
+
   // 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 app window observers.
   UserIDToAppWindowObserver user_id_to_app_observer_;
 
   // An observer list to be notified upon window owner changes.
   ObserverList<Observer> observers_;
 
@@ skipping 16 matching lines @@
   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_;
 
+  // The screen cover status before the animation has started.
+  TransitioningScreenCover screen_cover_;
+
+  // The next animation step for AdvanceUserTransitionAnimation().
+  AnimationStep animation_step_;
+
   // If true, all animations will be suppressed.
   bool animations_disabled_;
 
+  // For unit tests: Check which wallpaper was set.
+  std::string wallpaper_user_id_;
+
   DISALLOW_COPY_AND_ASSIGN(MultiUserWindowManagerChromeOS);
 };
 
 }  // namespace chrome
 
 #endif  // CHROME_BROWSER_UI_ASH_MULTI_USER_MULTI_USER_WINDOW_MANAGER_CHROMEOS_H_