| // 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_H_ |
| #define CHROME_BROWSER_UI_ASH_MULTI_USER_MULTI_USER_WINDOW_MANAGER_H_ |
| |
| #include <map> |
| #include <set> |
| #include <string> |
| |
| class Browser; |
| |
| namespace content { |
| class BrowserContext; |
| } |
| |
| namespace aura { |
| class Window; |
| } |
| |
| namespace chrome { |
| |
| class MultiUserWindowManagerChromeOS; |
| |
| // The MultiUserWindowManager manages windows from multiple users by presenting |
| // only user relevant windows to the current user. The manager is automatically |
| // determining the window ownership from browser and application windows and |
| // puts them onto the correct "desktop". |
| // Un-owned windows will be visible on all users desktop's and owned windows can |
| // only be presented on one desktop. If a window should get moved to another |
| // user's desktop |ShowWindowForUser| can be called. |
| // Windows which are neither a browser nor an app can be associated with a user |
| // through |SetWindowOwner|. |
| // This class will also switch the desktop upon user change. |
| // Note: |
| // - There is no need to "unregister" a window from an owner. The class will |
| // clean automatically all references of that window upon destruction. |
| // - User changes will be tracked via observer. No need to call. |
| // - All child windows will be owned by the same owner as its parent. |
| class MultiUserWindowManager { |
| public: |
| // Observer to notify of any window owner changes. |
| class Observer { |
| public: |
| // Invoked when the new window is created and the manager start to track its |
| // owner. |
| virtual void OnOwnerEntryAdded(aura::Window* window) {} |
| // Invoked when the owner of the window tracked by the manager is changed. |
| virtual void OnOwnerEntryChanged(aura::Window* window) {} |
| // Invoked when the window is destroyed and the manager stop to track its |
| // owner. |
| virtual void OnOwnerEntryRemoved(aura::Window* window) {} |
| |
| protected: |
| virtual ~Observer() {} |
| }; |
| |
| // The multi profile mode in use. |
| enum MultiProfileMode { |
| MULTI_PROFILE_MODE_UNINITIALIZED, // Not initialized yet. |
| MULTI_PROFILE_MODE_OFF, // Single user mode. |
| MULTI_PROFILE_MODE_SEPARATED, // Each user has his own desktop. |
| MULTI_PROFILE_MODE_MIXED // All users mix windows freely. |
| }; |
| |
| // Creates an instance of the MultiUserWindowManager. |
| // Note: This function might fail if due to the desired mode the |
| // MultiUserWindowManager is not required. |
| static MultiUserWindowManager* CreateInstance(); |
| |
| // Gets the instance of the object. If the multi profile mode is not enabled |
| // this will return NULL. |
| static MultiUserWindowManager* GetInstance(); |
| |
| // Return the current multi profile mode operation. If CreateInstance was not |
| // yet called (or was already destroyed), MULTI_PROFILE_MODE_UNINITIALIZED |
| // will get returned. |
| static MultiProfileMode GetMultiProfileMode(); |
| |
| // Whether or not the window's title should show the avatar. On chromeos, |
| // this is true when the owner of the window is different from the owner of |
| // the desktop. |
| static bool ShouldShowAvatar(aura::Window* window); |
| |
| // Removes the instance. |
| static void DeleteInstance(); |
| |
| // A function to set an |instance| of a created MultiUserWinwdowManager object |
| // with a given |mode| for test purposes. |
| static void SetInstanceForTest(MultiUserWindowManager* instance, |
| MultiProfileMode mode); |
| |
| // Assigns an owner to a passed window. Note that this window's parent should |
| // be a direct child of the root window. |
| // A user switch will automatically change the visibility - and - if the |
| // current user is not the owner it will immediately hidden. If the window |
| // had already be registered this function will run into a DCHECK violation. |
| virtual void SetWindowOwner( |
| aura::Window* window, const std::string& user_id) = 0; |
| |
| // See who owns this window. The return value is the user id or an empty |
| // string if not assigned yet. |
| virtual const std::string& GetWindowOwner(aura::Window* window) const = 0; |
| |
| // Allows to show an owned window for another users. If the window is not |
| // owned, this call will return immediately. (The FileManager for example |
| // might be available for every user and not belong explicitly to one). |
| // Note that a window can only be shown on one desktop at a time. Note that |
| // when the window gets minimized, it will automatically fall back to the |
| // owner's desktop. |
| virtual void ShowWindowForUser( |
| aura::Window* window, const std::string& user_id) = 0; |
| |
| // Returns true when windows are shared among users. |
| virtual bool AreWindowsSharedAmongUsers() const = 0; |
| |
| // Get the owners for the visible windows and set them to |user_ids|. |
| virtual void GetOwnersOfVisibleWindows( |
| std::set<std::string>* user_ids) const = 0; |
| |
| // A query call for a given window to see if it is on the given user's |
| // desktop. |
| virtual bool IsWindowOnDesktopOfUser(aura::Window* window, |
| const std::string& user_id) const = 0; |
| |
| // Get the user on which the window is currently shown. If an empty string is |
| // passed back the window will be presented for every user. |
| virtual const std::string& GetUserPresentingWindow( |
| aura::Window* window) const = 0; |
| |
| // Adds user to monitor starting and running V1/V2 application windows. |
| // Returns immediately if the user (identified by a |profile|) is already |
| // known to the manager. Note: This function is not implemented as a |
| // SessionStateObserver to coordinate the timing of the addition with other |
| // modules. |
| virtual void AddUser(content::BrowserContext* profile) = 0; |
| |
| // Manages observers. |
| virtual void AddObserver(Observer* observer) = 0; |
| virtual void RemoveObserver(Observer* observer) = 0; |
| |
| protected: |
| virtual ~MultiUserWindowManager() {} |
| |
| private: |
| // Caching the current multi profile mode since the detection is expensive. |
| static MultiProfileMode multi_user_mode_; |
| }; |
| |
| } // namespace chrome |
| |
| #endif // CHROME_BROWSER_UI_ASH_MULTI_USER_MULTI_USER_WINDOW_MANAGER_H_ |