Load DeviceLocalAccount policy and DeviceSettings immediately on restore after Chrome crash.

chromeos/dbus/session_manager_client.cc

 // 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.
 
 #include "chromeos/dbus/session_manager_client.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 22 matching lines @@
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace chromeos {
 
 namespace {
 
 // TODO(hidehiko): Share the constant between Chrome and ChromeOS.
 constexpr char kArcLowDiskError[] =
     "org.chromium.SessionManagerInterface.LowFreeDisk";
 
+constexpr char kStubPolicyFile[] = "stub_policy";
+constexpr char kStubDevicePolicyFile[] = "stub_device_policy";
+
 // Returns a location for |file| that is specific to the given |cryptohome_id|.
 // These paths will be relative to DIR_USER_POLICY_KEYS, and can be used only
 // to store stub files.
 base::FilePath GetUserFilePath(const cryptohome::Identification& cryptohome_id,
                                const char* file) {
   base::FilePath keys_path;
   if (!PathService::Get(chromeos::DIR_USER_POLICY_KEYS, &keys_path))
     return base::FilePath();
   const std::string sanitized =
       CryptohomeClient::GetStubSanitizedUsername(cryptohome_id);
@@ skipping 148 matching lines @@
                                  login_manager::kSessionManagerRetrievePolicy);
     session_manager_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&SessionManagerClientImpl::OnRetrievePolicy,
                    weak_ptr_factory_.GetWeakPtr(),
                    login_manager::kSessionManagerRetrievePolicy,
                    callback));
   }
 
