Don't refresh policy immediately when fetched already.

chrome/browser/policy/cloud_policy_refresh_scheduler_unittest.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 "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 111 matching lines @@
 
 TEST_F(CloudPolicyRefreshSchedulerTest, InitialRefreshUnmanaged) {
   store_.policy_->set_state(em::PolicyData::UNMANAGED);
   scoped_ptr<CloudPolicyRefreshScheduler> scheduler(CreateRefreshScheduler());
   CheckTiming(CloudPolicyRefreshScheduler::kUnmanagedRefreshDelayMs);
   ASSERT_FALSE(last_callback_.is_null());
   EXPECT_CALL(client_, FetchPolicy()).Times(1);
   last_callback_.Run();
 }
 
-TEST_F(CloudPolicyRefreshSchedulerTest, InitialRefreshManaged) {
+TEST_F(CloudPolicyRefreshSchedulerTest, InitialRefreshManagedNotYetFetched) {
   scoped_ptr<CloudPolicyRefreshScheduler> scheduler(CreateRefreshScheduler());
   EXPECT_EQ(last_delay_, base::TimeDelta());
   ASSERT_FALSE(last_callback_.is_null());
   EXPECT_CALL(client_, FetchPolicy()).Times(1);
   last_callback_.Run();
 }
 
+TEST_F(CloudPolicyRefreshSchedulerTest, InitialRefreshManagedAlreadyFetched) {
+  last_refresh_ = base::Time::NowFromSystemTime();
+  client_.SetPolicy(em::PolicyFetchResponse());
+  scoped_ptr<CloudPolicyRefreshScheduler> scheduler(CreateRefreshScheduler());
+  CheckTiming(kPolicyRefreshRate);
+  ASSERT_FALSE(last_callback_.is_null());
+  EXPECT_CALL(client_, FetchPolicy()).Times(1);
+  last_callback_.Run();
+}
+
 TEST_F(CloudPolicyRefreshSchedulerTest, Unregistered) {
   client_.SetDMToken("");
   EXPECT_CALL(*task_runner_, PostDelayedTask(_, _, _)).Times(0);
   scoped_ptr<CloudPolicyRefreshScheduler> scheduler(CreateRefreshScheduler());
   client_.NotifyPolicyFetched();
   client_.NotifyRegistrationStateChanged();
   client_.NotifyClientError();
   store_.NotifyStoreLoaded();
   store_.NotifyStoreError();
   prefs_.SetInteger(prefs::kUserPolicyRefreshRate, 12 * 60 * 60 * 1000);
@@ skipping 99 matching lines @@
     kPolicyRefreshRate, 1 },
 };
 
 class CloudPolicyRefreshSchedulerClientErrorTest
     : public CloudPolicyRefreshSchedulerSteadyStateTest,
       public testing::WithParamInterface<ClientErrorTestParam> {
 };
 
 TEST_P(CloudPolicyRefreshSchedulerClientErrorTest, OnClientError) {
   client_.SetStatus(GetParam().client_error);
+  last_delay_ = base::TimeDelta();
+  last_callback_.Reset();
 
   // See whether the error triggers the right refresh delay.
   int64 expected_delay_ms = GetParam().expected_delay_ms;
-  if (expected_delay_ms == -1)
-    EXPECT_CALL(*task_runner_, PostDelayedTask(_, _, _)).Times(0);
   client_.NotifyClientError();
   if (expected_delay_ms >= 0) {
     CheckTiming(expected_delay_ms);
 
     // Check whether exponential backoff is working as expected and capped at
     // the regular refresh rate (if applicable).
     do {
       expected_delay_ms *= GetParam().backoff_factor;
       last_refresh_ = base::Time::NowFromSystemTime();
       client_.NotifyClientError();
       CheckTiming(std::max(std::min(expected_delay_ms, kPolicyRefreshRate),
                            GetParam().expected_delay_ms));
     } while (GetParam().backoff_factor > 1 &&
              expected_delay_ms <= kPolicyRefreshRate);
+  } else {
+    EXPECT_EQ(base::TimeDelta(), last_delay_);
+    EXPECT_TRUE(last_callback_.is_null());
   }
 }
 
 INSTANTIATE_TEST_CASE_P(CloudPolicyRefreshSchedulerClientErrorTest,
                         CloudPolicyRefreshSchedulerClientErrorTest,
                         testing::ValuesIn(kClientErrorTestCases));
 
 }  // namespace policy