session_manager_client.cc revision 7d4cd473f85ac64c3747c96c277f9e506a0d2246 
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.
4
5#include "chromeos/dbus/session_manager_client.h"
6
7#include <map>
8
9#include "base/bind.h"
10#include "base/callback.h"
11#include "base/file_util.h"
12#include "base/files/file_path.h"
13#include "base/location.h"
14#include "base/path_service.h"
15#include "base/strings/string_util.h"
16#include "base/threading/worker_pool.h"
17#include "chromeos/chromeos_paths.h"
18#include "chromeos/dbus/cryptohome_client.h"
19#include "dbus/bus.h"
20#include "dbus/message.h"
21#include "dbus/object_path.h"
22#include "dbus/object_proxy.h"
23#include "third_party/cros_system_api/dbus/service_constants.h"
24
25namespace chromeos {
26
27// The SessionManagerClient implementation used in production.
28class SessionManagerClientImpl : public SessionManagerClient {
29 public:
30  explicit SessionManagerClientImpl(dbus::Bus* bus)
31      : session_manager_proxy_(NULL),
32        weak_ptr_factory_(this) {
33    session_manager_proxy_ = bus->GetObjectProxy(
34        login_manager::kSessionManagerServiceName,
35        dbus::ObjectPath(login_manager::kSessionManagerServicePath));
36
37    // Signals emitted on Chromium's interface.  Many of these ought to be
38    // method calls instead.
39    session_manager_proxy_->ConnectToSignal(
40        chromium::kChromiumInterface,
41        chromium::kOwnerKeySetSignal,
42        base::Bind(&SessionManagerClientImpl::OwnerKeySetReceived,
43                   weak_ptr_factory_.GetWeakPtr()),
44        base::Bind(&SessionManagerClientImpl::SignalConnected,
45                   weak_ptr_factory_.GetWeakPtr()));
46    session_manager_proxy_->ConnectToSignal(
47        chromium::kChromiumInterface,
48        chromium::kPropertyChangeCompleteSignal,
49        base::Bind(&SessionManagerClientImpl::PropertyChangeCompleteReceived,
50                   weak_ptr_factory_.GetWeakPtr()),
51        base::Bind(&SessionManagerClientImpl::SignalConnected,
52                   weak_ptr_factory_.GetWeakPtr()));
53    session_manager_proxy_->ConnectToSignal(
54        chromium::kChromiumInterface,
55        chromium::kLockScreenSignal,
56        base::Bind(&SessionManagerClientImpl::ScreenLockReceived,
57                   weak_ptr_factory_.GetWeakPtr()),
58        base::Bind(&SessionManagerClientImpl::SignalConnected,
59                   weak_ptr_factory_.GetWeakPtr()));
60    session_manager_proxy_->ConnectToSignal(
61        chromium::kChromiumInterface,
62        chromium::kUnlockScreenSignal,
63        base::Bind(&SessionManagerClientImpl::ScreenUnlockReceived,
64                   weak_ptr_factory_.GetWeakPtr()),
65        base::Bind(&SessionManagerClientImpl::SignalConnected,
66                   weak_ptr_factory_.GetWeakPtr()));
67    session_manager_proxy_->ConnectToSignal(
68        chromium::kChromiumInterface,
69        chromium::kLivenessRequestedSignal,
70        base::Bind(&SessionManagerClientImpl::LivenessRequestedReceived,
71                   weak_ptr_factory_.GetWeakPtr()),
72        base::Bind(&SessionManagerClientImpl::SignalConnected,
73                   weak_ptr_factory_.GetWeakPtr()));
74
75    // Signals emitted on the session manager's interface.
76    session_manager_proxy_->ConnectToSignal(
77        login_manager::kSessionManagerInterface,
78        login_manager::kScreenIsLockedSignal,
79        base::Bind(&SessionManagerClientImpl::ScreenIsLockedReceived,
80                   weak_ptr_factory_.GetWeakPtr()),
81        base::Bind(&SessionManagerClientImpl::SignalConnected,
82                   weak_ptr_factory_.GetWeakPtr()));
83    session_manager_proxy_->ConnectToSignal(
84        login_manager::kSessionManagerInterface,
85        login_manager::kScreenIsUnlockedSignal,
86        base::Bind(&SessionManagerClientImpl::ScreenIsUnlockedReceived,
87                   weak_ptr_factory_.GetWeakPtr()),
88        base::Bind(&SessionManagerClientImpl::SignalConnected,
89                   weak_ptr_factory_.GetWeakPtr()));
90  }
91
92  virtual ~SessionManagerClientImpl() {
93  }
94
95  // SessionManagerClient overrides:
96  virtual void AddObserver(Observer* observer) OVERRIDE {
97    observers_.AddObserver(observer);
98  }
99
100  virtual void RemoveObserver(Observer* observer) OVERRIDE {
101    observers_.RemoveObserver(observer);
102  }
103
104  virtual bool HasObserver(Observer* observer) OVERRIDE {
105    return observers_.HasObserver(observer);
106  }
107
108  virtual void EmitLoginPromptReady() OVERRIDE {
109    SimpleMethodCallToSessionManager(
110        login_manager::kSessionManagerEmitLoginPromptReady);
111  }
112
113  virtual void EmitLoginPromptVisible() OVERRIDE {
114    SimpleMethodCallToSessionManager(
115        login_manager::kSessionManagerEmitLoginPromptVisible);
116  }
117
118  virtual void RestartJob(int pid, const std::string& command_line) OVERRIDE {
119    dbus::MethodCall method_call(login_manager::kSessionManagerInterface,
120                                 login_manager::kSessionManagerRestartJob);
121    dbus::MessageWriter writer(&method_call);
122    writer.AppendInt32(pid);
123    writer.AppendString(command_line);
124    session_manager_proxy_->CallMethod(
125        &method_call,
126        dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
127        base::Bind(&SessionManagerClientImpl::OnRestartJob,
128                   weak_ptr_factory_.GetWeakPtr()));
129  }
130
131  virtual void RestartEntd() OVERRIDE {
132    SimpleMethodCallToSessionManager(login_manager::kSessionManagerRestartEntd);
133  }
134
135  virtual void StartSession(const std::string& user_email) OVERRIDE {
136    dbus::MethodCall method_call(login_manager::kSessionManagerInterface,
137                                 login_manager::kSessionManagerStartSession);
138    dbus::MessageWriter writer(&method_call);
139    writer.AppendString(user_email);
140    writer.AppendString("");  // Unique ID is deprecated
141    session_manager_proxy_->CallMethod(
142        &method_call,
143        dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
144        base::Bind(&SessionManagerClientImpl::OnStartSession,
145                   weak_ptr_factory_.GetWeakPtr()));
146  }
147
148  virtual void StopSession() OVERRIDE {
149    dbus::MethodCall method_call(login_manager::kSessionManagerInterface,
150                                 login_manager::kSessionManagerStopSession);
151    dbus::MessageWriter writer(&method_call);
152    writer.AppendString("");  // Unique ID is deprecated
153    session_manager_proxy_->CallMethod(
154        &method_call,
155        dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
156        base::Bind(&SessionManagerClientImpl::OnStopSession,
157                   weak_ptr_factory_.GetWeakPtr()));
158  }
159
160  virtual void StartDeviceWipe() OVERRIDE {
161    dbus::MethodCall method_call(login_manager::kSessionManagerInterface,
162                                 login_manager::kSessionManagerStartDeviceWipe);
163    session_manager_proxy_->CallMethod(
164        &method_call,
165        dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
166        base::Bind(&SessionManagerClientImpl::OnDeviceWipe,
167                   weak_ptr_factory_.GetWeakPtr()));
168  }
169
170  virtual void RequestLockScreen() OVERRIDE {
171    SimpleMethodCallToSessionManager(login_manager::kSessionManagerLockScreen);
172  }
173
174  virtual void NotifyLockScreenShown() OVERRIDE {
175    SimpleMethodCallToSessionManager(
176        login_manager::kSessionManagerHandleLockScreenShown);
177  }
178
179  virtual void RequestUnlockScreen() OVERRIDE {
180    SimpleMethodCallToSessionManager(
181        login_manager::kSessionManagerUnlockScreen);
182  }
183
184  virtual void NotifyLockScreenDismissed() OVERRIDE {
185    SimpleMethodCallToSessionManager(
186        login_manager::kSessionManagerHandleLockScreenDismissed);
187  }
188
189  virtual void RetrieveActiveSessions(
190      const ActiveSessionsCallback& callback) OVERRIDE {
191    dbus::MethodCall method_call(
192        login_manager::kSessionManagerInterface,
193        login_manager::kSessionManagerRetrieveActiveSessions);
194
195    session_manager_proxy_->CallMethod(
196        &method_call,
197        dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
198        base::Bind(&SessionManagerClientImpl::OnRetrieveActiveSessions,
199                   weak_ptr_factory_.GetWeakPtr(),
200                   login_manager::kSessionManagerRetrieveActiveSessions,
201                   callback));
202  }
203
204  virtual void RetrieveDevicePolicy(
205      const RetrievePolicyCallback& callback) OVERRIDE {
206    dbus::MethodCall method_call(login_manager::kSessionManagerInterface,
207                                 login_manager::kSessionManagerRetrievePolicy);
208    session_manager_proxy_->CallMethod(
209        &method_call,
210        dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
211        base::Bind(&SessionManagerClientImpl::OnRetrievePolicy,
212                   weak_ptr_factory_.GetWeakPtr(),
213                   login_manager::kSessionManagerRetrievePolicy,
214                   callback));
215  }
216
217  virtual void RetrievePolicyForUser(
218      const std::string& username,
219      const RetrievePolicyCallback& callback) OVERRIDE {
220    CallRetrievePolicyByUsername(
221        login_manager::kSessionManagerRetrievePolicyForUser,
222        username,
223        callback);
224  }
225
226  virtual void RetrieveDeviceLocalAccountPolicy(
227      const std::string& account_name,
228      const RetrievePolicyCallback& callback) OVERRIDE {
229    CallRetrievePolicyByUsername(
230        login_manager::kSessionManagerRetrieveDeviceLocalAccountPolicy,
231        account_name,
232        callback);
233  }
234
235  virtual void StoreDevicePolicy(const std::string& policy_blob,
236                                 const StorePolicyCallback& callback) OVERRIDE {
237    dbus::MethodCall method_call(login_manager::kSessionManagerInterface,
238                                 login_manager::kSessionManagerStorePolicy);
239    dbus::MessageWriter writer(&method_call);
240    // static_cast does not work due to signedness.
241    writer.AppendArrayOfBytes(
242        reinterpret_cast<const uint8*>(policy_blob.data()), policy_blob.size());
243    session_manager_proxy_->CallMethod(
244        &method_call,
245        dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
246        base::Bind(&SessionManagerClientImpl::OnStorePolicy,
247                   weak_ptr_factory_.GetWeakPtr(),
248                   login_manager::kSessionManagerStorePolicy,
249                   callback));
250  }
251
252  virtual void StorePolicyForUser(
253      const std::string& username,
254      const std::string& policy_blob,
255      const std::string& ignored_policy_key,
256      const StorePolicyCallback& callback) OVERRIDE {
257    CallStorePolicyByUsername(login_manager::kSessionManagerStorePolicyForUser,
258                              username,
259                              policy_blob,
260                              callback);
261  }
262
263  virtual void StoreDeviceLocalAccountPolicy(
264      const std::string& account_name,
265      const std::string& policy_blob,
266      const StorePolicyCallback& callback) OVERRIDE {
267    CallStorePolicyByUsername(
268        login_manager::kSessionManagerStoreDeviceLocalAccountPolicy,
269        account_name,
270        policy_blob,
271        callback);
272  }
273
274  virtual void SetFlagsForUser(const std::string& username,
275                               const std::vector<std::string>& flags) OVERRIDE {
276    dbus::MethodCall method_call(login_manager::kSessionManagerInterface,
277                                 login_manager::kSessionManagerSetFlagsForUser);
278    dbus::MessageWriter writer(&method_call);
279    writer.AppendString(username);
280    writer.AppendArrayOfStrings(flags);
281    session_manager_proxy_->CallMethod(
282        &method_call,
283        dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
284        dbus::ObjectProxy::EmptyResponseCallback());
285  }
286
287 private:
288  // Makes a method call to the session manager with no arguments and no
289  // response.
290  void SimpleMethodCallToSessionManager(const std::string& method_name) {
291    dbus::MethodCall method_call(login_manager::kSessionManagerInterface,
292                                 method_name);
293    session_manager_proxy_->CallMethod(
294        &method_call,
295        dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
296        dbus::ObjectProxy::EmptyResponseCallback());
297  }
298
299  // Helper for RetrieveDeviceLocalAccountPolicy and RetrievePolicyForUser.
300  void CallRetrievePolicyByUsername(const std::string& method_name,
301                                    const std::string& username,
302                                    const RetrievePolicyCallback& callback) {
303    dbus::MethodCall method_call(login_manager::kSessionManagerInterface,
304                                 method_name);
305    dbus::MessageWriter writer(&method_call);
306    writer.AppendString(username);
307    session_manager_proxy_->CallMethod(
308        &method_call,
309        dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
310        base::Bind(
311            &SessionManagerClientImpl::OnRetrievePolicy,
312            weak_ptr_factory_.GetWeakPtr(),
313            method_name,
314            callback));
315  }
316
317  void CallStorePolicyByUsername(const std::string& method_name,
318                                 const std::string& username,
319                                 const std::string& policy_blob,
320                                 const StorePolicyCallback& callback) {
321    dbus::MethodCall method_call(login_manager::kSessionManagerInterface,
322                                 method_name);
323    dbus::MessageWriter writer(&method_call);
324    writer.AppendString(username);
325    // static_cast does not work due to signedness.
326    writer.AppendArrayOfBytes(
327        reinterpret_cast<const uint8*>(policy_blob.data()), policy_blob.size());
328    session_manager_proxy_->CallMethod(
329        &method_call,
330        dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
331        base::Bind(
332            &SessionManagerClientImpl::OnStorePolicy,
333            weak_ptr_factory_.GetWeakPtr(),
334            method_name,
335            callback));
336  }
337
338  // Called when kSessionManagerRestartJob method is complete.
339  void OnRestartJob(dbus::Response* response) {
340    LOG_IF(ERROR, !response)
341        << "Failed to call "
342        << login_manager::kSessionManagerRestartJob;
343  }
344
345  // Called when kSessionManagerStartSession method is complete.
346  void OnStartSession(dbus::Response* response) {
347    LOG_IF(ERROR, !response)
348        << "Failed to call "
349        << login_manager::kSessionManagerStartSession;
350  }
351
352  // Called when kSessionManagerStopSession method is complete.
353  void OnStopSession(dbus::Response* response) {
354    LOG_IF(ERROR, !response)
355        << "Failed to call "
356        << login_manager::kSessionManagerStopSession;
357  }
358
359  // Called when kSessionManagerStopSession method is complete.
360  void OnDeviceWipe(dbus::Response* response) {
361    LOG_IF(ERROR, !response)
362        << "Failed to call "
363        << login_manager::kSessionManagerStartDeviceWipe;
364  }
365
366  // Called when kSessionManagerRetrieveActiveSessions method is complete.
367  void OnRetrieveActiveSessions(const std::string& method_name,
368                                const ActiveSessionsCallback& callback,
369                                dbus::Response* response) {
370    ActiveSessionsMap sessions;
371    bool success = false;
372    if (!response) {
373      LOG(ERROR) << "Failed to call " << method_name;
374      callback.Run(sessions, success);
375      return;
376    }
377
378    dbus::MessageReader reader(response);
379    dbus::MessageReader array_reader(NULL);
380
381    if (!reader.PopArray(&array_reader)) {
382      LOG(ERROR) << method_name << " response is incorrect: "
383                 << response->ToString();
384    } else {
385      while (array_reader.HasMoreData()) {
386        dbus::MessageReader dict_entry_reader(NULL);
387        std::string key;
388        std::string value;
389        if (!array_reader.PopDictEntry(&dict_entry_reader) ||
390            !dict_entry_reader.PopString(&key) ||
391            !dict_entry_reader.PopString(&value)) {
392          LOG(ERROR) << method_name << " response is incorrect: "
393                     << response->ToString();
394        } else {
395          sessions[key] = value;
396        }
397      }
398      success = true;
399    }
400    callback.Run(sessions, success);
401  }
402
403  // Called when kSessionManagerRetrievePolicy or
404  // kSessionManagerRetrievePolicyForUser method is complete.
405  void OnRetrievePolicy(const std::string& method_name,
406                        const RetrievePolicyCallback& callback,
407                        dbus::Response* response) {
408    if (!response) {
409      LOG(ERROR) << "Failed to call " << method_name;
410      callback.Run("");
411      return;
412    }
413    dbus::MessageReader reader(response);
414    uint8* values = NULL;
415    size_t length = 0;
416    if (!reader.PopArrayOfBytes(&values, &length)) {
417      LOG(ERROR) << "Invalid response: " << response->ToString();
418      callback.Run("");
419      return;
420    }
421    // static_cast does not work due to signedness.
422    std::string serialized_proto(reinterpret_cast<char*>(values), length);
423    callback.Run(serialized_proto);
424  }
425
426  // Called when kSessionManagerStorePolicy or kSessionManagerStorePolicyForUser
427  // method is complete.
428  void OnStorePolicy(const std::string& method_name,
429                     const StorePolicyCallback& callback,
430                     dbus::Response* response) {
431    bool success = false;
432    if (!response) {
433      LOG(ERROR) << "Failed to call " << method_name;
434    } else {
435      dbus::MessageReader reader(response);
436      if (!reader.PopBool(&success))
437        LOG(ERROR) << "Invalid response: " << response->ToString();
438    }
439    callback.Run(success);
440  }
441
442  // Called when the owner key set signal is received.
443  void OwnerKeySetReceived(dbus::Signal* signal) {
444    dbus::MessageReader reader(signal);
445    std::string result_string;
446    if (!reader.PopString(&result_string)) {
447      LOG(ERROR) << "Invalid signal: " << signal->ToString();
448      return;
449    }
450    const bool success = StartsWithASCII(result_string, "success", false);
451    FOR_EACH_OBSERVER(Observer, observers_, OwnerKeySet(success));
452  }
453
454  // Called when the property change complete signal is received.
455  void PropertyChangeCompleteReceived(dbus::Signal* signal) {
456    dbus::MessageReader reader(signal);
457    std::string result_string;
458    if (!reader.PopString(&result_string)) {
459      LOG(ERROR) << "Invalid signal: " << signal->ToString();
460      return;
461    }
462    const bool success = StartsWithASCII(result_string, "success", false);
463    FOR_EACH_OBSERVER(Observer, observers_, PropertyChangeComplete(success));
464  }
465
466  void ScreenLockReceived(dbus::Signal* signal) {
467    FOR_EACH_OBSERVER(Observer, observers_, LockScreen());
468  }
469
470  void ScreenUnlockReceived(dbus::Signal* signal) {
471    FOR_EACH_OBSERVER(Observer, observers_, UnlockScreen());
472  }
473
474  void LivenessRequestedReceived(dbus::Signal* signal) {
475    SimpleMethodCallToSessionManager(
476        login_manager::kSessionManagerHandleLivenessConfirmed);
477  }
478
479  void ScreenIsLockedReceived(dbus::Signal* signal) {
480    FOR_EACH_OBSERVER(Observer, observers_, ScreenIsLocked());
481  }
482
483  void ScreenIsUnlockedReceived(dbus::Signal* signal) {
484    FOR_EACH_OBSERVER(Observer, observers_, ScreenIsUnlocked());
485  }
486
487  // Called when the object is connected to the signal.
488  void SignalConnected(const std::string& interface_name,
489                       const std::string& signal_name,
490                       bool success) {
491    LOG_IF(ERROR, !success) << "Failed to connect to " << signal_name;
492  }
493
494  dbus::ObjectProxy* session_manager_proxy_;
495  ObserverList<Observer> observers_;
496
497  // Note: This should remain the last member so it'll be destroyed and
498  // invalidate its weak pointers before any other members are destroyed.
499  base::WeakPtrFactory<SessionManagerClientImpl> weak_ptr_factory_;
500
501  DISALLOW_COPY_AND_ASSIGN(SessionManagerClientImpl);
502};
503
504// The SessionManagerClient implementation used on Linux desktop,
505// which does nothing.
506class SessionManagerClientStubImpl : public SessionManagerClient {
507 public:
508  SessionManagerClientStubImpl() {
509    // Make sure that there are no keys left over from a previous browser run.
510    base::FilePath user_policy_key_dir;
511    if (PathService::Get(chromeos::DIR_USER_POLICY_KEYS,
512                         &user_policy_key_dir)) {
513      base::WorkerPool::PostTask(
514          FROM_HERE,
515          base::Bind(base::IgnoreResult(&file_util::Delete),
516                     user_policy_key_dir, true),
517          false);
518    }
519  }
520  virtual ~SessionManagerClientStubImpl() {}
521
522  // SessionManagerClient overrides.
523  virtual void AddObserver(Observer* observer) OVERRIDE {
524    observers_.AddObserver(observer);
525  }
526  virtual void RemoveObserver(Observer* observer) OVERRIDE {
527    observers_.RemoveObserver(observer);
528  }
529  virtual bool HasObserver(Observer* observer) OVERRIDE {
530    return observers_.HasObserver(observer);
531  }
532  virtual void EmitLoginPromptReady() OVERRIDE {}
533  virtual void EmitLoginPromptVisible() OVERRIDE {}
534  virtual void RestartJob(int pid, const std::string& command_line) OVERRIDE {}
535  virtual void RestartEntd() OVERRIDE {}
536  virtual void StartSession(const std::string& user_email) OVERRIDE {}
537  virtual void StopSession() OVERRIDE {}
538  virtual void StartDeviceWipe() OVERRIDE {}
539  virtual void RequestLockScreen() OVERRIDE {
540    FOR_EACH_OBSERVER(Observer, observers_, LockScreen());
541  }
542  virtual void NotifyLockScreenShown() OVERRIDE {
543    FOR_EACH_OBSERVER(Observer, observers_, ScreenIsLocked());
544  }
545  virtual void RequestUnlockScreen() OVERRIDE {
546    FOR_EACH_OBSERVER(Observer, observers_, UnlockScreen());
547  }
548  virtual void NotifyLockScreenDismissed() OVERRIDE {
549    FOR_EACH_OBSERVER(Observer, observers_, ScreenIsUnlocked());
550  }
551  virtual void RetrieveActiveSessions(
552      const ActiveSessionsCallback& callback) OVERRIDE {}
553  virtual void RetrieveDevicePolicy(
554      const RetrievePolicyCallback& callback) OVERRIDE {
555    callback.Run(device_policy_);
556  }
557  virtual void RetrievePolicyForUser(
558      const std::string& username,
559      const RetrievePolicyCallback& callback) OVERRIDE {
560    callback.Run(user_policies_[username]);
561  }
562  virtual void RetrieveDeviceLocalAccountPolicy(
563      const std::string& account_name,
564      const RetrievePolicyCallback& callback) OVERRIDE {
565    callback.Run(user_policies_[account_name]);
566  }
567  virtual void StoreDevicePolicy(const std::string& policy_blob,
568                                 const StorePolicyCallback& callback) OVERRIDE {
569    device_policy_ = policy_blob;
570    callback.Run(true);
571  }
572  virtual void StorePolicyForUser(
573      const std::string& username,
574      const std::string& policy_blob,
575      const std::string& policy_key,
576      const StorePolicyCallback& callback) OVERRIDE {
577    if (policy_key.empty()) {
578      user_policies_[username] = policy_blob;
579      callback.Run(true);
580      return;
581    }
582    // The session manager writes the user policy key to a well-known
583    // location. Do the same with the stub impl, so that user policy works and
584    // can be tested on desktop builds.
585    // TODO(joaodasilva): parse the PolicyFetchResponse in |policy_blob| to get
586    // the policy key directly, after moving the policy protobufs to a top-level
587    // directory. The |policy_key| argument to this method can then be removed.
588    // http://crbug.com/240269
589    base::FilePath key_path;
590    if (!PathService::Get(chromeos::DIR_USER_POLICY_KEYS, &key_path)) {
591      callback.Run(false);
592      return;
593    }
594    const std::string sanitized =
595        CryptohomeClient::GetStubSanitizedUsername(username);
596    key_path = key_path.AppendASCII(sanitized).AppendASCII("policy.pub");
597    // Assume that the key write is successful.
598    user_policies_[username] = policy_blob;
599    base::WorkerPool::PostTaskAndReply(
600        FROM_HERE,
601        base::Bind(&SessionManagerClientStubImpl::StoreFileInBackground,
602                   key_path, policy_key),
603        base::Bind(callback, true),
604        false);
605  }
606  virtual void StoreDeviceLocalAccountPolicy(
607      const std::string& account_name,
608      const std::string& policy_blob,
609      const StorePolicyCallback& callback) OVERRIDE {
610    user_policies_[account_name] = policy_blob;
611    callback.Run(true);
612  }
613  virtual void SetFlagsForUser(const std::string& username,
614                               const std::vector<std::string>& flags) OVERRIDE {
615  }
616
617  static void StoreFileInBackground(const base::FilePath& path,
618                                    const std::string& data) {
619    const int size = static_cast<int>(data.size());
620    if (!file_util::CreateDirectory(path.DirName()) ||
621        file_util::WriteFile(path, data.data(), size) != size) {
622      LOG(WARNING) << "Failed to write policy key to " << path.value();
623    }
624  }
625
626 private:
627  ObserverList<Observer> observers_;
628  std::string device_policy_;
629  std::map<std::string, std::string> user_policies_;
630
631  DISALLOW_COPY_AND_ASSIGN(SessionManagerClientStubImpl);
632};
633
634SessionManagerClient::SessionManagerClient() {
635}
636
637SessionManagerClient::~SessionManagerClient() {
638}
639
640SessionManagerClient* SessionManagerClient::Create(
641    DBusClientImplementationType type,
642    dbus::Bus* bus) {
643  if (type == REAL_DBUS_CLIENT_IMPLEMENTATION)
644    return new SessionManagerClientImpl(bus);
645  DCHECK_EQ(STUB_DBUS_CLIENT_IMPLEMENTATION, type);
646  return new SessionManagerClientStubImpl();
647}
648
649}  // namespace chromeos
650