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

chrome/browser/chromeos/settings/device_settings_service.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/settings/device_settings_service.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
@@ skipping 111 matching lines @@
 }
 
 scoped_refptr<PublicKey> DeviceSettingsService::GetPublicKey() {
   return public_key_;
 }
 
 void DeviceSettingsService::Load() {
   EnqueueLoad(false);
 }
 
+void DeviceSettingsService::LoadImmediately() {
+  bool request_key_load = true;
+  bool cloud_validations = true;
+  if (device_mode_ == policy::DEVICE_MODE_ENTERPRISE_AD) {
+    request_key_load = false;
+    cloud_validations = false;
+  }
+  std::unique_ptr<SessionManagerOperation> operation(new LoadSettingsOperation(
+      request_key_load, cloud_validations, true /*force_immediate_load*/,
+      base::Bind(&DeviceSettingsService::HandleCompletedOperation,
+                 weak_factory_.GetWeakPtr(), base::Closure())));
+  operation->Start(session_manager_client_, owner_key_util_, public_key_);
+}
+
 void DeviceSettingsService::Store(
     std::unique_ptr<em::PolicyFetchResponse> policy,
     const base::Closure& callback) {
   // On Active Directory managed devices policy is written only by authpolicyd.
   CHECK(device_mode_ != policy::DEVICE_MODE_ENTERPRISE_AD);
   Enqueue(linked_ptr<SessionManagerOperation>(new StoreSettingsOperation(
-      base::Bind(&DeviceSettingsService::HandleCompletedOperation,
+      base::Bind(&DeviceSettingsService::HandleCompletedAsyncOperation,
                  weak_factory_.GetWeakPtr(), callback),
       std::move(policy))));
 }
 
 DeviceSettingsService::OwnershipStatus
     DeviceSettingsService::GetOwnershipStatus() {
   if (public_key_.get())
     return public_key_->is_loaded() ? OWNERSHIP_TAKEN : OWNERSHIP_NONE;
   if (device_mode_ == policy::DEVICE_MODE_ENTERPRISE_AD)
     return OWNERSHIP_TAKEN;
@@ skipping 77 matching lines @@
     StartNextOperation();
 }
 
 void DeviceSettingsService::EnqueueLoad(bool request_key_load) {
   bool cloud_validations = true;
   if (device_mode_ == policy::DEVICE_MODE_ENTERPRISE_AD) {
     request_key_load = false;
     cloud_validations = false;
   }
   linked_ptr<SessionManagerOperation> operation(new LoadSettingsOperation(
-      request_key_load, cloud_validations,
-      base::Bind(&DeviceSettingsService::HandleCompletedOperation,
+      request_key_load, cloud_validations, false /*force_immediate_load*/,
+      base::Bind(&DeviceSettingsService::HandleCompletedAsyncOperation,
                  weak_factory_.GetWeakPtr(), base::Closure())));
   Enqueue(operation);
 }
 
 void DeviceSettingsService::EnsureReload(bool request_key_load) {
   if (!pending_operations_.empty())
     pending_operations_.front()->RestartLoad(request_key_load);
   else
     EnqueueLoad(request_key_load);
 }
 
 void DeviceSettingsService::StartNextOperation() {
   if (!pending_operations_.empty() && session_manager_client_ &&
       owner_key_util_.get()) {
     pending_operations_.front()->Start(
         session_manager_client_, owner_key_util_, public_key_);
   }
 }
 
+void DeviceSettingsService::HandleCompletedAsyncOperation(
+    const base::Closure& callback,
+    SessionManagerOperation* operation,
+    Status status) {
+  DCHECK_EQ(operation, pending_operations_.front().get());
+  HandleCompletedOperation(callback, operation, status);
+  // Only remove the pending operation here, so new operations triggered by
+  // any of the callbacks above are queued up properly.
+  pending_operations_.pop_front();
+
+  StartNextOperation();
+}
+
 void DeviceSettingsService::HandleCompletedOperation(
     const base::Closure& callback,
     SessionManagerOperation* operation,
     Status status) {
-  DCHECK_EQ(operation, pending_operations_.front().get());
-
   store_status_ = status;
   if (status == STORE_SUCCESS) {
     policy_data_ = std::move(operation->policy_data());
     device_settings_ = std::move(operation->device_settings());
     load_retries_left_ = kMaxLoadRetries;
   } else if (status != STORE_KEY_UNAVAILABLE) {
     LOG(ERROR) << "Session manager operation failed: " << status;
     // Validation errors can be temporary if the rtc has gone on holiday for a
     // short while. So we will retry such loads for up to 10 minutes.
     if (status == STORE_TEMP_VALIDATION_ERROR) {
@@ skipping 18 matching lines @@
     previous_ownership_status_ = GetOwnershipStatus();
     NotifyOwnershipStatusChanged();
   }
   NotifyDeviceSettingsUpdated();
   RunPendingOwnershipStatusCallbacks();
 
   // The completion callback happens after the notification so clients can
   // filter self-triggered updates.
   if (!callback.is_null())
     callback.Run();
-
-  // Only remove the pending operation here, so new operations triggered by any
-  // of the callbacks above are queued up properly.
-  pending_operations_.pop_front();
-
-  StartNextOperation();
 }
 
 void DeviceSettingsService::HandleError(Status status,
                                         const base::Closure& callback) {
   store_status_ = status;
   LOG(ERROR) << "Session manager operation failed: " << status;
   NotifyDeviceSettingsUpdated();
 
   // The completion callback happens after the notification so clients can
   // filter self-triggered updates.
@@ skipping 28 matching lines @@
   DeviceSettingsService::Initialize();
 }
 
 ScopedTestDeviceSettingsService::~ScopedTestDeviceSettingsService() {
   // Clean pending operations.
   DeviceSettingsService::Get()->UnsetSessionManager();
   DeviceSettingsService::Shutdown();
 }
 
 }  // namespace chromeos