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
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
|
// Copyright (c) 2012 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 CHROMEOS_DBUS_SESSION_MANAGER_CLIENT_H_
#define CHROMEOS_DBUS_SESSION_MANAGER_CLIENT_H_
#include <map>
#include <string>
#include "base/callback.h"
#include "base/observer_list.h"
#include "chromeos/chromeos_export.h"
#include "chromeos/dbus/dbus_client.h"
#include "chromeos/dbus/dbus_client_implementation_type.h"
namespace chromeos {
// SessionManagerClient is used to communicate with the session manager.
class CHROMEOS_EXPORT SessionManagerClient : public DBusClient {
public:
// Interface for observing changes from the session manager.
class Observer {
public:
virtual ~Observer() {}
// Called when the owner key is set.
virtual void OwnerKeySet(bool success) {}
// Called when the property change is complete.
virtual void PropertyChangeComplete(bool success) {}
// Called when the session manager announces that the screen has been locked
// successfully (i.e. after NotifyLockScreenShown() has been called).
virtual void ScreenIsLocked() {}
// Called when the session manager announces that the screen has been
// unlocked successfully (i.e. after NotifyLockScreenDismissed() has
// been called).
virtual void ScreenIsUnlocked() {}
// Called after EmitLoginPromptVisible is called.
virtual void EmitLoginPromptVisibleCalled() {}
};
// Interface for performing actions on behalf of the stub implementation.
class StubDelegate {
public:
virtual ~StubDelegate() {}
// Locks the screen. Invoked by the stub when RequestLockScreen() is called.
// In the real implementation of SessionManagerClient::RequestLockScreen(),
// a lock request is forwarded to the session manager; in the stub, this is
// short-circuited and the screen is locked immediately.
virtual void LockScreenForStub() = 0;
};
// Sets the delegate used by the stub implementation. Ownership of |delegate|
// remains with the caller.
virtual void SetStubDelegate(StubDelegate* delegate) = 0;
// Adds and removes the observer.
virtual void AddObserver(Observer* observer) = 0;
virtual void RemoveObserver(Observer* observer) = 0;
virtual bool HasObserver(Observer* observer) = 0;
// Kicks off an attempt to emit the "login-prompt-visible" upstart signal.
virtual void EmitLoginPromptVisible() = 0;
// Restarts a job referenced by |pid| with the provided command line.
virtual void RestartJob(int pid, const std::string& command_line) = 0;
// Used for StartSession. Takes a boolean indicating whether the
// operation was successful or not.
typedef base::Callback<void(bool success)> StartSessionCallback;
// Starts the session for the user.
virtual void StartSession(const std::string& user_email,
const StartSessionCallback& callback) = 0;
// Stops the current session.
virtual void StopSession() = 0;
// Starts the factory reset.
virtual void StartDeviceWipe() = 0;
// Locks the screen.
virtual void RequestLockScreen() = 0;
// Notifies that the lock screen is shown.
virtual void NotifyLockScreenShown() = 0;
// Notifies that the lock screen is dismissed.
virtual void NotifyLockScreenDismissed() = 0;
// Map that is used to describe the set of active user sessions where |key|
// is user_id and |value| is user_id_hash.
typedef std::map<std::string, std::string> ActiveSessionsMap;
// The ActiveSessionsCallback is used for the RetrieveActiveSessions()
// method. It receives |sessions| argument where the keys are user_ids for
// all users that are currently active and |success| argument which indicates
// whether or not the request succeded.
typedef base::Callback<void(const ActiveSessionsMap& sessions,
bool success)> ActiveSessionsCallback;
// Enumerates active user sessions. Usually Chrome naturally keeps track of
// active users when they are added into current session. When Chrome is
// restarted after crash by session_manager it only receives user_id and
// user_id_hash for one user. This method is used to retrieve list of all
// active users.
virtual void RetrieveActiveSessions(
const ActiveSessionsCallback& callback) = 0;
// Used for RetrieveDevicePolicy, RetrievePolicyForUser and
// RetrieveDeviceLocalAccountPolicy. Takes a serialized protocol buffer as
// string. Upon success, we will pass a protobuf to the callback. On
// failure, we will pass "".
typedef base::Callback<void(const std::string&)> RetrievePolicyCallback;
// Fetches the device policy blob stored by the session manager. Upon
// completion of the retrieve attempt, we will call the provided callback.
virtual void RetrieveDevicePolicy(const RetrievePolicyCallback& callback) = 0;
// Fetches the user policy blob stored by the session manager for the given
// |username|. Upon completion of the retrieve attempt, we will call the
// provided callback.
virtual void RetrievePolicyForUser(
const std::string& username,
const RetrievePolicyCallback& callback) = 0;
// Same as RetrievePolicyForUser() but blocks until a reply is received, and
// returns the policy synchronously. Returns an empty string if the method
// call fails.
// This may only be called in situations where blocking the UI thread is
// considered acceptable (e.g. restarting the browser after a crash or after
// a flag change).
virtual std::string BlockingRetrievePolicyForUser(
const std::string& username) = 0;
// Fetches the policy blob associated with the specified device-local account
// from session manager. |callback| is invoked up on completion.
virtual void RetrieveDeviceLocalAccountPolicy(
const std::string& account_id,
const RetrievePolicyCallback& callback) = 0;
// Used for StoreDevicePolicy, StorePolicyForUser and
// StoreDeviceLocalAccountPolicy. Takes a boolean indicating whether the
// operation was successful or not.
typedef base::Callback<void(bool)> StorePolicyCallback;
// Attempts to asynchronously store |policy_blob| as device policy. Upon
// completion of the store attempt, we will call callback.
virtual void StoreDevicePolicy(const std::string& policy_blob,
const StorePolicyCallback& callback) = 0;
// Attempts to asynchronously store |policy_blob| as user policy for the given
// |username|. Upon completion of the store attempt, we will call callback.
// The |policy_key| argument is not sent to the session manager, but is used
// by the stub implementation to enable policy validation on desktop builds.
virtual void StorePolicyForUser(const std::string& username,
const std::string& policy_blob,
const std::string& policy_key,
const StorePolicyCallback& callback) = 0;
// Sends a request to store a policy blob for the specified device-local
// account. The result of the operation is reported through |callback|.
virtual void StoreDeviceLocalAccountPolicy(
const std::string& account_id,
const std::string& policy_blob,
const StorePolicyCallback& callback) = 0;
// Sets the flags to be applied next time by the session manager when Chrome
// is restarted inside an already started session for a particular user.
virtual void SetFlagsForUser(const std::string& username,
const std::vector<std::string>& flags) = 0;
// Creates the instance.
static SessionManagerClient* Create(DBusClientImplementationType type);
virtual ~SessionManagerClient();
protected:
// Create() should be used instead.
SessionManagerClient();
private:
DISALLOW_COPY_AND_ASSIGN(SessionManagerClient);
};
} // namespace chromeos
#endif // CHROMEOS_DBUS_SESSION_MANAGER_CLIENT_H_
|
