Reduce unneeded policy fetches by detecting expired invalidations.

chrome/browser/policy/cloud/cloud_policy_invalidator_unittest.cc

 // Copyright 2013 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 <string>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 65 matching lines @@
 
   // Disconnects the cloud policy core.
   void DisconnectCore();
 
   // Simulates storing a new policy to the policy store.
   // |object| determines which policy object the store will report the
   // invalidator should register for. May be POLICY_OBJECT_NONE for no object.
   // |invalidation_version| determines what invalidation the store will report.
   // |policy_changed| determines whether a policy value different from the
   // current value will be stored.
-  // |timestamp| determines the response timestamp the store will report.
+  // |time| determines the timestamp the store will report.
   void StorePolicy(
       PolicyObject object,
       int64 invalidation_version,
       bool policy_changed,
-      int64 timestamp);
+      base::Time time);
   void StorePolicy(
       PolicyObject object,
       int64 invalidation_version,
       bool policy_changed) {
-    StorePolicy(object, invalidation_version, policy_changed, ++timestamp_);
+    StorePolicy(object,
+                invalidation_version,
+                policy_changed,
+                Now() - base::TimeDelta::FromMinutes(5));
   }
   void StorePolicy(PolicyObject object, int64 invalidation_version) {
     StorePolicy(object, invalidation_version, false);
   }
   void StorePolicy(PolicyObject object) {
     StorePolicy(object, 0);
   }
 
   // Disables the invalidation service. It is enabled by default.
   void DisableInvalidationService();
@@ skipping 32 matching lines @@
   // Determines if the invalidation with the given ack handle has been
   // acknowledged.
   bool IsInvalidationAcknowledged(const syncer::Invalidation& invalidation);
 
   // Determines if the invalidator has registered for an object with the
   // invalidation service.
   bool IsInvalidatorRegistered();
 
   // Get the current count for the given metric.
   base::HistogramBase::Count GetCount(MetricPolicyRefresh metric);
-  base::HistogramBase::Count GetInvalidationCount(bool with_payload);
+  base::HistogramBase::Count GetInvalidationCount(PolicyInvalidationType type);
 
   // Advance the test clock.
   void AdvanceClock(base::TimeDelta delta);
 
+  // Get the current time on the test clock.
+  base::Time Now();
+
+  // Translate a version number into an appropriate invalidation version (which
+  // is based on the current time).
+  int64 V(int version);
+
+  // Get an invalidation version for the given time.
+  int64 GetVersion(base::Time time);
+
  private:
   // Checks that the policy was refreshed due to an invalidation with the given
   // base delay.
   bool CheckPolicyRefreshed(base::TimeDelta delay);
 
   // Checks that the policy was refreshed the given number of times.
   bool CheckPolicyRefreshCount(int count);
 
   // Returns the object id of the given policy object.
   const invalidation::ObjectId& GetPolicyObjectId(PolicyObject object) const;
@@ skipping 12 matching lines @@
   scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
   base::SimpleTestClock* clock_;
 
   // The invalidator which will be tested.
   scoped_ptr<CloudPolicyInvalidator> invalidator_;
 
   // Object ids for the test policy objects.
   invalidation::ObjectId object_id_a_;
   invalidation::ObjectId object_id_b_;
 
-  // Increasing policy timestamp.
-  int64 timestamp_;
-
   // Fake policy values which are alternated to cause the store to report a
   // changed policy.
   const char* policy_value_a_;
   const char* policy_value_b_;
 
   // The currently used policy value.
   const char* policy_value_cur_;
 
   // Stores starting histogram counts for kMetricPolicyRefresh.
   scoped_ptr<base::HistogramSamples> refresh_samples_;
 
   // Stores starting histogram counts for kMetricPolicyInvalidations.
   scoped_ptr<base::HistogramSamples> invalidations_samples_;
 };
 
 CloudPolicyInvalidatorTest::CloudPolicyInvalidatorTest()
     : core_(PolicyNamespaceKey(dm_protocol::kChromeUserPolicyType,
                                std::string()),
             &store_,
             loop_.message_loop_proxy()),
       client_(NULL),
       task_runner_(new base::TestSimpleTaskRunner()),
       clock_(new base::SimpleTestClock()),
       object_id_a_(135, "asdf"),
       object_id_b_(246, "zxcv"),
-      timestamp_(123456),
       policy_value_a_("asdf"),
       policy_value_b_("zxcv"),
