blob: 2496ea52d60dd270879365505d0af3505064e5ac (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
|
// 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_
|
