chromeos/dbus/session_manager_client.cc

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