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() {
+  loading_immediately_ = true;

[Andrew T Wilson (Slow), 2017/02/23 12:05:48]

Can we get rid of this data member and instead pass this in as a flag to
HandleCompletedOperation (bind it in the callback below)? It's kind of weird to
have this state flag hanging around.

[Sergey Poromov, 2017/02/28 14:01:17]

Done.

+  std::unique_ptr<SessionManagerOperation> operation(new LoadSettingsOperation(

[emaxx, 2017/02/22 17:24:33]

Should the same check for "device_mode_ == policy::DEVICE_MODE_ENTERPRISE_AD" be
done here as in DeviceSettingsService::EnqueueLoad()?

[Sergey Poromov, 2017/02/28 14:01:17]

Expect so, but needs review from tnagel@ for ActiveDirectory part of code.

[emaxx, 2017/02/28 14:31:31]

Yes, please ask Thiemo to pay special attention to this piece of code.

[Thiemo Nagel, 2017/02/28 15:41:05]

Yes!

+      true /*force_key_load*/, true /*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,
                  weak_factory_.GetWeakPtr(), callback),
       std::move(policy))));
 }
@@ skipping 84 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,
+      request_key_load, cloud_validations, false /*force_immediate_load*/,

[Thiemo Nagel, 2017/02/28 15:41:05]

Nit: pls add blanks: /* force_immediate_load */

       base::Bind(&DeviceSettingsService::HandleCompletedOperation,
                  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::HandleCompletedOperation(
     const base::Closure& callback,
     SessionManagerOperation* operation,
     Status status) {
-  DCHECK_EQ(operation, pending_operations_.front().get());
+  if (!loading_immediately_)
+    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.
@@ skipping 20 matching lines @@
     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();
+  if (!loading_immediately_) {

[emaxx, 2017/02/22 17:24:33]

Could we have a separate method for the async operation instead?
It would call the method with the common functionality (which is in lines
274..311 currently) and additionally do everything that is needed for the
asynchronous case.

[Andrew T Wilson (Slow), 2017/02/23 12:05:48]

Yes, I'd either do this, or else bind a boolean into this callback. But agreed
it's probably cleanest to have two callbacks.

[Sergey Poromov, 2017/02/28 14:01:17]

Done.

[Sergey Poromov, 2017/02/28 14:01:17]

Done.

+    // 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();
+    StartNextOperation();
+  }
+  loading_immediately_ = false;
 }
 
 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