Pepper: Fix crash on allocation failure.
[chromium-blink-merge.git] / chromeos / dbus / session_manager_client.h
blobd4c07066e2debc1144ec80967cb211ddd56288a5
1 // Copyright (c) 2012 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.
5 #ifndef CHROMEOS_DBUS_SESSION_MANAGER_CLIENT_H_
6 #define CHROMEOS_DBUS_SESSION_MANAGER_CLIENT_H_
8 #include <map>
9 #include <string>
10 #include <vector>
12 #include "base/callback.h"
13 #include "base/observer_list.h"
14 #include "chromeos/chromeos_export.h"
15 #include "chromeos/dbus/dbus_client.h"
16 #include "chromeos/dbus/dbus_client_implementation_type.h"
18 namespace chromeos {
20 // SessionManagerClient is used to communicate with the session manager.
21 class CHROMEOS_EXPORT SessionManagerClient : public DBusClient {
22 public:
23 // Interface for observing changes from the session manager.
24 class Observer {
25 public:
26 virtual ~Observer() {}
28 // Called when the owner key is set.
29 virtual void OwnerKeySet(bool success) {}
31 // Called when the property change is complete.
32 virtual void PropertyChangeComplete(bool success) {}
34 // Called when the session manager announces that the screen has been locked
35 // successfully (i.e. after NotifyLockScreenShown() has been called).
36 virtual void ScreenIsLocked() {}
38 // Called when the session manager announces that the screen has been
39 // unlocked successfully (i.e. after NotifyLockScreenDismissed() has
40 // been called).
41 virtual void ScreenIsUnlocked() {}
43 // Called after EmitLoginPromptVisible is called.
44 virtual void EmitLoginPromptVisibleCalled() {}
47 // Interface for performing actions on behalf of the stub implementation.
48 class StubDelegate {
49 public:
50 virtual ~StubDelegate() {}
52 // Locks the screen. Invoked by the stub when RequestLockScreen() is called.
53 // In the real implementation of SessionManagerClient::RequestLockScreen(),
54 // a lock request is forwarded to the session manager; in the stub, this is
55 // short-circuited and the screen is locked immediately.
56 virtual void LockScreenForStub() = 0;
59 // Sets the delegate used by the stub implementation. Ownership of |delegate|
60 // remains with the caller.
61 virtual void SetStubDelegate(StubDelegate* delegate) = 0;
63 // Adds and removes the observer.
64 virtual void AddObserver(Observer* observer) = 0;
65 virtual void RemoveObserver(Observer* observer) = 0;
66 virtual bool HasObserver(Observer* observer) = 0;
68 // Kicks off an attempt to emit the "login-prompt-visible" upstart signal.
69 virtual void EmitLoginPromptVisible() = 0;
71 // Restarts a job referenced by |pid| with the provided command line.
72 virtual void RestartJob(int pid, const std::string& command_line) = 0;
74 // Starts the session for the user.
75 virtual void StartSession(const std::string& user_email) = 0;
77 // Stops the current session.
78 virtual void StopSession() = 0;
80 // Starts the factory reset.
81 virtual void StartDeviceWipe() = 0;
83 // Locks the screen.
84 virtual void RequestLockScreen() = 0;
86 // Notifies that the lock screen is shown.
87 virtual void NotifyLockScreenShown() = 0;
89 // Notifies that the lock screen is dismissed.
90 virtual void NotifyLockScreenDismissed() = 0;
92 // Map that is used to describe the set of active user sessions where |key|
93 // is user_id and |value| is user_id_hash.
94 typedef std::map<std::string, std::string> ActiveSessionsMap;
96 // The ActiveSessionsCallback is used for the RetrieveActiveSessions()
97 // method. It receives |sessions| argument where the keys are user_ids for
98 // all users that are currently active and |success| argument which indicates
99 // whether or not the request succeded.
100 typedef base::Callback<void(const ActiveSessionsMap& sessions,
101 bool success)> ActiveSessionsCallback;
103 // Enumerates active user sessions. Usually Chrome naturally keeps track of
104 // active users when they are added into current session. When Chrome is
105 // restarted after crash by session_manager it only receives user_id and
106 // user_id_hash for one user. This method is used to retrieve list of all
107 // active users.
108 virtual void RetrieveActiveSessions(
109 const ActiveSessionsCallback& callback) = 0;
111 // Used for RetrieveDevicePolicy, RetrievePolicyForUser and
112 // RetrieveDeviceLocalAccountPolicy. Takes a serialized protocol buffer as
113 // string. Upon success, we will pass a protobuf to the callback. On
114 // failure, we will pass "".
115 typedef base::Callback<void(const std::string&)> RetrievePolicyCallback;
117 // Fetches the device policy blob stored by the session manager. Upon
118 // completion of the retrieve attempt, we will call the provided callback.
119 virtual void RetrieveDevicePolicy(const RetrievePolicyCallback& callback) = 0;
121 // Fetches the user policy blob stored by the session manager for the given
122 // |username|. Upon completion of the retrieve attempt, we will call the
123 // provided callback.
124 virtual void RetrievePolicyForUser(
125 const std::string& username,
126 const RetrievePolicyCallback& callback) = 0;
128 // Same as RetrievePolicyForUser() but blocks until a reply is received, and
129 // returns the policy synchronously. Returns an empty string if the method
130 // call fails.
131 // This may only be called in situations where blocking the UI thread is
132 // considered acceptable (e.g. restarting the browser after a crash or after
133 // a flag change).
134 virtual std::string BlockingRetrievePolicyForUser(
135 const std::string& username) = 0;
137 // Fetches the policy blob associated with the specified device-local account
138 // from session manager. |callback| is invoked up on completion.
139 virtual void RetrieveDeviceLocalAccountPolicy(
140 const std::string& account_id,
141 const RetrievePolicyCallback& callback) = 0;
143 // Used for StoreDevicePolicy, StorePolicyForUser and
144 // StoreDeviceLocalAccountPolicy. Takes a boolean indicating whether the
145 // operation was successful or not.
146 typedef base::Callback<void(bool)> StorePolicyCallback;
148 // Attempts to asynchronously store |policy_blob| as device policy. Upon
149 // completion of the store attempt, we will call callback.
150 virtual void StoreDevicePolicy(const std::string& policy_blob,
151 const StorePolicyCallback& callback) = 0;
153 // Attempts to asynchronously store |policy_blob| as user policy for the given
154 // |username|. Upon completion of the store attempt, we will call callback.
155 virtual void StorePolicyForUser(const std::string& username,
156 const std::string& policy_blob,
157 const StorePolicyCallback& callback) = 0;
159 // Sends a request to store a policy blob for the specified device-local
160 // account. The result of the operation is reported through |callback|.
161 virtual void StoreDeviceLocalAccountPolicy(
162 const std::string& account_id,
163 const std::string& policy_blob,
164 const StorePolicyCallback& callback) = 0;
166 // Sets the flags to be applied next time by the session manager when Chrome
167 // is restarted inside an already started session for a particular user.
168 virtual void SetFlagsForUser(const std::string& username,
169 const std::vector<std::string>& flags) = 0;
171 typedef base::Callback<void(const std::vector<std::string>& state_keys)>
172 StateKeysCallback;
174 // Get the currently valid server-backed state keys for the device.
175 // Server-backed state keys are opaque, device-unique, time-dependent,
176 // client-determined identifiers that are used for keying state in the cloud
177 // for the device to retrieve after a device factory reset.
179 // The state keys are returned asynchronously via |callback|. The callback
180 // will be invoked with an empty state key vector in case of errors.
181 virtual void GetServerBackedStateKeys(const StateKeysCallback& callback) = 0;
183 // Creates the instance.
184 static SessionManagerClient* Create(DBusClientImplementationType type);
186 virtual ~SessionManagerClient();
188 protected:
189 // Create() should be used instead.
190 SessionManagerClient();
192 private:
193 DISALLOW_COPY_AND_ASSIGN(SessionManagerClient);
196 } // namespace chromeos
198 #endif // CHROMEOS_DBUS_SESSION_MANAGER_CLIENT_H_