Reland: No longer start up profile if there was an error fetching policy.

chrome/browser/chromeos/policy/user_cloud_policy_manager_factory_chromeos.cc

 // Copyright (c) 2013 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/user_cloud_policy_manager_factory_chromeos.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 131 matching lines @@
   if (!user->HasGaiaAccount() ||
       user->IsSupervised() ||
       BrowserPolicyConnector::IsNonEnterpriseUser(username)) {
     return scoped_ptr<UserCloudPolicyManagerChromeOS>();
   }
 
   policy::BrowserPolicyConnectorChromeOS* connector =
       g_browser_process->platform_part()->browser_policy_connector_chromeos();
   const bool is_browser_restart =
       command_line->HasSwitch(chromeos::switches::kLoginUser);
-  const bool wait_for_initial_policy = !is_browser_restart;
+  const user_manager::UserManager* const user_manager =
+      user_manager::UserManager::Get();
 
-  const base::TimeDelta initial_policy_fetch_timeout =
-      user_manager::UserManager::Get()->IsCurrentUserNew()
-          ? base::TimeDelta::Max()
-          : base::TimeDelta::FromSeconds(kInitialPolicyFetchTimeoutSeconds);
+  // We want to block for policy in a few situations: if the user is new, or
+  // if we are forcing an online signin. An online signin will be forced if
+  // there has been a credential error, or if the initial session creation
+  // was not completed (the oauth_token_status is not set to valid by
+  // OAuth2LoginManager until profile creation/session restore is complete).
+  const bool block_forever_for_policy =
+      !user_manager->IsLoggedInAsStub() &&
+      (user_manager->IsCurrentUserNew() ||
+       user_manager->GetActiveUser()->force_online_signin() ||
+       user_manager->GetActiveUser()->oauth_token_status() !=
+           user_manager::User::OAUTH2_TOKEN_STATUS_VALID);
+
+  const bool wait_for_policy_fetch =
+      block_forever_for_policy || !is_browser_restart;
+
+  base::TimeDelta initial_policy_fetch_timeout;
+  if (block_forever_for_policy) {
+    initial_policy_fetch_timeout = base::TimeDelta::Max();
+  } else if (wait_for_policy_fetch) {
+    initial_policy_fetch_timeout =
+        base::TimeDelta::FromSeconds(kInitialPolicyFetchTimeoutSeconds);
+  }
 
   DeviceManagementService* device_management_service =
       connector->device_management_service();
-  if (wait_for_initial_policy)
+  if (wait_for_policy_fetch)
     device_management_service->ScheduleInitialization(0);
 
   base::FilePath profile_dir = profile->GetPath();
   const base::FilePath legacy_dir = profile_dir.Append(kDeviceManagementDir);
   const base::FilePath policy_cache_file = legacy_dir.Append(kPolicy);
   const base::FilePath token_cache_file = legacy_dir.Append(kToken);
   const base::FilePath component_policy_cache_dir =
       profile_dir.Append(kPolicy).Append(kComponentsDir);
   const base::FilePath external_data_dir =
         profile_dir.Append(kPolicy).Append(kPolicyExternalDataDir);
@@ skipping 22 matching lines @@
   if (force_immediate_load)
     store->LoadImmediately();
 
   scoped_refptr<base::SequencedTaskRunner> file_task_runner =
       content::BrowserThread::GetMessageLoopProxyForThread(
           content::BrowserThread::FILE);
 
   scoped_ptr<UserCloudPolicyManagerChromeOS> manager(
       new UserCloudPolicyManagerChromeOS(
           std::move(store), std::move(external_data_manager),
-          component_policy_cache_dir, wait_for_initial_policy,
+          component_policy_cache_dir, wait_for_policy_fetch,
           initial_policy_fetch_timeout, base::ThreadTaskRunnerHandle::Get(),
           file_task_runner, io_task_runner));
 
   bool wildcard_match = false;
   if (connector->IsEnterpriseManaged() &&
       chromeos::CrosSettings::IsWhitelisted(username, &wildcard_match) &&
       wildcard_match && !connector->IsNonEnterpriseUser(username)) {
     manager->EnableWildcardLoginCheck(username);
   }
 
@@ skipping 29 matching lines @@
 
 bool UserCloudPolicyManagerFactoryChromeOS::HasTestingFactory(
     content::BrowserContext* context) {
   return false;
 }
 
 void UserCloudPolicyManagerFactoryChromeOS::CreateServiceNow(
     content::BrowserContext* context) {}
 
 }  // namespace policy