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

chrome/browser/chromeos/policy/device_local_account_policy_provider.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_provider.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
@@ skipping 27 matching lines @@
 }
 
 DeviceLocalAccountPolicyProvider::~DeviceLocalAccountPolicyProvider() {
   service_->RemoveObserver(this);
 }
 
 // static
 std::unique_ptr<DeviceLocalAccountPolicyProvider>
 DeviceLocalAccountPolicyProvider::Create(
     const std::string& user_id,
-    DeviceLocalAccountPolicyService* device_local_account_policy_service) {
+    DeviceLocalAccountPolicyService* device_local_account_policy_service,
+    bool force_immediate_load) {
   DeviceLocalAccount::Type type;
   if (!device_local_account_policy_service ||
       !IsDeviceLocalAccountUser(user_id, &type)) {
     return std::unique_ptr<DeviceLocalAccountPolicyProvider>();
   }
 
   std::unique_ptr<PolicyMap> chrome_policy_overrides;
   if (type == DeviceLocalAccount::TYPE_PUBLIC_SESSION) {
     chrome_policy_overrides.reset(new PolicyMap());
 
@@ skipping 23 matching lines @@
     chrome_policy_overrides->Set(
         key::kFullscreenAllowed, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
         POLICY_SOURCE_PUBLIC_SESSION_OVERRIDE,
         base::MakeUnique<base::FundamentalValue>(false), nullptr);
   }
 
   std::unique_ptr<DeviceLocalAccountPolicyProvider> provider(
       new DeviceLocalAccountPolicyProvider(user_id,
                                            device_local_account_policy_service,
                                            std::move(chrome_policy_overrides)));
+  if (force_immediate_load)
+    provider->GetBroker()->LoadImmediately();

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

See my comment in Store->LoadImmediately() - it's a bit weird that we're issuing
both an asynchronous *and* a synchronous store load. Ideally we'd avoid the
asynchronous load if we're gonna do a sync load, or at least ignore the result
from the async load.

   return provider;
 }
 
 bool DeviceLocalAccountPolicyProvider::IsInitializationComplete(
     PolicyDomain domain) const {
   if (domain == POLICY_DOMAIN_CHROME)
     return store_initialized_;
   if (ComponentCloudPolicyService::SupportsDomain(domain) &&
       GetBroker() && GetBroker()->component_policy_service()) {
     return GetBroker()->component_policy_service()->is_initialized();
@@ skipping 69 matching lines @@
       const PolicyMap::Entry& entry = policy_override.second;
       chrome_policy.Set(policy_override.first, entry.level, entry.scope,
                         entry.source, entry.value->CreateDeepCopy(), nullptr);
     }
   }
 
   UpdatePolicy(std::move(bundle));
 }
 
 }  // namespace policy