-      policy_value_cur_(policy_value_a_) {}
+      policy_value_cur_(policy_value_a_) {
+  clock_->SetNow(
+      base::Time::UnixEpoch() + base::TimeDelta::FromSeconds(987654321));
+}
 
 void CloudPolicyInvalidatorTest::SetUp() {
   base::StatisticsRecorder::Initialize();
   refresh_samples_ = GetHistogramSamples(kMetricPolicyRefresh);
   invalidations_samples_ = GetHistogramSamples(kMetricPolicyInvalidations);
 }
 
 void CloudPolicyInvalidatorTest::TearDown() {
   if (invalidator_)
     invalidator_->Shutdown();
@@ skipping 39 matching lines @@
 
 void CloudPolicyInvalidatorTest::DisconnectCore() {
   client_ = NULL;
   core_.Disconnect();
 }
 
 void CloudPolicyInvalidatorTest::StorePolicy(
     PolicyObject object,
     int64 invalidation_version,
     bool policy_changed,
-    int64 timestamp) {
+    base::Time time) {
   enterprise_management::PolicyData* data =
       new enterprise_management::PolicyData();
   if (object != POLICY_OBJECT_NONE) {
     data->set_invalidation_source(GetPolicyObjectId(object).source());
     data->set_invalidation_name(GetPolicyObjectId(object).name());
   }
-  data->set_timestamp(timestamp);
+  data->set_timestamp((time - base::Time::UnixEpoch()).InMilliseconds());
   // Swap the policy value if a policy change is desired.
   if (policy_changed)
     policy_value_cur_ = policy_value_cur_ == policy_value_a_ ?
         policy_value_b_ : policy_value_a_;
   data->set_policy_value(policy_value_cur_);
   store_.invalidation_version_ = invalidation_version;
   store_.policy_.reset(data);
   base::DictionaryValue policies;
   policies.SetInteger(
       key::kMaxInvalidationFetchDelay,
@@ skipping 81 matching lines @@
       .GetRegisteredIds(invalidator_.get()).empty();
 }
 
 base::HistogramBase::Count CloudPolicyInvalidatorTest::GetCount(
     MetricPolicyRefresh metric) {
   return GetHistogramSamples(kMetricPolicyRefresh)->GetCount(metric) -
       refresh_samples_->GetCount(metric);
 }
 
 base::HistogramBase::Count CloudPolicyInvalidatorTest::GetInvalidationCount(
-    bool with_payload) {
-  int metric = with_payload ? 1 : 0;
-  return GetHistogramSamples(kMetricPolicyInvalidations)->GetCount(metric) -
-      invalidations_samples_->GetCount(metric);
+    PolicyInvalidationType type) {
+  return GetHistogramSamples(kMetricPolicyInvalidations)->GetCount(type) -
+      invalidations_samples_->GetCount(type);
 }
 
 void CloudPolicyInvalidatorTest::AdvanceClock(base::TimeDelta delta) {
   clock_->Advance(delta);
 }
 
+base::Time CloudPolicyInvalidatorTest::Now() {
+  return clock_->Now();
+}
+
+int64 CloudPolicyInvalidatorTest::V(int version) {
+  return GetVersion(Now()) + version;
+}
+
+int64 CloudPolicyInvalidatorTest::GetVersion(base::Time time) {
+  return (time - base::Time::UnixEpoch()).InMicroseconds();
+}
+
 bool CloudPolicyInvalidatorTest::CheckPolicyRefreshed(base::TimeDelta delay) {
   base::TimeDelta max_delay = delay + base::TimeDelta::FromMilliseconds(
       CloudPolicyInvalidator::kMaxFetchDelayMin);
 
   if (task_runner_->GetPendingTasks().empty())
     return false;
   base::TimeDelta actual_delay = task_runner_->GetPendingTasks().back().delay;
   EXPECT_GE(actual_delay, delay);
   EXPECT_LE(actual_delay, max_delay);
 
@@ skipping 162 matching lines @@
   FireUnknownVersionInvalidation(POLICY_OBJECT_B);
   EXPECT_TRUE(CheckPolicyRefreshedWithUnknownVersion());
 }
 
 TEST_F(CloudPolicyInvalidatorTest, HandleInvalidation) {
   // Register and fire invalidation
   StorePolicy(POLICY_OBJECT_A);
   StartInvalidator();
   EXPECT_TRUE(InvalidationsEnabled());
   syncer::Invalidation inv =
-      FireInvalidation(POLICY_OBJECT_A, 12, "test_payload");
+      FireInvalidation(POLICY_OBJECT_A, V(12), "test_payload");
 
   // Make sure client info is set as soon as the invalidation is received.
-  EXPECT_TRUE(CheckInvalidationInfo(12, "test_payload"));
+  EXPECT_TRUE(CheckInvalidationInfo(V(12), "test_payload"));
   EXPECT_TRUE(CheckPolicyRefreshed());
 
   // Make sure invalidation is not acknowledged until the store is loaded.
   EXPECT_FALSE(IsInvalidationAcknowledged(inv));
-  EXPECT_TRUE(CheckInvalidationInfo(12, "test_payload"));
-  StorePolicy(POLICY_OBJECT_A, 12);
+  EXPECT_TRUE(CheckInvalidationInfo(V(12), "test_payload"));
+  StorePolicy(POLICY_OBJECT_A, V(12));
   EXPECT_TRUE(IsInvalidationAcknowledged(inv));
   EXPECT_TRUE(CheckInvalidationInfo(0, std::string()));
 }
 
 TEST_F(CloudPolicyInvalidatorTest, HandleInvalidationWithUnknownVersion) {
   // Register and fire invalidation with unknown version.
   StorePolicy(POLICY_OBJECT_A);
   StartInvalidator();
   syncer::Invalidation inv = FireUnknownVersionInvalidation(POLICY_OBJECT_A);
 
   // Make sure client info is not set until after the invalidation callback is
   // made.
   EXPECT_TRUE(CheckInvalidationInfo(0, std::string()));
   EXPECT_TRUE(CheckPolicyRefreshedWithUnknownVersion());
   EXPECT_TRUE(CheckInvalidationInfo(-1, std::string()));
 
   // Make sure invalidation is not acknowledged until the store is loaded.
   EXPECT_FALSE(IsInvalidationAcknowledged(inv));
   StorePolicy(POLICY_OBJECT_A, -1);
   EXPECT_TRUE(IsInvalidationAcknowledged(inv));
   EXPECT_TRUE(CheckInvalidationInfo(0, std::string()));
 }
 
 TEST_F(CloudPolicyInvalidatorTest, HandleMultipleInvalidations) {
   // Generate multiple invalidations.
   StorePolicy(POLICY_OBJECT_A);
   StartInvalidator();
-  syncer::Invalidation inv1 = FireInvalidation(POLICY_OBJECT_A, 1, "test1");
-  EXPECT_TRUE(CheckInvalidationInfo(1, "test1"));
-  syncer::Invalidation inv2 = FireInvalidation(POLICY_OBJECT_A, 2, "test2");
-  EXPECT_TRUE(CheckInvalidationInfo(2, "test2"));
-  syncer::Invalidation inv3 = FireInvalidation(POLICY_OBJECT_A, 3, "test3");
-  EXPECT_TRUE(CheckInvalidationInfo(3, "test3"));
+  syncer::Invalidation inv1 = FireInvalidation(POLICY_OBJECT_A, V(1), "test1");
+  EXPECT_TRUE(CheckInvalidationInfo(V(1), "test1"));
+  syncer::Invalidation inv2 = FireInvalidation(POLICY_OBJECT_A, V(2), "test2");
+  EXPECT_TRUE(CheckInvalidationInfo(V(2), "test2"));
+  syncer::Invalidation inv3 = FireInvalidation(POLICY_OBJECT_A, V(3), "test3");
+  EXPECT_TRUE(CheckInvalidationInfo(V(3), "test3"));
 
   // Make sure the replaced invalidations are acknowledged.
   EXPECT_TRUE(IsInvalidationAcknowledged(inv1));
   EXPECT_TRUE(IsInvalidationAcknowledged(inv2));
 
   // Make sure the policy is refreshed once.
   EXPECT_TRUE(CheckPolicyRefreshed());
 
   // Make sure that the last invalidation is only acknowledged after the store
   // is loaded with the latest version.
-  StorePolicy(POLICY_OBJECT_A, 1);
+  StorePolicy(POLICY_OBJECT_A, V(1));
   EXPECT_FALSE(IsInvalidationAcknowledged(inv3));
-  StorePolicy(POLICY_OBJECT_A, 2);
+  StorePolicy(POLICY_OBJECT_A, V(2));
   EXPECT_FALSE(IsInvalidationAcknowledged(inv3));
-  StorePolicy(POLICY_OBJECT_A, 3);
+  StorePolicy(POLICY_OBJECT_A, V(3));
   EXPECT_TRUE(IsInvalidationAcknowledged(inv3));
 }
 
 TEST_F(CloudPolicyInvalidatorTest,
        HandleMultipleInvalidationsWithUnknownVersion) {
   // Validate that multiple invalidations with unknown version each generate
   // unique invalidation version numbers.
   StorePolicy(POLICY_OBJECT_A);
   StartInvalidator();
   syncer::Invalidation inv1 = FireUnknownVersionInvalidation(POLICY_OBJECT_A);
@@ skipping 20 matching lines @@
   StorePolicy(POLICY_OBJECT_A, -2);
   EXPECT_FALSE(IsInvalidationAcknowledged(inv3));
   StorePolicy(POLICY_OBJECT_A, -3);
   EXPECT_TRUE(IsInvalidationAcknowledged(inv3));
 }
 
 TEST_F(CloudPolicyInvalidatorTest, AcknowledgeBeforeRefresh) {
   // Generate an invalidation.
   StorePolicy(POLICY_OBJECT_A);
   StartInvalidator();
-  syncer::Invalidation inv = FireInvalidation(POLICY_OBJECT_A, 3, "test");
+  syncer::Invalidation inv = FireInvalidation(POLICY_OBJECT_A, V(3), "test");
 
   // Ensure that the policy is not refreshed and the invalidation is
   // acknowledged if the store is loaded with the latest version before the
   // refresh can occur.
-  StorePolicy(POLICY_OBJECT_A, 3);
+  StorePolicy(POLICY_OBJECT_A, V(3));
   EXPECT_TRUE(IsInvalidationAcknowledged(inv));
   EXPECT_TRUE(CheckPolicyNotRefreshed());
 }
 
 TEST_F(CloudPolicyInvalidatorTest, NoCallbackAfterShutdown) {
   // Generate an invalidation.
   StorePolicy(POLICY_OBJECT_A);
   StartInvalidator();
-  syncer::Invalidation inv = FireInvalidation(POLICY_OBJECT_A, 3, "test");
+  syncer::Invalidation inv = FireInvalidation(POLICY_OBJECT_A, V(3), "test");
 
   // Ensure that the policy refresh is not made after the invalidator is shut
   // down.
   ShutdownInvalidator();
   EXPECT_TRUE(CheckPolicyNotRefreshed());
   DestroyInvalidator();
 }
 
 TEST_F(CloudPolicyInvalidatorTest, StateChanged) {
   // Test invalidation service state changes while not registered.
@@ skipping 29 matching lines @@
   EXPECT_FALSE(InvalidationsEnabled());
   StorePolicy(POLICY_OBJECT_NONE);
   StorePolicy(POLICY_OBJECT_A);
   EXPECT_FALSE(InvalidationsEnabled());
 }
 
 TEST_F(CloudPolicyInvalidatorTest, Disconnect) {
   // Generate an invalidation.
   StorePolicy(POLICY_OBJECT_A);
   StartInvalidator();
-  syncer::Invalidation inv = FireInvalidation(POLICY_OBJECT_A, 1, "test");
+  syncer::Invalidation inv = FireInvalidation(POLICY_OBJECT_A, V(1), "test");
   EXPECT_TRUE(InvalidationsEnabled());
 
   // Ensure that the policy is not refreshed after disconnecting the core, but
   // a call to indicate that invalidations are disabled is made.
   DisconnectCore();
   EXPECT_TRUE(CheckPolicyNotRefreshed());
 
   // Ensure that invalidation service events do not cause refreshes while the
   // invalidator is stopped.
-  EXPECT_TRUE(IsUnsent(FireInvalidation(POLICY_OBJECT_A, 2, "test")));
+  EXPECT_TRUE(IsUnsent(FireInvalidation(POLICY_OBJECT_A, V(2), "test")));
   EXPECT_TRUE(CheckPolicyNotRefreshed());
   DisableInvalidationService();
   EnableInvalidationService();
 
   // Connect and disconnect without starting the refresh scheduler.
   ConnectCore();
-  EXPECT_TRUE(IsUnsent(FireInvalidation(POLICY_OBJECT_A, 3, "test")));
+  EXPECT_TRUE(IsUnsent(FireInvalidation(POLICY_OBJECT_A, V(3), "test")));
   EXPECT_TRUE(CheckPolicyNotRefreshed());
   DisconnectCore();
-  EXPECT_TRUE(IsUnsent(FireInvalidation(POLICY_OBJECT_A, 4, "test")));
+  EXPECT_TRUE(IsUnsent(FireInvalidation(POLICY_OBJECT_A, V(4), "test")));
   EXPECT_TRUE(CheckPolicyNotRefreshed());
 
   // Ensure that the invalidator returns to normal after reconnecting.
   ConnectCore();
   StartRefreshScheduler();
   EXPECT_TRUE(CheckPolicyNotRefreshed());
   EXPECT_TRUE(InvalidationsEnabled());
-  FireInvalidation(POLICY_OBJECT_A, 5, "test");
-  EXPECT_TRUE(CheckInvalidationInfo(5, "test"));
+  FireInvalidation(POLICY_OBJECT_A, V(5), "test");
+  EXPECT_TRUE(CheckInvalidationInfo(V(5), "test"));
   EXPECT_TRUE(CheckPolicyRefreshed());
   DisableInvalidationService();
   EXPECT_FALSE(InvalidationsEnabled());
 }
 
 TEST_F(CloudPolicyInvalidatorTest, RefreshMetricsUnregistered) {
   // Store loads occurring before invalidation registration are not counted.
   StartInvalidator();
   StorePolicy(POLICY_OBJECT_NONE, 0, false /* policy_changed */);
   StorePolicy(POLICY_OBJECT_NONE, 0, true /* policy_changed */);
@@ skipping 55 matching lines @@
   EXPECT_EQ(0, GetCount(METRIC_POLICY_REFRESH_INVALIDATED_UNCHANGED));
 }
 
 TEST_F(CloudPolicyInvalidatorTest, RefreshMetricsInvalidation) {
   // Store loads after an invalidation are counted as invalidated, even if
   // the loads do not result in the invalidation being acknowledged.
   StartInvalidator();
   StorePolicy(POLICY_OBJECT_A);
   AdvanceClock(base::TimeDelta::FromSeconds(
       CloudPolicyInvalidator::kInvalidationGracePeriod));
-  FireInvalidation(POLICY_OBJECT_A, 5, "test");
+  FireInvalidation(POLICY_OBJECT_A, V(5), "test");
   StorePolicy(POLICY_OBJECT_A, 0, false /* policy_changed */);
   StorePolicy(POLICY_OBJECT_A, 0, true /* policy_changed */);
-  StorePolicy(POLICY_OBJECT_A, 5, true /* policy_changed */);
+  StorePolicy(POLICY_OBJECT_A, V(5), true /* policy_changed */);
 
   // Store loads after the invalidation is complete are not counted as
   // invalidated.
   StorePolicy(POLICY_OBJECT_A, 0, false /* policy_changed */);
   StorePolicy(POLICY_OBJECT_A, 0, true /* policy_changed */);
   StorePolicy(POLICY_OBJECT_A, 0, false /* policy_changed */);
   StorePolicy(POLICY_OBJECT_A, 0, true /* policy_changed */);
   StorePolicy(POLICY_OBJECT_A, 0, false /* policy_changed */);
   StorePolicy(POLICY_OBJECT_A, 0, true /* policy_changed */);
   StorePolicy(POLICY_OBJECT_A, 0, false /* policy_changed */);
 
   EXPECT_EQ(3, GetCount(METRIC_POLICY_REFRESH_CHANGED));
   EXPECT_EQ(0, GetCount(METRIC_POLICY_REFRESH_CHANGED_NO_INVALIDATIONS));
   EXPECT_EQ(4, GetCount(METRIC_POLICY_REFRESH_UNCHANGED));
   EXPECT_EQ(2, GetCount(METRIC_POLICY_REFRESH_INVALIDATED_CHANGED));
   EXPECT_EQ(1, GetCount(METRIC_POLICY_REFRESH_INVALIDATED_UNCHANGED));
 }
 
-TEST_F(CloudPolicyInvalidatorTest, InvalidationMetrics) {
-  // Generate a mix of versioned and unknown-version invalidations.
-  StorePolicy(POLICY_OBJECT_A);
+TEST_F(CloudPolicyInvalidatorTest, ExpiredInvalidations) {
+  StorePolicy(POLICY_OBJECT_A, 0, false, Now());
   StartInvalidator();
-  EXPECT_TRUE(IsUnsent(FireUnknownVersionInvalidation(POLICY_OBJECT_B)));
-  FireUnknownVersionInvalidation(POLICY_OBJECT_A);
-  EXPECT_TRUE(IsUnsent(FireInvalidation(POLICY_OBJECT_B, 1, "test")));
-  FireInvalidation(POLICY_OBJECT_A, 1, "test");
-  FireInvalidation(POLICY_OBJECT_A, 2, "test");
-  FireUnknownVersionInvalidation(POLICY_OBJECT_A);
-  FireUnknownVersionInvalidation(POLICY_OBJECT_A);
-  FireInvalidation(POLICY_OBJECT_A, 3, "test");
-  FireInvalidation(POLICY_OBJECT_A, 4, "test");
+
+  // Invalidations fired before the last fetch time (adjusted by max time delta)
+  // should be ignored.
+  base::Time time = Now() - base::TimeDelta::FromMinutes(
+      CloudPolicyInvalidator::kMaxInvalidationTimeDelta + 5);
+  syncer::Invalidation inv =
+      FireInvalidation(POLICY_OBJECT_A, GetVersion(time), "test");
+  ASSERT_TRUE(IsInvalidationAcknowledged(inv));
+  ASSERT_TRUE(CheckPolicyNotRefreshed());
+
+  time += base::TimeDelta::FromMinutes(5) - base::TimeDelta::FromSeconds(1);
+  inv = FireInvalidation(POLICY_OBJECT_A, GetVersion(time), "test");
+  ASSERT_TRUE(IsInvalidationAcknowledged(inv));
+  ASSERT_TRUE(CheckPolicyNotRefreshed());
+
+  // Invalidations fired after the last fetch should not be ignored.
+  time += base::TimeDelta::FromSeconds(1);
+  inv = FireInvalidation(POLICY_OBJECT_A, GetVersion(time), "test");
+  ASSERT_FALSE(IsInvalidationAcknowledged(inv));
+  ASSERT_TRUE(CheckPolicyRefreshed());
+
+  time += base::TimeDelta::FromMinutes(10);
+  inv = FireInvalidation(POLICY_OBJECT_A, GetVersion(time), "test");
+  ASSERT_FALSE(IsInvalidationAcknowledged(inv));
+  ASSERT_TRUE(CheckPolicyRefreshed());
+
+  time += base::TimeDelta::FromMinutes(10);
+  inv = FireInvalidation(POLICY_OBJECT_A, GetVersion(time), "test");
+  ASSERT_FALSE(IsInvalidationAcknowledged(inv));
+  ASSERT_TRUE(CheckPolicyRefreshed());
+
+  // Unknown version invalidations fired just after the last fetch time should
+  // be ignored.
+  inv = FireUnknownVersionInvalidation(POLICY_OBJECT_A);
+  ASSERT_TRUE(IsInvalidationAcknowledged(inv));
+  ASSERT_TRUE(CheckPolicyNotRefreshed());
+
+  AdvanceClock(base::TimeDelta::FromSeconds(
+      CloudPolicyInvalidator::kUnknownVersionIgnorePeriod - 1));
+  inv = FireUnknownVersionInvalidation(POLICY_OBJECT_A);
+  ASSERT_TRUE(IsInvalidationAcknowledged(inv));
+  ASSERT_TRUE(CheckPolicyNotRefreshed());
+
+  // Unknown version invalidations fired past the ignore period should not be
+  // ignored.
+  AdvanceClock(base::TimeDelta::FromSeconds(1));
+  inv = FireUnknownVersionInvalidation(POLICY_OBJECT_A);
+  ASSERT_FALSE(IsInvalidationAcknowledged(inv));
+  ASSERT_TRUE(CheckPolicyRefreshedWithUnknownVersion());
 
   // Verify that received invalidations metrics are correct.
-  EXPECT_EQ(3, GetInvalidationCount(false /* with_payload */));
-  EXPECT_EQ(4, GetInvalidationCount(true /* with_payload */));
+  EXPECT_EQ(1, GetInvalidationCount(POLICY_INVALIDATION_TYPE_NO_PAYLOAD));
+  EXPECT_EQ(3, GetInvalidationCount(POLICY_INVALIDATION_TYPE_NORMAL));
+  EXPECT_EQ(2,
+            GetInvalidationCount(POLICY_INVALIDATION_TYPE_NO_PAYLOAD_EXPIRED));
+  EXPECT_EQ(2, GetInvalidationCount(POLICY_INVALIDATION_TYPE_EXPIRED));
 }
 
 }  // namespace policy