Put a hard limit on initial policy fetch wait time.

chrome/browser/chromeos/policy/user_cloud_policy_manager_chromeos.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/user_cloud_policy_manager_chromeos.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop_proxy.h"
@@ skipping 33 matching lines @@
 const char kUMAInitialFetchOAuth2Error[] =
     "Enterprise.UserPolicyChromeOS.InitialFetch.OAuth2Error";
 const char kUMAInitialFetchOAuth2NetworkError[] =
     "Enterprise.UserPolicyChromeOS.InitialFetch.OAuth2NetworkError";
 
 }  // namespace
 
 UserCloudPolicyManagerChromeOS::UserCloudPolicyManagerChromeOS(
     scoped_ptr<CloudPolicyStore> store,
     scoped_ptr<ResourceCache> resource_cache,
-    bool wait_for_policy_fetch)
+    bool wait_for_policy_fetch,
+    base::TimeDelta initial_policy_fetch_timeout)
     : CloudPolicyManager(
           PolicyNamespaceKey(dm_protocol::kChromeUserPolicyType, std::string()),
           store.get()),
       store_(store.Pass()),
-      wait_for_policy_fetch_(wait_for_policy_fetch) {
+      wait_for_policy_fetch_(wait_for_policy_fetch),
+      policy_fetch_timeout_(false, false) {
   time_init_started_ = base::Time::Now();
+  if (wait_for_policy_fetch_) {
+    policy_fetch_timeout_.Start(
+        FROM_HERE,
+        initial_policy_fetch_timeout,
+        base::Bind(&UserCloudPolicyManagerChromeOS::CancelWaitForPolicyFetch,
+                   base::Unretained(this)));
+  }
   if (resource_cache) {
     // TODO(joaodasilva): Move the backend from the FILE thread to the blocking
     // pool.
     component_policy_service_.reset(new ComponentCloudPolicyService(
         this,
         store_.get(),
         resource_cache.Pass(),
         content::BrowserThread::GetMessageLoopProxyForThread(
             content::BrowserThread::FILE),
         content::BrowserThread::GetMessageLoopProxyForThread(
@@ skipping 228 matching lines @@
     bool success) {
 
   const base::Time now = base::Time::Now();
   UMA_HISTOGRAM_TIMES(kUMAInitialFetchDelayPolicyFetch,
                       now - time_client_registered_);
   UMA_HISTOGRAM_TIMES(kUMAInitialFetchDelayTotal, now - time_init_started_);
   CancelWaitForPolicyFetch();
 }
 
 void UserCloudPolicyManagerChromeOS::CancelWaitForPolicyFetch() {
+  if (!wait_for_policy_fetch_)
+    return;
+
   wait_for_policy_fetch_ = false;
   CheckAndPublishPolicy();
   // Now that |wait_for_policy_fetch_| is guaranteed to be false, the scheduler
   // can be started.
   StartRefreshSchedulerIfReady();
 }
 
 void UserCloudPolicyManagerChromeOS::StartRefreshSchedulerIfReady() {
   if (core()->refresh_scheduler())
     return;  // Already started.
@@ skipping 10 matching lines @@
     // start the scheduler. The |component_policy_service_| will call back into
     // OnComponentCloudPolicyUpdated() once it's ready.
     return;
   }
 
   StartRefreshScheduler();
   core()->TrackRefreshDelayPref(local_state_, prefs::kUserPolicyRefreshRate);
 }
 
 }  // namespace policy