Home | History | Annotate | Download | only in multi_user 
      1 // Copyright 2013 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #ifndef CHROME_BROWSER_UI_ASH_MULTI_USER_MULTI_USER_WINDOW_MANAGER_CHROMEOS_H_
      6 #define CHROME_BROWSER_UI_ASH_MULTI_USER_MULTI_USER_WINDOW_MANAGER_CHROMEOS_H_
      7 
      8 #include <map>
      9 #include <string>
     10 
     11 #include "ash/session/session_state_observer.h"
     12 #include "base/compiler_specific.h"
     13 #include "base/memory/scoped_ptr.h"
     14 #include "base/observer_list.h"
     15 #include "chrome/browser/ui/ash/multi_user/multi_user_window_manager.h"
     16 #include "content/public/browser/notification_observer.h"
     17 #include "content/public/browser/notification_registrar.h"
     18 #include "ui/aura/window_observer.h"
     19 #include "ui/wm/core/transient_window_observer.h"
     20 
     21 class Browser;
     22 class MultiUserNotificationBlockerChromeOS;
     23 class MultiUserNotificationBlockerChromeOSTest;
     24 
     25 namespace content {
     26 class BrowserContext;
     27 }
     28 
     29 namespace aura {
     30 class Window;
     31 }  // namespace aura
     32 
     33 namespace ash {
     34 namespace test {
     35 class MultiUserWindowManagerChromeOSTest;
     36 }  // namespace test
     37 }  // namespace ash
     38 
     39 namespace chrome {
     40 
     41 class AppObserver;
     42 class UserSwichAnimatorChromeOS;
     43 
     44 // This ChromeOS implementation of the MultiUserWindowManager interface is
     45 // detecting app and browser creations, tagging their windows automatically and
     46 // using (currently) show and hide to make the owned windows visible - or not.
     47 // If it becomes necessary, the function |SetWindowVisibility| can be
     48 // overwritten to match new ways of doing this.
     49 // Note:
     50 // - aura::Window::Hide() is currently hiding the window and all owned transient
     51 //   children. However aura::Window::Show() is only showing the window itself.
     52 //   To address that, all transient children (and their children) are remembered
     53 //   in |transient_window_to_visibility_| and monitored to keep track of the
     54 //   visibility changes from the owning user. This way the visibility can be
     55 //   changed back to its requested state upon showing by us - or when the window
     56 //   gets detached from its current owning parent.
     57 class MultiUserWindowManagerChromeOS
     58     : public MultiUserWindowManager,
     59       public ash::SessionStateObserver,
     60       public aura::WindowObserver,
     61       public content::NotificationObserver,
     62       public wm::TransientWindowObserver {
     63  public:
     64   // The speed which should be used to perform animations.
     65   enum AnimationSpeed {
     66     ANIMATION_SPEED_NORMAL,   // The normal animation speed.
     67     ANIMATION_SPEED_FAST,     // Unit test speed which test animations.
     68     ANIMATION_SPEED_DISABLED  // Unit tests which do not require animations.
     69   };
     70 
     71   // Create the manager and use |active_user_id| as the active user.
     72   explicit MultiUserWindowManagerChromeOS(const std::string& active_user_id);
     73   virtual ~MultiUserWindowManagerChromeOS();
     74 
     75   // MultiUserWindowManager overrides:
     76   virtual void SetWindowOwner(
     77       aura::Window* window, const std::string& user_id) OVERRIDE;
     78   virtual const std::string& GetWindowOwner(
     79       aura::Window* window) const OVERRIDE;
     80   virtual void ShowWindowForUser(
     81       aura::Window* window, const std::string& user_id) OVERRIDE;
     82   virtual bool AreWindowsSharedAmongUsers() const OVERRIDE;
     83   virtual void GetOwnersOfVisibleWindows(
     84       std::set<std::string>* user_ids) const OVERRIDE;
     85   virtual bool IsWindowOnDesktopOfUser(
     86       aura::Window* window,
     87       const std::string& user_id) const OVERRIDE;
     88   virtual const std::string& GetUserPresentingWindow(
     89       aura::Window* window) const OVERRIDE;
     90   virtual void AddUser(content::BrowserContext* context) OVERRIDE;
     91   virtual void AddObserver(Observer* observer) OVERRIDE;
     92   virtual void RemoveObserver(Observer* observer) OVERRIDE;
     93 
     94   // SessionStateObserver overrides:
     95   virtual void ActiveUserChanged(const std::string& user_id) OVERRIDE;
     96 
     97   // WindowObserver overrides:
     98   virtual void OnWindowDestroyed(aura::Window* window) OVERRIDE;
     99   virtual void OnWindowVisibilityChanging(aura::Window* window,
    100                                           bool visible) OVERRIDE;
    101   virtual void OnWindowVisibilityChanged(aura::Window* window,
    102                                          bool visible) OVERRIDE;
    103 
    104   // TransientWindowObserver overrides:
    105   virtual void OnTransientChildAdded(aura::Window* window,
    106                                      aura::Window* transient) OVERRIDE;
    107   virtual void OnTransientChildRemoved(aura::Window* window,
    108                                        aura::Window* transient) OVERRIDE;
    109 
    110   // content::NotificationObserver overrides:
    111   virtual void Observe(int type,
    112                const content::NotificationSource& source,
    113                const content::NotificationDetails& details) OVERRIDE;
    114 
    115   // Disable any animations for unit tests.
    116   void SetAnimationSpeedForTest(AnimationSpeed speed);
    117 
    118   // Returns true when a user switch animation is running. For unit tests.
    119   bool IsAnimationRunningForTest();
    120 
    121   // Returns the current user for unit tests.
    122   const std::string& GetCurrentUserForTest() const;
    123 
    124  protected:
    125   friend class UserSwichAnimatorChromeOS;
    126 
    127   class WindowEntry {
    128    public:
    129     explicit WindowEntry(const std::string& user_id)
    130         : owner_(user_id),
    131           show_for_user_(user_id),
    132           show_(true) {}
    133     virtual ~WindowEntry() {}
    134 
    135     // Returns the owner of this window. This cannot be changed.
    136     const std::string& owner() const { return owner_; }
    137 
    138     // Returns the user for which this should be shown.
    139     const std::string& show_for_user() const { return show_for_user_; }
    140 
    141     // Returns if the window should be shown for the "show user" or not.
    142     bool show() const { return show_; }
    143 
    144     // Set the user which will display the window on the owned desktop. If
    145     // an empty user id gets passed the owner will be used.
    146     void set_show_for_user(const std::string& user_id) {
    147       show_for_user_ = user_id.empty() ? owner_ : user_id;
    148     }
    149 
    150     // Sets if the window gets shown for the active user or not.
    151     void set_show(bool show) { show_ = show; }
    152 
    153    private:
    154     // The user id of the owner of this window.
    155     const std::string owner_;
    156 
    157     // The user id of the user on which desktop the window gets shown.
    158     std::string show_for_user_;
    159 
    160     // True if the window should be visible for the user which shows the window.
    161     bool show_;
    162 
    163     DISALLOW_COPY_AND_ASSIGN(WindowEntry);
    164   };
    165 
    166   typedef std::map<aura::Window*, WindowEntry*> WindowToEntryMap;
    167 
    168   // Show a window for a user without switching the user.
    169   // Returns true when the window moved to a new desktop.
    170   bool ShowWindowForUserIntern(aura::Window* window,
    171                                const std::string& user_id);
    172 
    173   // Show / hide the given window. Note: By not doing this within the functions,
    174   // this allows to either switching to different ways to show/hide and / or to
    175   // distinguish state changes performed by this class vs. state changes
    176   // performed by the others. Note furthermore that system modal dialogs will
    177   // not get hidden. We will switch instead to the owners desktop.
    178   // The |animation_time_in_ms| is the time the animation should take. Set to 0
    179   // if it should get set instantly.
    180   void SetWindowVisibility(aura::Window* window,
    181                            bool visible,
    182                            int animation_time_in_ms);
    183 
    184   const WindowToEntryMap& window_to_entry() { return window_to_entry_; }
    185   MultiUserNotificationBlockerChromeOS* notification_blocker() {
    186     return notification_blocker_.get();
    187   }
    188 
    189  private:
    190   friend class ::MultiUserNotificationBlockerChromeOSTest;
    191   friend class ash::test::MultiUserWindowManagerChromeOSTest;
    192 
    193   typedef std::map<std::string, AppObserver*> UserIDToAppWindowObserver;
    194   typedef std::map<aura::Window*, bool> TransientWindowToVisibility;
    195 
    196   // Add a browser window to the system so that the owner can be remembered.
    197   void AddBrowserWindow(Browser* browser);
    198 
    199   // Show the window and its transient children. However - if a transient child
    200   // was turned invisible by some other operation, it will stay invisible.
    201   // Use the given |animation_time_in_ms| for transitioning.
    202   void ShowWithTransientChildrenRecursive(aura::Window* window,
    203                                           int animation_time_in_ms);
    204 
    205   // Find the first owned window in the chain.
    206   // Returns NULL when the window itself is owned.
    207   aura::Window* GetOwningWindowInTransientChain(aura::Window* window) const;
    208 
    209   // A |window| and its children were attached as transient children to an
    210   // |owning_parent| and need to be registered. Note that the |owning_parent|
    211   // itself will not be registered, but its children will.
    212   void AddTransientOwnerRecursive(aura::Window* window,
    213                                   aura::Window* owning_parent);
    214 
    215   // A window and its children were removed from its parent and can be
    216   // unregistered.
    217   void RemoveTransientOwnerRecursive(aura::Window* window);
    218 
    219   // Animate a |window| to be |visible| in |animation_time_in_ms|.
    220   void SetWindowVisible(aura::Window* window,
    221                         bool visible,
    222                         int aimation_time_in_ms);
    223 
    224   // Get the animation time in milliseconds dependent on the |AnimationSpeed|
    225   // from the passed |default_time_in_ms|.
    226   int GetAdjustedAnimationTimeInMS(int default_time_in_ms) const;
    227 
    228   // A lookup to see to which user the given window belongs to, where and if it
    229   // should get shown.
    230   WindowToEntryMap window_to_entry_;
    231 
    232   // A list of all known users and their app window observers.
    233   UserIDToAppWindowObserver user_id_to_app_observer_;
    234 
    235   // An observer list to be notified upon window owner changes.
    236   ObserverList<Observer> observers_;
    237 
    238   // A map which remembers for owned transient windows their own visibility.
    239   TransientWindowToVisibility transient_window_to_visibility_;
    240 
    241   // The currently selected active user. It is used to find the proper
    242   // visibility state in various cases. The state is stored here instead of
    243   // being read from the user manager to be in sync while a switch occurs.
    244   std::string current_user_id_;
    245 
    246   // The blocker which controls the desktop notification visibility based on the
    247   // current multi-user status.
    248   scoped_ptr<MultiUserNotificationBlockerChromeOS> notification_blocker_;
    249 
    250   // The notification registrar to track the creation of browser windows.
    251   content::NotificationRegistrar registrar_;
    252 
    253   // Suppress changes to the visibility flag while we are changing it ourselves.
    254   bool suppress_visibility_changes_;
    255 
    256   // Caching the current multi profile mode since the detection which mode is
    257   // used is quite expensive.
    258   static MultiProfileMode multi_user_mode_;
    259 
    260   // The speed which is used to perform any animations.
    261   AnimationSpeed animation_speed_;
    262 
    263   // The animation between users.
    264   scoped_ptr<UserSwichAnimatorChromeOS> animation_;
    265 
    266   DISALLOW_COPY_AND_ASSIGN(MultiUserWindowManagerChromeOS);
    267 };
    268 
    269 }  // namespace chrome
    270 
    271 #endif  // CHROME_BROWSER_UI_ASH_MULTI_USER_MULTI_USER_WINDOW_MANAGER_CHROMEOS_H_
    272