Implement cloud policy invalidations using the invalidation service framework.

chrome/browser/policy/cloud/cloud_policy_refresh_scheduler_unittest.cc

Index: chrome/browser/policy/cloud/cloud_policy_refresh_scheduler_unittest.cc
diff --git a/chrome/browser/policy/cloud/cloud_policy_refresh_scheduler_unittest.cc b/chrome/browser/policy/cloud/cloud_policy_refresh_scheduler_unittest.cc
index 36de88ea4e0a149dfe70af660d2e669e388cf36c..f1ce5156e7081f09bbc4c0ae0db358877964ed2b 100644
--- a/chrome/browser/policy/cloud/cloud_policy_refresh_scheduler_unittest.cc
+++ b/chrome/browser/policy/cloud/cloud_policy_refresh_scheduler_unittest.cc
@@ -53,8 +53,14 @@ class CloudPolicyRefreshSchedulerTest : public testing::Test {
   }
 
   CloudPolicyRefreshScheduler* CreateRefreshScheduler() {
+    return CreateRefreshScheduler(true /* invalidations_enabled */);
+  }
+
+  CloudPolicyRefreshScheduler* CreateRefreshScheduler(
+      bool invalidations_enabled) {
     CloudPolicyRefreshScheduler* scheduler =
-        new CloudPolicyRefreshScheduler(&client_, &store_, task_runner_);
+        new CloudPolicyRefreshScheduler(&client_, &store_, task_runner_,
+                                        invalidations_enabled);
     scheduler->SetRefreshDelay(kPolicyRefreshRate);
     return scheduler;
   }
