Invalidation trickles mega-patch

chrome/browser/policy/cloud/cloud_policy_invalidator_unittest.cc

Index: chrome/browser/policy/cloud/cloud_policy_invalidator_unittest.cc
diff --git a/chrome/browser/policy/cloud/cloud_policy_invalidator_unittest.cc b/chrome/browser/policy/cloud/cloud_policy_invalidator_unittest.cc
index 3f92b4a492d2bb1b5c6292b8fa214b27ca3c7456..9eb2f3d0508877e0fba4f02156b805f45941e7db 100644
--- a/chrome/browser/policy/cloud/cloud_policy_invalidator_unittest.cc
+++ b/chrome/browser/policy/cloud/cloud_policy_invalidator_unittest.cc
@@ -107,17 +107,15 @@ class CloudPolicyInvalidatorTest : public testing::Test {
   // Enables the invalidation service. It is enabled by default.
   void EnableInvalidationService();
 
-  // Causes the invalidation service to fire an invalidation. Returns an ack
-  // handle which be used to verify that the invalidation was acknowledged.
-  syncer::AckHandle FireInvalidation(
+  // Causes the invalidation service to fire an invalidation.
+  syncer::Invalidation FireInvalidation(
       PolicyObject object,
       int64 version,
       const std::string& payload);
 
   // Causes the invalidation service to fire an invalidation with unknown
-  // version. Returns an ack handle which be used to verify that the
-  // invalidation was acknowledged.
-  syncer::AckHandle FireInvalidation(PolicyObject object);
+  // version.
+  syncer::Invalidation FireUnknownVersionInvalidation(PolicyObject object);
 
   // Checks the expected value of the currently set invalidation info.
   bool CheckInvalidationInfo(int64 version, const std::string& payload);
@@ -131,13 +129,19 @@ class CloudPolicyInvalidatorTest : public testing::Test {
   bool CheckPolicyRefreshed();
   bool CheckPolicyRefreshedWithUnknownVersion();
 
+  bool IsUnsent(const syncer::Invalidation& invalidation);
+
+  // Checks that the state changed callback of the invalidation handler was not
+  // called.
+  bool CheckStateChangedNotCalled();
+
   // Returns the invalidations enabled state set by the invalidator on the
   // refresh scheduler.
   bool InvalidationsEnabled();
 
   // Determines if the invalidation with the given ack handle has been
   // acknowledged.
-  bool IsInvalidationAcknowledged(const syncer::AckHandle& ack_handle);
+  bool IsInvalidationAcknowledged(const syncer::Invalidation& invalidation);
 
   // Determines if the invalidator has registered for an object with the
   // invalidation service.
@@ -217,7 +221,6 @@ void CloudPolicyInvalidatorTest::SetUp() {
 }
 
 void CloudPolicyInvalidatorTest::TearDown() {
-  EXPECT_FALSE(invalidation_service_.ReceivedInvalidAcknowledgement());
   if (invalidator_)
     invalidator_->Shutdown();
   core_.Disconnect();
@@ -301,22 +304,24 @@ void CloudPolicyInvalidatorTest::EnableInvalidationService() {
   invalidation_service_.SetInvalidatorState(syncer::INVALIDATIONS_ENABLED);
 }
 
-syncer::AckHandle CloudPolicyInvalidatorTest::FireInvalidation(
+syncer::Invalidation CloudPolicyInvalidatorTest::FireInvalidation(
     PolicyObject object,
     int64 version,
     const std::string& payload) {
-  return invalidation_service_.EmitInvalidationForTest(
+  syncer::Invalidation invalidation = syncer::Invalidation::Init(
       GetPolicyObjectId(object),
       version,
       payload);
+  invalidation_service_.EmitInvalidationForTest(invalidation);
+  return invalidation;
 }
 
-syncer::AckHandle CloudPolicyInvalidatorTest::FireInvalidation(
+syncer::Invalidation CloudPolicyInvalidatorTest::FireUnknownVersionInvalidation(
     PolicyObject object) {
-  return invalidation_service_.EmitInvalidationForTest(
-      GetPolicyObjectId(object),
-      syncer::Invalidation::kUnknownVersion,
-      std::string());
+  syncer::Invalidation invalidation = syncer::Invalidation::InitUnknownVersion(
+      GetPolicyObjectId(object));
+  invalidation_service_.EmitInvalidationForTest(invalidation);
+  return invalidation;
 }
 
 bool CloudPolicyInvalidatorTest::CheckInvalidationInfo(
@@ -336,6 +341,11 @@ bool CloudPolicyInvalidatorTest::CheckPolicyRefreshed() {
   return CheckPolicyRefreshed(base::TimeDelta());
 }
 
+bool CloudPolicyInvalidatorTest::IsUnsent(
+    const syncer::Invalidation& invalidation) {
+  return invalidation_service_.GetMockAckHandler()->IsUnsent(invalidation);
+}
+
 bool CloudPolicyInvalidatorTest::CheckPolicyRefreshedWithUnknownVersion() {
   return CheckPolicyRefreshed(base::TimeDelta::FromMinutes(
         CloudPolicyInvalidator::kMissingPayloadDelay));
@@ -346,8 +356,13 @@ bool CloudPolicyInvalidatorTest::InvalidationsEnabled() {
 }
 
 bool CloudPolicyInvalidatorTest::IsInvalidationAcknowledged(
-    const syncer::AckHandle& ack_handle) {
-  return invalidation_service_.IsInvalidationAcknowledged(ack_handle);
+    const syncer::Invalidation& invalidation) {
+  // The acknowledgement task is run through a WeakHandle.  We need to run any
+  // posted tasks before we can check acknowledgement status.
+  loop_.RunUntilIdle();
+
+  EXPECT_FALSE(IsUnsent(invalidation));
+  return !invalidation_service_.GetMockAckHandler()->IsUnacked(invalidation);
 }
 
 bool CloudPolicyInvalidatorTest::IsInvalidatorRegistered() {
@@ -420,7 +435,7 @@ TEST_F(CloudPolicyInvalidatorTest, Uninitialized) {
   StartInvalidator(false /* initialize */, true /* start_refresh_scheduler */);
   StorePolicy(POLICY_OBJECT_A);
   EXPECT_FALSE(IsInvalidatorRegistered());
-  FireInvalidation(POLICY_OBJECT_A);
+  EXPECT_TRUE(IsUnsent(FireUnknownVersionInvalidation(POLICY_OBJECT_A)));
   EXPECT_TRUE(CheckPolicyNotRefreshed());
 }
 
@@ -430,7 +445,7 @@ TEST_F(CloudPolicyInvalidatorTest, RefreshSchedulerNotStarted) {
   StartInvalidator(true /* initialize */, false /* start_refresh_scheduler */);
   StorePolicy(POLICY_OBJECT_A);
   EXPECT_FALSE(IsInvalidatorRegistered());
-  FireInvalidation(POLICY_OBJECT_A);
+  EXPECT_TRUE(IsUnsent(FireUnknownVersionInvalidation(POLICY_OBJECT_A)));
   EXPECT_TRUE(CheckPolicyNotRefreshed());
 }
 
@@ -442,7 +457,7 @@ TEST_F(CloudPolicyInvalidatorTest, DisconnectCoreThenInitialize) {
   InitializeInvalidator();
   StorePolicy(POLICY_OBJECT_A);
   EXPECT_FALSE(IsInvalidatorRegistered());
-  FireInvalidation(POLICY_OBJECT_A);
+  EXPECT_TRUE(IsUnsent(FireUnknownVersionInvalidation(POLICY_OBJECT_A)));
   EXPECT_TRUE(CheckPolicyNotRefreshed());
 }
 
@@ -457,7 +472,7 @@ TEST_F(CloudPolicyInvalidatorTest, InitializeThenStartRefreshScheduler) {
   StartRefreshScheduler();
   StorePolicy(POLICY_OBJECT_A);
   EXPECT_TRUE(IsInvalidatorRegistered());
-  FireInvalidation(POLICY_OBJECT_A);
+  FireUnknownVersionInvalidation(POLICY_OBJECT_A);
   EXPECT_TRUE(CheckPolicyRefreshedWithUnknownVersion());
 }
 
@@ -466,25 +481,25 @@ TEST_F(CloudPolicyInvalidatorTest, RegisterOnStoreLoaded) {
   StartInvalidator();
   EXPECT_FALSE(IsInvalidatorRegistered());
   EXPECT_FALSE(InvalidationsEnabled());
-  FireInvalidation(POLICY_OBJECT_A);
-  FireInvalidation(POLICY_OBJECT_B);
+  EXPECT_TRUE(IsUnsent(FireUnknownVersionInvalidation(POLICY_OBJECT_A)));
+  EXPECT_TRUE(IsUnsent(FireUnknownVersionInvalidation(POLICY_OBJECT_B)));
   EXPECT_TRUE(CheckPolicyNotRefreshed());
 
   // No registration when store is loaded with no invalidation object id.
   StorePolicy(POLICY_OBJECT_NONE);
   EXPECT_FALSE(IsInvalidatorRegistered());
   EXPECT_FALSE(InvalidationsEnabled());
-  FireInvalidation(POLICY_OBJECT_A);
-  FireInvalidation(POLICY_OBJECT_B);
+  EXPECT_TRUE(IsUnsent(FireUnknownVersionInvalidation(POLICY_OBJECT_A)));
+  EXPECT_TRUE(IsUnsent(FireUnknownVersionInvalidation(POLICY_OBJECT_B)));
   EXPECT_TRUE(CheckPolicyNotRefreshed());
 
   // Check registration when store is loaded for object A.
   StorePolicy(POLICY_OBJECT_A);
   EXPECT_TRUE(IsInvalidatorRegistered());
   EXPECT_TRUE(InvalidationsEnabled());
-  FireInvalidation(POLICY_OBJECT_A);
+  FireUnknownVersionInvalidation(POLICY_OBJECT_A);
   EXPECT_TRUE(CheckPolicyRefreshedWithUnknownVersion());
-  FireInvalidation(POLICY_OBJECT_B);
+  EXPECT_TRUE(IsUnsent(FireUnknownVersionInvalidation(POLICY_OBJECT_B)));
   EXPECT_TRUE(CheckPolicyNotRefreshed());
 }
 
@@ -494,25 +509,25 @@ TEST_F(CloudPolicyInvalidatorTest, ChangeRegistration) {
   StorePolicy(POLICY_OBJECT_A);
   EXPECT_TRUE(IsInvalidatorRegistered());
   EXPECT_TRUE(InvalidationsEnabled());
-  FireInvalidation(POLICY_OBJECT_A);
+  FireUnknownVersionInvalidation(POLICY_OBJECT_A);
   EXPECT_TRUE(CheckPolicyRefreshedWithUnknownVersion());
-  FireInvalidation(POLICY_OBJECT_B);
+  EXPECT_TRUE(IsUnsent(FireUnknownVersionInvalidation(POLICY_OBJECT_B)));
   EXPECT_TRUE(CheckPolicyNotRefreshed());
-  syncer::AckHandle ack = FireInvalidation(POLICY_OBJECT_A);
+  syncer::Invalidation inv = FireUnknownVersionInvalidation(POLICY_OBJECT_A);
 
   // Check re-registration for object B. Make sure the pending invalidation for
   // object A is acknowledged without making the callback.
   StorePolicy(POLICY_OBJECT_B);
   EXPECT_TRUE(IsInvalidatorRegistered());
   EXPECT_TRUE(InvalidationsEnabled());
-  EXPECT_TRUE(IsInvalidationAcknowledged(ack));
+  EXPECT_TRUE(IsInvalidationAcknowledged(inv));
   EXPECT_TRUE(CheckPolicyNotRefreshed());
 
   // Make sure future invalidations for object A are ignored and for object B
   // are processed.
-  FireInvalidation(POLICY_OBJECT_A);
+  EXPECT_TRUE(IsUnsent(FireUnknownVersionInvalidation(POLICY_OBJECT_A)));
   EXPECT_TRUE(CheckPolicyNotRefreshed());
-  FireInvalidation(POLICY_OBJECT_B);
+  FireUnknownVersionInvalidation(POLICY_OBJECT_B);
   EXPECT_TRUE(CheckPolicyRefreshedWithUnknownVersion());
 }
 
@@ -522,25 +537,25 @@ TEST_F(CloudPolicyInvalidatorTest, UnregisterOnStoreLoaded) {
   StorePolicy(POLICY_OBJECT_A);
   EXPECT_TRUE(IsInvalidatorRegistered());
   EXPECT_TRUE(InvalidationsEnabled());
-  FireInvalidation(POLICY_OBJECT_A);
+  FireUnknownVersionInvalidation(POLICY_OBJECT_A);
   EXPECT_TRUE(CheckPolicyRefreshedWithUnknownVersion());
 
   // Check unregistration when store is loaded with no invalidation object id.
-  syncer::AckHandle ack = FireInvalidation(POLICY_OBJECT_A);
-  EXPECT_FALSE(IsInvalidationAcknowledged(ack));
+  syncer::Invalidation inv = FireUnknownVersionInvalidation(POLICY_OBJECT_A);
+  EXPECT_FALSE(IsInvalidationAcknowledged(inv));
   StorePolicy(POLICY_OBJECT_NONE);
   EXPECT_FALSE(IsInvalidatorRegistered());
-  EXPECT_TRUE(IsInvalidationAcknowledged(ack));
+  EXPECT_TRUE(IsInvalidationAcknowledged(inv));
   EXPECT_FALSE(InvalidationsEnabled());
-  FireInvalidation(POLICY_OBJECT_A);
-  FireInvalidation(POLICY_OBJECT_B);
+  EXPECT_TRUE(IsUnsent(FireUnknownVersionInvalidation(POLICY_OBJECT_A)));
+  EXPECT_TRUE(IsUnsent(FireUnknownVersionInvalidation(POLICY_OBJECT_B)));
   EXPECT_TRUE(CheckPolicyNotRefreshed());
 
   // Check re-registration for object B.
   StorePolicy(POLICY_OBJECT_B);
   EXPECT_TRUE(IsInvalidatorRegistered());
   EXPECT_TRUE(InvalidationsEnabled());
-  FireInvalidation(POLICY_OBJECT_B);
+  FireUnknownVersionInvalidation(POLICY_OBJECT_B);
   EXPECT_TRUE(CheckPolicyRefreshedWithUnknownVersion());
 }
 
@@ -549,17 +564,18 @@ TEST_F(CloudPolicyInvalidatorTest, HandleInvalidation) {
   StorePolicy(POLICY_OBJECT_A);
   StartInvalidator();
   EXPECT_TRUE(InvalidationsEnabled());
-  syncer::AckHandle ack = FireInvalidation(POLICY_OBJECT_A, 12, "test_payload");
+  syncer::Invalidation inv =
+      FireInvalidation(POLICY_OBJECT_A, 12, "test_payload");
 
   // Make sure client info is set as soon as the invalidation is received.
   EXPECT_TRUE(CheckInvalidationInfo(12, "test_payload"));
   EXPECT_TRUE(CheckPolicyRefreshed());
 
   // Make sure invalidation is not acknowledged until the store is loaded.
-  EXPECT_FALSE(IsInvalidationAcknowledged(ack));
+  EXPECT_FALSE(IsInvalidationAcknowledged(inv));
   EXPECT_TRUE(CheckInvalidationInfo(12, "test_payload"));
   StorePolicy(POLICY_OBJECT_A, 12);
-  EXPECT_TRUE(IsInvalidationAcknowledged(ack));
+  EXPECT_TRUE(IsInvalidationAcknowledged(inv));
   EXPECT_TRUE(CheckInvalidationInfo(0, std::string()));
 }
 
@@ -567,7 +583,7 @@ TEST_F(CloudPolicyInvalidatorTest, HandleInvalidationWithUnknownVersion) {
   // Register and fire invalidation with unknown version.
   StorePolicy(POLICY_OBJECT_A);
   StartInvalidator();
-  syncer::AckHandle ack = FireInvalidation(POLICY_OBJECT_A);
+  syncer::Invalidation inv = FireUnknownVersionInvalidation(POLICY_OBJECT_A);
 
   // Make sure client info is not set until after the invalidation callback is
   // made.
@@ -576,9 +592,9 @@ TEST_F(CloudPolicyInvalidatorTest, HandleInvalidationWithUnknownVersion) {
   EXPECT_TRUE(CheckInvalidationInfo(-1, std::string()));
 
   // Make sure invalidation is not acknowledged until the store is loaded.
-  EXPECT_FALSE(IsInvalidationAcknowledged(ack));
+  EXPECT_FALSE(IsInvalidationAcknowledged(inv));
   StorePolicy(POLICY_OBJECT_A, -1);
-  EXPECT_TRUE(IsInvalidationAcknowledged(ack));
+  EXPECT_TRUE(IsInvalidationAcknowledged(inv));
   EXPECT_TRUE(CheckInvalidationInfo(0, std::string()));
 }
 
@@ -586,16 +602,16 @@ TEST_F(CloudPolicyInvalidatorTest, HandleMultipleInvalidations) {
   // Generate multiple invalidations.
   StorePolicy(POLICY_OBJECT_A);
   StartInvalidator();
-  syncer::AckHandle ack1 = FireInvalidation(POLICY_OBJECT_A, 1, "test1");
+  syncer::Invalidation inv1 = FireInvalidation(POLICY_OBJECT_A, 1, "test1");
   EXPECT_TRUE(CheckInvalidationInfo(1, "test1"));
-  syncer::AckHandle ack2 = FireInvalidation(POLICY_OBJECT_A, 2, "test2");
+  syncer::Invalidation inv2 = FireInvalidation(POLICY_OBJECT_A, 2, "test2");
   EXPECT_TRUE(CheckInvalidationInfo(2, "test2"));
-  syncer::AckHandle ack3= FireInvalidation(POLICY_OBJECT_A, 3, "test3");
+  syncer::Invalidation inv3 = FireInvalidation(POLICY_OBJECT_A, 3, "test3");
   EXPECT_TRUE(CheckInvalidationInfo(3, "test3"));
 
   // Make sure the replaced invalidations are acknowledged.
-  EXPECT_TRUE(IsInvalidationAcknowledged(ack1));
-  EXPECT_TRUE(IsInvalidationAcknowledged(ack2));
+  EXPECT_TRUE(IsInvalidationAcknowledged(inv1));
+  EXPECT_TRUE(IsInvalidationAcknowledged(inv2));
 
   // Make sure the policy is refreshed once.
   EXPECT_TRUE(CheckPolicyRefreshed());
@@ -603,11 +619,11 @@ TEST_F(CloudPolicyInvalidatorTest, HandleMultipleInvalidations) {
   // Make sure that the last invalidation is only acknowledged after the store
   // is loaded with the latest version.
   StorePolicy(POLICY_OBJECT_A, 1);
-  EXPECT_FALSE(IsInvalidationAcknowledged(ack3));
+  EXPECT_FALSE(IsInvalidationAcknowledged(inv3));
   StorePolicy(POLICY_OBJECT_A, 2);
-  EXPECT_FALSE(IsInvalidationAcknowledged(ack3));
+  EXPECT_FALSE(IsInvalidationAcknowledged(inv3));
   StorePolicy(POLICY_OBJECT_A, 3);
-  EXPECT_TRUE(IsInvalidationAcknowledged(ack3));
+  EXPECT_TRUE(IsInvalidationAcknowledged(inv3));
 }
 
 TEST_F(CloudPolicyInvalidatorTest,
@@ -616,44 +632,44 @@ TEST_F(CloudPolicyInvalidatorTest,
   // unique invalidation version numbers.
   StorePolicy(POLICY_OBJECT_A);
   StartInvalidator();
-  syncer::AckHandle ack1 = FireInvalidation(POLICY_OBJECT_A);
+  syncer::Invalidation inv1 = FireUnknownVersionInvalidation(POLICY_OBJECT_A);
   EXPECT_TRUE(CheckInvalidationInfo(0, std::string()));
   EXPECT_TRUE(CheckPolicyRefreshedWithUnknownVersion());
   EXPECT_TRUE(CheckInvalidationInfo(-1, std::string()));
-  syncer::AckHandle ack2 = FireInvalidation(POLICY_OBJECT_A);
+  syncer::Invalidation inv2 = FireUnknownVersionInvalidation(POLICY_OBJECT_A);
   EXPECT_TRUE(CheckInvalidationInfo(0, std::string()));
   EXPECT_TRUE(CheckPolicyRefreshedWithUnknownVersion());
   EXPECT_TRUE(CheckInvalidationInfo(-2, std::string()));
-  syncer::AckHandle ack3 = FireInvalidation(POLICY_OBJECT_A);
+  syncer::Invalidation inv3 = FireUnknownVersionInvalidation(POLICY_OBJECT_A);
   EXPECT_TRUE(CheckInvalidationInfo(0, std::string()));
   EXPECT_TRUE(CheckPolicyRefreshedWithUnknownVersion());
   EXPECT_TRUE(CheckInvalidationInfo(-3, std::string()));
 
   // Make sure the replaced invalidations are acknowledged.
-  EXPECT_TRUE(IsInvalidationAcknowledged(ack1));
-  EXPECT_TRUE(IsInvalidationAcknowledged(ack2));
+  EXPECT_TRUE(IsInvalidationAcknowledged(inv1));
+  EXPECT_TRUE(IsInvalidationAcknowledged(inv2));
 
   // Make sure that the last invalidation is only acknowledged after the store
   // is loaded with the last unknown version.
   StorePolicy(POLICY_OBJECT_A, -1);
-  EXPECT_FALSE(IsInvalidationAcknowledged(ack3));
+  EXPECT_FALSE(IsInvalidationAcknowledged(inv3));
   StorePolicy(POLICY_OBJECT_A, -2);
-  EXPECT_FALSE(IsInvalidationAcknowledged(ack3));
+  EXPECT_FALSE(IsInvalidationAcknowledged(inv3));
   StorePolicy(POLICY_OBJECT_A, -3);
-  EXPECT_TRUE(IsInvalidationAcknowledged(ack3));
+  EXPECT_TRUE(IsInvalidationAcknowledged(inv3));
 }
 
 TEST_F(CloudPolicyInvalidatorTest, AcknowledgeBeforeRefresh) {
   // Generate an invalidation.
   StorePolicy(POLICY_OBJECT_A);
   StartInvalidator();
-  syncer::AckHandle ack = FireInvalidation(POLICY_OBJECT_A, 3, "test");
+  syncer::Invalidation inv = FireInvalidation(POLICY_OBJECT_A, 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);
-  EXPECT_TRUE(IsInvalidationAcknowledged(ack));
+  EXPECT_TRUE(IsInvalidationAcknowledged(inv));
   EXPECT_TRUE(CheckPolicyNotRefreshed());
 }
 
@@ -661,7 +677,7 @@ TEST_F(CloudPolicyInvalidatorTest, NoCallbackAfterShutdown) {
   // Generate an invalidation.
   StorePolicy(POLICY_OBJECT_A);
   StartInvalidator();
-  syncer::AckHandle ack = FireInvalidation(POLICY_OBJECT_A, 3, "test");
+  syncer::Invalidation inv = FireInvalidation(POLICY_OBJECT_A, 3, "test");
 
   // Ensure that the policy refresh is not made after the invalidator is shut
   // down.
@@ -711,7 +727,7 @@ TEST_F(CloudPolicyInvalidatorTest, Disconnect) {
   // Generate an invalidation.
   StorePolicy(POLICY_OBJECT_A);
   StartInvalidator();
-  syncer::AckHandle ack = FireInvalidation(POLICY_OBJECT_A, 1, "test");
+  syncer::Invalidation inv = FireInvalidation(POLICY_OBJECT_A, 1, "test");
   EXPECT_TRUE(InvalidationsEnabled());
 
   // Ensure that the policy is not refreshed after disconnecting the core, but
@@ -721,17 +737,17 @@ TEST_F(CloudPolicyInvalidatorTest, Disconnect) {
 
   // Ensure that invalidation service events do not cause refreshes while the
   // invalidator is stopped.
-  FireInvalidation(POLICY_OBJECT_A, 2, "test");
+  EXPECT_TRUE(IsUnsent(FireInvalidation(POLICY_OBJECT_A, 2, "test")));
   EXPECT_TRUE(CheckPolicyNotRefreshed());
   DisableInvalidationService();
   EnableInvalidationService();
 
   // Connect and disconnect without starting the refresh scheduler.
   ConnectCore();
-  FireInvalidation(POLICY_OBJECT_A, 3, "test");
+  EXPECT_TRUE(IsUnsent(FireInvalidation(POLICY_OBJECT_A, 3, "test")));
   EXPECT_TRUE(CheckPolicyNotRefreshed());
   DisconnectCore();
-  FireInvalidation(POLICY_OBJECT_A, 4, "test");
+  EXPECT_TRUE(IsUnsent(FireInvalidation(POLICY_OBJECT_A, 4, "test")));
   EXPECT_TRUE(CheckPolicyNotRefreshed());
 
   // Ensure that the invalidator returns to normal after reconnecting.
@@ -830,13 +846,13 @@ TEST_F(CloudPolicyInvalidatorTest, InvalidationMetrics) {
   // Generate a mix of versioned and unknown-version invalidations.
   StorePolicy(POLICY_OBJECT_A);
   StartInvalidator();
-  FireInvalidation(POLICY_OBJECT_B);
-  FireInvalidation(POLICY_OBJECT_A);
-  FireInvalidation(POLICY_OBJECT_B, 1, "test");
+  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");
-  FireInvalidation(POLICY_OBJECT_A);
-  FireInvalidation(POLICY_OBJECT_A);
+  FireUnknownVersionInvalidation(POLICY_OBJECT_A);
+  FireUnknownVersionInvalidation(POLICY_OBJECT_A);
   FireInvalidation(POLICY_OBJECT_A, 3, "test");
   FireInvalidation(POLICY_OBJECT_A, 4, "test");