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

chrome/browser/chromeos/policy/device_local_account_policy_store.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 "chrome/browser/chromeos/policy/device_local_account_policy_store.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 22 matching lines @@
       device_settings_service_(device_settings_service),
       weak_factory_(this) {}
 
 DeviceLocalAccountPolicyStore::~DeviceLocalAccountPolicyStore() {}
 
 void DeviceLocalAccountPolicyStore::Load() {
   weak_factory_.InvalidateWeakPtrs();
   session_manager_client_->RetrieveDeviceLocalAccountPolicy(
       account_id_,
       base::Bind(&DeviceLocalAccountPolicyStore::ValidateLoadedPolicyBlob,
-                 weak_factory_.GetWeakPtr()));
+                 weak_factory_.GetWeakPtr(), true /*validate_in_background*/));
+}
+
+void DeviceLocalAccountPolicyStore::LoadImmediately() {
+  // This blocking D-Bus call is in the startup path and will block the UI
+  // thread. This only happens when the Profile is created synchronously, which
+  // on Chrome OS happens whenever the browser is restarted into the same
+  // session, that is when the browser crashes, or right after signin if
+  // the user has flags configured in about:flags.
+  // However, on those paths we must load policy synchronously so that the
+  // Profile initialization never sees unmanaged prefs, which would lead to
+  // data loss. http://crbug.com/263061
+
+  // Cancel all running async loads.
+  weak_factory_.InvalidateWeakPtrs();
+
+  const std::string policy_blob =
+      session_manager_client_->BlockingRetrieveDeviceLocalAccountPolicy(
+          account_id_);
+  ValidateLoadedPolicyBlob(false /*validate_in_background*/, policy_blob);
 }
 
 void DeviceLocalAccountPolicyStore::Store(
     const em::PolicyFetchResponse& policy) {
   weak_factory_.InvalidateWeakPtrs();
   CheckKeyAndValidate(
       true, base::MakeUnique<em::PolicyFetchResponse>(policy),
+      true /*validate_in_background*/,
       base::Bind(&DeviceLocalAccountPolicyStore::StoreValidatedPolicy,
                  weak_factory_.GetWeakPtr()));
 }
 
 void DeviceLocalAccountPolicyStore::ValidateLoadedPolicyBlob(
+    bool validate_in_background,
     const std::string& policy_blob) {
   if (policy_blob.empty()) {
     status_ = CloudPolicyStore::STATUS_LOAD_ERROR;
     NotifyStoreError();
   } else {
     std::unique_ptr<em::PolicyFetchResponse> policy(
         new em::PolicyFetchResponse());
     if (policy->ParseFromString(policy_blob)) {
       CheckKeyAndValidate(
-          false, std::move(policy),
+          false, std::move(policy), validate_in_background,
           base::Bind(&DeviceLocalAccountPolicyStore::UpdatePolicy,
                      weak_factory_.GetWeakPtr()));
     } else {
       status_ = CloudPolicyStore::STATUS_PARSE_ERROR;
       NotifyStoreError();
     }
   }
 }
 
 void DeviceLocalAccountPolicyStore::UpdatePolicy(
@@ skipping 44 matching lines @@
     status_ = CloudPolicyStore::STATUS_STORE_ERROR;
     NotifyStoreError();
   } else {
     Load();
   }
 }
 
 void DeviceLocalAccountPolicyStore::CheckKeyAndValidate(
     bool valid_timestamp_required,
     std::unique_ptr<em::PolicyFetchResponse> policy,
+    bool validate_in_background,
     const ValidateCompletionCallback& callback) {
-  device_settings_service_->GetOwnershipStatusAsync(
-      base::Bind(&DeviceLocalAccountPolicyStore::Validate,
-                 weak_factory_.GetWeakPtr(),
-                 valid_timestamp_required,
-                 base::Passed(&policy),
-                 callback));
+  if (validate_in_background) {
+    device_settings_service_->GetOwnershipStatusAsync(
+        base::Bind(&DeviceLocalAccountPolicyStore::Validate,
+                   weak_factory_.GetWeakPtr(), valid_timestamp_required,
+                   base::Passed(&policy), callback, validate_in_background));
+  } else {
+    chromeos::DeviceSettingsService::OwnershipStatus ownership_status =
+        device_settings_service_->GetOwnershipStatus();
+    Validate(valid_timestamp_required, std::move(policy), callback,
+             validate_in_background, ownership_status);
+  }
 }
 
 void DeviceLocalAccountPolicyStore::Validate(
     bool valid_timestamp_required,
     std::unique_ptr<em::PolicyFetchResponse> policy_response,
     const ValidateCompletionCallback& callback,
+    bool validate_in_background,
     chromeos::DeviceSettingsService::OwnershipStatus ownership_status) {
   DCHECK_NE(chromeos::DeviceSettingsService::OWNERSHIP_UNKNOWN,
             ownership_status);
   const em::PolicyData* device_policy_data =
       device_settings_service_->policy_data();
   // Note that the key is obtained through the device settings service instead
   // of using |policy_signature_public_key_| member, as the latter one is
   // updated only after the successful installation of the policy.
   scoped_refptr<ownership::PublicKey> key =
       device_settings_service_->GetPublicKey();
@@ skipping 22 matching lines @@
   // Validate the DMToken to match what device policy has.
   validator->ValidateDMToken(device_policy_data->request_token(),
                              CloudPolicyValidatorBase::DM_TOKEN_REQUIRED);
 
   // Validate the device id to match what device policy has.
   validator->ValidateDeviceId(device_policy_data->device_id(),
                               CloudPolicyValidatorBase::DEVICE_ID_REQUIRED);
 
   validator->ValidatePayload();
   validator->ValidateSignature(key->as_string());
-  validator.release()->StartValidation(base::Bind(callback, key->as_string()));
+
+  if (validate_in_background) {
+    // The Validator will delete itself once validation is
+    // complete.
+    validator.release()->StartValidation(
+        base::Bind(callback, key->as_string()));
+  } else {
+    validator->RunValidation();
+
+    UpdatePolicy(key->as_string(), validator.get());
+  }
 }
 
 }  // namespace policy