Implement cloud policy invalidations using the invalidation service framework.

chrome/browser/policy/cloud/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/message_loop.h"
 #include "base/test/test_simple_task_runner.h"
@@ skipping 35 matching lines @@
     store_.policy_.reset(new em::PolicyData());
     store_.policy_->set_timestamp(
         ((base::Time::NowFromSystemTime() - base::TimeDelta::FromMinutes(1)) -
          base::Time::UnixEpoch()).InMilliseconds());
     last_refresh_ =
         base::Time::UnixEpoch() +
         base::TimeDelta::FromMilliseconds(store_.policy_->timestamp());
   }
 
   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;
   }
 
   void NotifyIPAddressChanged() {
     net::NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
     loop_.RunUntilIdle();
   }
 
   base::TimeDelta GetLastDelay() const {
@@ skipping 19 matching lines @@
   scoped_ptr<net::NetworkChangeNotifier> network_change_notifier_;
 
   // Base time for the refresh that the scheduler should be using.
   base::Time last_refresh_;
 };
 
 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();
 }
 
 TEST_F(CloudPolicyRefreshSchedulerTest, InitialRefreshUnmanaged) {
   store_.policy_->set_state(em::PolicyData::UNMANAGED);
   scoped_ptr<CloudPolicyRefreshScheduler> scheduler(CreateRefreshScheduler());
   CheckTiming(CloudPolicyRefreshScheduler::kUnmanagedRefreshDelayMs);
   EXPECT_CALL(client_, FetchPolicy()).Times(1);
   task_runner_->RunUntilIdle();
 }
 
 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();
 }
 
 TEST_F(CloudPolicyRefreshSchedulerTest, InitialRefreshManagedAlreadyFetched) {
   last_refresh_ = base::Time::NowFromSystemTime();
   client_.SetPolicy(PolicyNamespaceKey(dm_protocol::kChromeUserPolicyType,
                                        std::string()),
       em::PolicyFetchResponse());
   scoped_ptr<CloudPolicyRefreshScheduler> scheduler(CreateRefreshScheduler());
   CheckTiming(kPolicyRefreshRate);
   EXPECT_CALL(client_, FetchPolicy()).Times(1);
   task_runner_->RunUntilIdle();
 }
 
 TEST_F(CloudPolicyRefreshSchedulerTest, Unregistered) {
   client_.SetDMToken(std::string());
   scoped_ptr<CloudPolicyRefreshScheduler> scheduler(CreateRefreshScheduler());
   client_.NotifyPolicyFetched();
   client_.NotifyRegistrationStateChanged();
   client_.NotifyClientError();
   scheduler->SetRefreshDelay(12 * 60 * 60 * 1000);
   store_.NotifyStoreLoaded();
   store_.NotifyStoreError();
   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.
   for (int i = 0; i < 5; ++i) {
     EXPECT_CALL(client_, FetchPolicy()).Times(1);
     scheduler->RefreshSoon();
     task_runner_->RunUntilIdle();
     Mock::VerifyAndClearExpectations(&client_);
   }
   // The next refresh is throttled.
   EXPECT_CALL(client_, FetchPolicy()).Times(0);
   scheduler->RefreshSoon();
   task_runner_->RunPendingTasks();
   Mock::VerifyAndClearExpectations(&client_);
 }
 
 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);
     CloudPolicyRefreshSchedulerTest::SetUp();
     last_refresh_ = base::Time::NowFromSystemTime();
     client_.NotifyPolicyFetched();
     CheckTiming(kPolicyRefreshRate);
   }
 
   CloudPolicyRefreshScheduler refresh_scheduler_;
 };
 
 TEST_F(CloudPolicyRefreshSchedulerSteadyStateTest, OnPolicyFetched) {
   client_.NotifyPolicyFetched();
   CheckTiming(kPolicyRefreshRate);
 }
 
 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());
   client_.NotifyRegistrationStateChanged();
   EXPECT_TRUE(task_runner_->GetPendingTasks().empty());
 }
 
 TEST_F(CloudPolicyRefreshSchedulerSteadyStateTest, OnStoreLoaded) {
   store_.NotifyStoreLoaded();
   CheckTiming(kPolicyRefreshRate);
@@ skipping 18 matching lines @@
   refresh_scheduler_.SetRefreshDelay(delay_long_ms);
   CheckTiming(CloudPolicyRefreshScheduler::kRefreshDelayMaxMs);
 }
 
 TEST_F(CloudPolicyRefreshSchedulerSteadyStateTest, OnIPAddressChanged) {
   NotifyIPAddressChanged();
   CheckTiming(kPolicyRefreshRate);
 
   client_.SetStatus(DM_STATUS_REQUEST_FAILED);
   NotifyIPAddressChanged();
-  EXPECT_EQ(GetLastDelay(), base::TimeDelta());
+  CheckTiming(CloudPolicyRefreshScheduler::kFirstRefreshDelayMs);
 }
 
 struct ClientErrorTestParam {
   DeviceManagementStatus client_error;
   int64 expected_delay_ms;
   int backoff_factor;
 };
 
 static const ClientErrorTestParam kClientErrorTestCases[] = {
   { DM_STATUS_REQUEST_INVALID,
@@ skipping 53 matching lines @@
     EXPECT_EQ(base::TimeDelta(), GetLastDelay());
     EXPECT_TRUE(task_runner_->GetPendingTasks().empty());
   }
 }
 
 INSTANTIATE_TEST_CASE_P(CloudPolicyRefreshSchedulerClientErrorTest,
                         CloudPolicyRefreshSchedulerClientErrorTest,
                         testing::ValuesIn(kClientErrorTestCases));
 
 }  // namespace policy