@@ -94,6 +100,16 @@ TEST_F(CloudPolicyRefreshSchedulerTest, InitialRefreshNoPolicy) {
   store_.policy_.reset();
   scoped_ptr<CloudPolicyRefreshScheduler> scheduler(CreateRefreshScheduler());
   EXPECT_FALSE(task_runner_->GetPendingTasks().empty());
+  CheckTiming(CloudPolicyRefreshScheduler::kFirstRefreshDelayMs);
+  EXPECT_CALL(client_, FetchPolicy()).Times(1);
+  task_runner_->RunUntilIdle();
+}
+
+TEST_F(CloudPolicyRefreshSchedulerTest, InitialRefreshNoPolicyNoInvalidations) {
+  store_.policy_.reset();
+  scoped_ptr<CloudPolicyRefreshScheduler> scheduler(CreateRefreshScheduler(
+      false /* invalidations_enabled */));
+  EXPECT_FALSE(task_runner_->GetPendingTasks().empty());
   EXPECT_EQ(GetLastDelay(), base::TimeDelta());
   EXPECT_CALL(client_, FetchPolicy()).Times(1);
   task_runner_->RunUntilIdle();
@@ -110,6 +126,16 @@ TEST_F(CloudPolicyRefreshSchedulerTest, InitialRefreshUnmanaged) {
 TEST_F(CloudPolicyRefreshSchedulerTest, InitialRefreshManagedNotYetFetched) {
   scoped_ptr<CloudPolicyRefreshScheduler> scheduler(CreateRefreshScheduler());
   EXPECT_FALSE(task_runner_->GetPendingTasks().empty());
+  CheckTiming(CloudPolicyRefreshScheduler::kFirstRefreshDelayMs);
+  EXPECT_CALL(client_, FetchPolicy()).Times(1);
+  task_runner_->RunUntilIdle();
+}
+
+TEST_F(CloudPolicyRefreshSchedulerTest,
+       InitialRefreshManagedNotYetFetchedNoInvalidations) {
+  scoped_ptr<CloudPolicyRefreshScheduler> scheduler(CreateRefreshScheduler(
+      false /* invalidations_enabled */));
+  EXPECT_FALSE(task_runner_->GetPendingTasks().empty());
   EXPECT_EQ(GetLastDelay(), base::TimeDelta());
   EXPECT_CALL(client_, FetchPolicy()).Times(1);
   task_runner_->RunUntilIdle();
@@ -138,6 +164,32 @@ TEST_F(CloudPolicyRefreshSchedulerTest, Unregistered) {
   EXPECT_TRUE(task_runner_->GetPendingTasks().empty());
 }
 
+TEST_F(CloudPolicyRefreshSchedulerTest, RefreshSoon) {
+  last_refresh_ = base::Time::NowFromSystemTime();
+  store_.policy_.reset();
+  scoped_ptr<CloudPolicyRefreshScheduler> scheduler(CreateRefreshScheduler());
+  EXPECT_FALSE(task_runner_->GetPendingTasks().empty());
+  CheckTiming(CloudPolicyRefreshScheduler::kFirstRefreshDelayMs);
+  scheduler->RefreshSoon();
+  EXPECT_FALSE(task_runner_->GetPendingTasks().empty());
+  CheckTiming(CloudPolicyRefreshScheduler::kFirstRefreshDelayMs);
+  EXPECT_CALL(client_, FetchPolicy()).Times(1);
+  task_runner_->RunUntilIdle();
+}
+
+TEST_F(CloudPolicyRefreshSchedulerTest, RefreshForInvalidation) {
+  last_refresh_ = base::Time::NowFromSystemTime();
+  store_.policy_.reset();
+  scoped_ptr<CloudPolicyRefreshScheduler> scheduler(CreateRefreshScheduler());
+  EXPECT_FALSE(task_runner_->GetPendingTasks().empty());
+  CheckTiming(CloudPolicyRefreshScheduler::kFirstRefreshDelayMs);
+  scheduler->RefreshForInvalidation();
+  EXPECT_FALSE(task_runner_->GetPendingTasks().empty());
+  EXPECT_EQ(GetLastDelay(), base::TimeDelta());
+  EXPECT_CALL(client_, FetchPolicy()).Times(1);
+  task_runner_->RunUntilIdle();
+}
+
 TEST_F(CloudPolicyRefreshSchedulerTest, RefreshSoonRateLimit) {
   scoped_ptr<CloudPolicyRefreshScheduler> scheduler(CreateRefreshScheduler());
   // Max out the request rate.
@@ -158,7 +210,8 @@ class CloudPolicyRefreshSchedulerSteadyStateTest
     : public CloudPolicyRefreshSchedulerTest {
  protected:
   CloudPolicyRefreshSchedulerSteadyStateTest()
-      : refresh_scheduler_(&client_, &store_, task_runner_) {}
+      : refresh_scheduler_(&client_, &store_, task_runner_,
+                           true /* invalidations_enabled */) {}
 
   virtual void SetUp() OVERRIDE {
     refresh_scheduler_.SetRefreshDelay(kPolicyRefreshRate);
@@ -179,7 +232,7 @@ TEST_F(CloudPolicyRefreshSchedulerSteadyStateTest, OnPolicyFetched) {
 TEST_F(CloudPolicyRefreshSchedulerSteadyStateTest, OnRegistrationStateChanged) {
   client_.SetDMToken("new_token");
   client_.NotifyRegistrationStateChanged();
-  EXPECT_EQ(GetLastDelay(), base::TimeDelta());
+  CheckTiming(CloudPolicyRefreshScheduler::kFirstRefreshDelayMs);
 
   task_runner_->ClearPendingTasks();
   client_.SetDMToken(std::string());
@@ -218,7 +271,7 @@ TEST_F(CloudPolicyRefreshSchedulerSteadyStateTest, OnIPAddressChanged) {
 
   client_.SetStatus(DM_STATUS_REQUEST_FAILED);
   NotifyIPAddressChanged();
-  EXPECT_EQ(GetLastDelay(), base::TimeDelta());
+  CheckTiming(CloudPolicyRefreshScheduler::kFirstRefreshDelayMs);
 }
 
 struct ClientErrorTestParam {