+  std::string BlockingRetrieveDevicePolicy() override {
+    dbus::MethodCall method_call(login_manager::kSessionManagerInterface,
+                                 login_manager::kSessionManagerRetrievePolicy);
+    std::unique_ptr<dbus::Response> response =
+        blocking_method_caller_->CallMethodAndBlock(&method_call);
+    std::string policy;
+    ExtractString(login_manager::kSessionManagerRetrievePolicy, response.get(),
+                  &policy);
+    return policy;
+  }
+
   void RetrievePolicyForUser(const cryptohome::Identification& cryptohome_id,
                              const RetrievePolicyCallback& callback) override {
     CallRetrievePolicyByUsername(
         login_manager::kSessionManagerRetrievePolicyForUser, cryptohome_id.id(),
         callback);
   }
 
   std::string BlockingRetrievePolicyForUser(
       const cryptohome::Identification& cryptohome_id) override {
     dbus::MethodCall method_call(
@@ skipping 12 matching lines @@
 
   void RetrieveDeviceLocalAccountPolicy(
       const std::string& account_name,
       const RetrievePolicyCallback& callback) override {
     CallRetrievePolicyByUsername(
         login_manager::kSessionManagerRetrieveDeviceLocalAccountPolicy,
         account_name,
         callback);
   }
 
+  std::string BlockingRetrieveDeviceLocalAccountPolicy(
+      const std::string& account_name) override {
+    dbus::MethodCall method_call(
+        login_manager::kSessionManagerInterface,
+        login_manager::kSessionManagerRetrieveDeviceLocalAccountPolicy);
+    dbus::MessageWriter writer(&method_call);
+    writer.AppendString(account_name);
+    std::unique_ptr<dbus::Response> response =
+        blocking_method_caller_->CallMethodAndBlock(&method_call);
+    std::string policy;
+    ExtractString(
+        login_manager::kSessionManagerRetrieveDeviceLocalAccountPolicy,
+        response.get(), &policy);
+    return policy;
+  }
+
   void StoreDevicePolicy(const std::string& policy_blob,
                          const StorePolicyCallback& callback) override {
     dbus::MethodCall method_call(login_manager::kSessionManagerInterface,
                                  login_manager::kSessionManagerStorePolicy);
     dbus::MessageWriter writer(&method_call);
     // static_cast does not work due to signedness.
     writer.AppendArrayOfBytes(
         reinterpret_cast<const uint8_t*>(policy_blob.data()),
         policy_blob.size());
     session_manager_proxy_->CallMethod(
@@ skipping 575 matching lines @@
   }
   void RetrieveActiveSessions(const ActiveSessionsCallback& callback) override {
   }
   void RetrieveDevicePolicy(const RetrievePolicyCallback& callback) override {
     base::FilePath owner_key_path;
     if (!PathService::Get(chromeos::FILE_OWNER_KEY, &owner_key_path)) {
       callback.Run("");
       return;
     }
     base::FilePath device_policy_path =
-        owner_key_path.DirName().AppendASCII("stub_device_policy");
+        owner_key_path.DirName().AppendASCII(kStubDevicePolicyFile);
     base::PostTaskWithTraitsAndReplyWithResult(
         FROM_HERE, base::TaskTraits()
                        .WithShutdownBehavior(
                            base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN)
                        .MayBlock(),
         base::Bind(&GetFileContent, device_policy_path), callback);
   }
+  std::string BlockingRetrieveDevicePolicy() override {
+    base::FilePath owner_key_path;
+    if (!PathService::Get(chromeos::FILE_OWNER_KEY, &owner_key_path)) {
+      return "";
+    }
+    base::FilePath device_policy_path =
+        owner_key_path.DirName().AppendASCII(kStubDevicePolicyFile);
+    return GetFileContent(device_policy_path);
+  }
   void RetrievePolicyForUser(const cryptohome::Identification& cryptohome_id,
                              const RetrievePolicyCallback& callback) override {
     base::PostTaskWithTraitsAndReplyWithResult(
-        FROM_HERE, base::TaskTraits()
-                       .WithShutdownBehavior(
-                           base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN)
-                       .MayBlock(),
+        FROM_HERE,
+        base::TaskTraits()
+            .WithShutdownBehavior(
+                base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN)
+            .MayBlock(),
         base::Bind(&GetFileContent,
-                   GetUserFilePath(cryptohome_id, "stub_policy")),
+                   GetUserFilePath(cryptohome_id, kStubPolicyFile)),
         callback);
   }
   std::string BlockingRetrievePolicyForUser(
       const cryptohome::Identification& cryptohome_id) override {
-    return GetFileContent(GetUserFilePath(cryptohome_id, "stub_policy"));
+    return GetFileContent(GetUserFilePath(cryptohome_id, kStubPolicyFile));
   }
   void RetrieveDeviceLocalAccountPolicy(
       const std::string& account_id,
       const RetrievePolicyCallback& callback) override {
     RetrievePolicyForUser(cryptohome::Identification::FromString(account_id),
                           callback);
   }
+  std::string BlockingRetrieveDeviceLocalAccountPolicy(
+      const std::string& account_id) override {
+    return BlockingRetrievePolicyForUser(
+        cryptohome::Identification::FromString(account_id));
+  }
   void StoreDevicePolicy(const std::string& policy_blob,
                          const StorePolicyCallback& callback) override {
     enterprise_management::PolicyFetchResponse response;
     base::FilePath owner_key_path;
     if (!response.ParseFromString(policy_blob) ||
         !PathService::Get(chromeos::FILE_OWNER_KEY, &owner_key_path)) {
       callback.Run(false);
       return;
     }
 
     if (response.has_new_public_key()) {
       base::PostTaskWithTraits(
           FROM_HERE, base::TaskTraits()
                          .WithShutdownBehavior(
                              base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN)
                          .MayBlock(),
           base::Bind(&StoreFile, owner_key_path, response.new_public_key()));
     }
 
     // Chrome will attempt to retrieve the device policy right after storing
     // during enrollment, so make sure it's written before signaling
     // completion.
     // Note also that the owner key will be written before the device policy,
     // if it was present in the blob.
     base::FilePath device_policy_path =
-        owner_key_path.DirName().AppendASCII("stub_device_policy");
+        owner_key_path.DirName().AppendASCII(kStubDevicePolicyFile);
     base::PostTaskWithTraitsAndReply(
         FROM_HERE, base::TaskTraits()
                        .WithShutdownBehavior(
                            base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN)
                        .MayBlock(),
         base::Bind(&StoreFile, device_policy_path, policy_blob),
         base::Bind(callback, true));
   }
   void StorePolicyForUser(const cryptohome::Identification& cryptohome_id,
                           const std::string& policy_blob,
@@ skipping 13 matching lines @@
           FROM_HERE, base::TaskTraits()
                          .WithShutdownBehavior(
                              base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN)
                          .MayBlock(),
           base::Bind(&StoreFile, key_path, response.new_public_key()));
     }
 
     // This file isn't read directly by Chrome, but is used by this class to
     // reload the user policy across restarts.
     base::FilePath stub_policy_path =
-        GetUserFilePath(cryptohome_id, "stub_policy");
+        GetUserFilePath(cryptohome_id, kStubPolicyFile);
     base::PostTaskWithTraitsAndReply(
         FROM_HERE, base::TaskTraits()
                        .WithShutdownBehavior(
                            base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN)
                        .MayBlock(),
         base::Bind(&StoreFile, stub_policy_path, policy_blob),
         base::Bind(callback, true));
   }
   void StoreDeviceLocalAccountPolicy(
       const std::string& account_id,
@@ skipping 71 matching lines @@
 
 SessionManagerClient* SessionManagerClient::Create(
     DBusClientImplementationType type) {
   if (type == REAL_DBUS_CLIENT_IMPLEMENTATION)
     return new SessionManagerClientImpl();
   DCHECK_EQ(FAKE_DBUS_CLIENT_IMPLEMENTATION, type);
   return new SessionManagerClientStubImpl();
 }
 
 }  // namespace chromeos