UserPolicyCache only becomes ready after policy has been fetched.

chrome/browser/policy/browser_policy_connector.cc

 // Copyright (c) 2011 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/policy/browser_policy_connector.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/path_service.h"
@@ skipping 214 matching lines @@
         ScheduleServiceInitialization(delay_milliseconds);
   }
 #if defined(OS_CHROMEOS)
   if (device_cloud_policy_subsystem_.get()) {
     device_cloud_policy_subsystem_->
         ScheduleServiceInitialization(delay_milliseconds);
   }
 #endif
 }
 void BrowserPolicyConnector::InitializeUserPolicy(
-    const std::string& user_name) {
+    const std::string& user_name,
+    bool wait_for_policy_fetch) {
   // Throw away the old backend.
   user_cloud_policy_subsystem_.reset();
   user_policy_token_cache_.reset();
   user_data_store_.reset();
   token_service_ = NULL;
   registrar_.RemoveAll();
 
   CommandLine* command_line = CommandLine::ForCurrentProcess();
 
   FilePath policy_dir;
   PathService::Get(chrome::DIR_USER_DATA, &policy_dir);
 #if defined(OS_CHROMEOS)
   policy_dir = policy_dir.Append(
       command_line->GetSwitchValuePath(switches::kLoginProfile));
 #endif
 
   if (command_line->HasSwitch(switches::kDeviceManagementUrl)) {
     FilePath policy_cache_dir = policy_dir.Append(kPolicyDir);
+
     UserPolicyCache* user_policy_cache =
-        new UserPolicyCache(policy_cache_dir.Append(kPolicyCacheFile));
+        new UserPolicyCache(policy_cache_dir.Append(kPolicyCacheFile),
+                            wait_for_policy_fetch);
     user_data_store_.reset(CloudPolicyDataStore::CreateForUserPolicies());
     user_policy_token_cache_.reset(
         new UserPolicyTokenCache(user_data_store_.get(),
                                  policy_cache_dir.Append(kTokenCacheFile)));
 
     // Prepending user caches meaning they will take precedence of device policy
     // caches.
     managed_cloud_provider_->PrependCache(user_policy_cache);
     recommended_cloud_provider_->PrependCache(user_policy_cache);
     user_cloud_policy_subsystem_.reset(new CloudPolicySubsystem(
         user_data_store_.get(),
         user_policy_cache));
 
     // Initiate the DM-Token load.
     user_policy_token_cache_->Load();
 
     user_data_store_->set_user_name(user_name);
     user_data_store_->set_user_affiliation(GetUserAffiliation(user_name));
 
+    int64 delay =
+        wait_for_policy_fetch ? 0 : kServiceInitializationStartupDelay;
     user_cloud_policy_subsystem_->CompleteInitialization(
         prefs::kUserPolicyRefreshRate,
-        kServiceInitializationStartupDelay);
+        delay);
   }
 }
 
 void BrowserPolicyConnector::SetUserPolicyTokenService(
     TokenService* token_service) {
   token_service_ = token_service;
   registrar_.Add(this,
                  chrome::NOTIFICATION_TOKEN_AVAILABLE,
                  content::Source<TokenService>(token_service_));
 
   if (token_service_->HasTokenForService(
           GaiaConstants::kDeviceManagementService)) {
     user_data_store_->SetGaiaToken(token_service_->GetTokenForService(
         GaiaConstants::kDeviceManagementService));
   }
 }
 
 void BrowserPolicyConnector::RegisterForUserPolicy(
     const std::string& oauth_token) {
-  if (user_data_store_.get())
-    user_data_store_->SetOAuthToken(oauth_token);
+  if (oauth_token.empty()) {
+    // An attempt to fetch the dm service oauth token has failed. Notify
+    // the user policy cache of this, so that a potential blocked login
+    // proceeds without waiting for user policy.
+    if (user_cloud_policy_subsystem_.get()) {
+      user_cloud_policy_subsystem_->GetCloudPolicyCacheBase()->
+          SetFetchingDone();
+    }
+  } else {
+    if (user_data_store_.get())
+      user_data_store_->SetOAuthToken(oauth_token);
+  }
 }
 
 const CloudPolicyDataStore*
     BrowserPolicyConnector::GetDeviceCloudPolicyDataStore() const {
 #if defined(OS_CHROMEOS)
   return device_data_store_.get();
 #else
   return NULL;
 #endif
 }
 
 const CloudPolicyDataStore*
     BrowserPolicyConnector::GetUserCloudPolicyDataStore() const {
   return user_data_store_.get();
 }
 
 const ConfigurationPolicyHandlerList*
     BrowserPolicyConnector::GetHandlerList() const {
   return &handler_list_;
 }
 
+CloudPolicyDataStore::UserAffiliation
+    BrowserPolicyConnector::GetUserAffiliation(const std::string& user_name) {
+#if defined(OS_CHROMEOS)
+  if (install_attributes_.get()) {
+    size_t pos = user_name.find('@');
+    if (pos != std::string::npos &&
+        user_name.substr(pos + 1) == install_attributes_->GetDomain()) {
+      return CloudPolicyDataStore::USER_AFFILIATION_MANAGED;
+    }
+  }
+#endif
+
+  return CloudPolicyDataStore::USER_AFFILIATION_NONE;
+}
+
 BrowserPolicyConnector::BrowserPolicyConnector()
     : ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {
   managed_platform_provider_.reset(CreateManagedPlatformProvider());
   recommended_platform_provider_.reset(CreateRecommendedPlatformProvider());
 
   managed_cloud_provider_.reset(new CloudPolicyProviderImpl(
       GetChromePolicyDefinitionList(),
       CloudPolicyCacheBase::POLICY_LEVEL_MANDATORY));
   recommended_cloud_provider_.reset(new CloudPolicyProviderImpl(
       GetChromePolicyDefinitionList(),
@@ skipping 79 matching lines @@
 void BrowserPolicyConnector::InitializeDevicePolicySubsystem() {
 #if defined(OS_CHROMEOS)
   if (device_cloud_policy_subsystem_.get()) {
     device_cloud_policy_subsystem_->CompleteInitialization(
         prefs::kDevicePolicyRefreshRate,
         kServiceInitializationStartupDelay);
   }
 #endif
 }
 
-CloudPolicyDataStore::UserAffiliation
-    BrowserPolicyConnector::GetUserAffiliation(const std::string& user_name) {
-#if defined(OS_CHROMEOS)
-  if (install_attributes_.get()) {
-    size_t pos = user_name.find('@');
-    if (pos != std::string::npos &&
-        user_name.substr(pos + 1) == install_attributes_->GetDomain()) {
-      return CloudPolicyDataStore::USER_AFFILIATION_MANAGED;
-    }
-  }
-#endif
-
-  return CloudPolicyDataStore::USER_AFFILIATION_NONE;
-}
-
 // static
 BrowserPolicyConnector* BrowserPolicyConnector::CreateForTests() {
   return new BrowserPolicyConnector(NULL, NULL, NULL, NULL);
 }
 
 // static
 ConfigurationPolicyProvider*
     BrowserPolicyConnector::CreateManagedPlatformProvider() {
   const PolicyDefinitionList* policy_list = GetChromePolicyDefinitionList();
 #if defined(OS_WIN)
@@ skipping 26 matching lines @@
         config_dir_path.Append(FILE_PATH_LITERAL("recommended")));
   } else {
     return NULL;
   }
 #else
   return NULL;
 #endif
 }
 
 }  // namespace policy