sync: Inject sync/'s dependency on invalidations

sync/sessions/nudge_tracker_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/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "sync/internal_api/public/base/model_type_test_util.h"
 #include "sync/notifier/invalidation_util.h"
 #include "sync/notifier/mock_ack_handler.h"
 #include "sync/notifier/object_id_invalidation_map.h"
 #include "sync/sessions/nudge_tracker.h"
+#include "sync/test/mock_invalidation.h"
+#include "sync/test/mock_invalidation_tracker.h"
+#include "sync/test/trackable_mock_invalidation.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace syncer {
 
 namespace {
 
 testing::AssertionResult ModelTypeSetEquals(ModelTypeSet a, ModelTypeSet b) {
   if (a.Equals(b)) {
     return testing::AssertionSuccess();
   } else {
     return testing::AssertionFailure()
         << "Left side " << ModelTypeSetToString(a)
         << ", does not match rigth side: " << ModelTypeSetToString(b);
   }
 }
 
-syncer::Invalidation BuildUnknownVersionInvalidation(ModelType type) {
-  invalidation::ObjectId id;
-  bool result = RealModelTypeToObjectId(type, &id);
-  DCHECK(result);
-  return Invalidation::InitUnknownVersion(id);
-}
-
-
 }  // namespace
 
 namespace sessions {
 
 class NudgeTrackerTest : public ::testing::Test {
  public:
   NudgeTrackerTest() {
     SetInvalidationsInSync();
   }
 
@@ skipping 19 matching lines @@
     sync_pb::GetUpdateTriggers gu_trigger;
     nudge_tracker_.FillProtoMessage(type, &gu_trigger);
     return gu_trigger.datatype_refresh_nudges();
   }
 
   void SetInvalidationsInSync() {
     nudge_tracker_.OnInvalidationsEnabled();
     nudge_tracker_.RecordSuccessfulSyncCycle();
   }
 
+  scoped_ptr<InvalidationInterface> BuildInvalidation(
+      int64 version,
+      const std::string& payload) {
+    return MockInvalidation::Build(version, payload)
+        .PassAs<InvalidationInterface>();
+  }
+
+  static scoped_ptr<InvalidationInterface> BuildUnknownVersionInvalidation() {
+    return MockInvalidation::BuildUnknownVersion()
+        .PassAs<InvalidationInterface>();
+  }
+
  protected:
   NudgeTracker nudge_tracker_;
 };
 
 // Exercise an empty NudgeTracker.
 // Use with valgrind to detect uninitialized members.
 TEST_F(NudgeTrackerTest, EmptyNudgeTracker) {
   // Now we're at the normal, "idle" state.
   EXPECT_FALSE(nudge_tracker_.IsSyncRequired());
   EXPECT_FALSE(nudge_tracker_.IsGetUpdatesRequired());
@@ skipping 27 matching lines @@
   nudge_tracker_.RecordLocalRefreshRequest(ModelTypeSet(TYPED_URLS));
   EXPECT_EQ(sync_pb::GetUpdatesCallerInfo::DATATYPE_REFRESH,
             nudge_tracker_.GetLegacySource());
 
   // Another local nudge will not be enough to change it.
   nudge_tracker_.RecordLocalChange(ModelTypeSet(BOOKMARKS));
   EXPECT_EQ(sync_pb::GetUpdatesCallerInfo::DATATYPE_REFRESH,
             nudge_tracker_.GetLegacySource());
 
   // An invalidation will override the refresh request source.
-  ObjectIdInvalidationMap invalidation_map =
-      BuildInvalidationMap(PREFERENCES, 1, "hint");
-  nudge_tracker_.RecordRemoteInvalidation(invalidation_map);
+  nudge_tracker_.RecordRemoteInvalidation(PREFERENCES,
+                                          BuildInvalidation(1, "hint"));
   EXPECT_EQ(sync_pb::GetUpdatesCallerInfo::NOTIFICATION,
             nudge_tracker_.GetLegacySource());
 
   // Neither local nudges nor refresh requests will override it.
   nudge_tracker_.RecordLocalChange(ModelTypeSet(BOOKMARKS));
   EXPECT_EQ(sync_pb::GetUpdatesCallerInfo::NOTIFICATION,
             nudge_tracker_.GetLegacySource());
   nudge_tracker_.RecordLocalRefreshRequest(ModelTypeSet(TYPED_URLS));
   EXPECT_EQ(sync_pb::GetUpdatesCallerInfo::NOTIFICATION,
             nudge_tracker_.GetLegacySource());
 }
 
 // Verifies the management of invalidation hints and GU trigger fields.
 TEST_F(NudgeTrackerTest, HintCoalescing) {
   // Easy case: record one hint.
   {
-    ObjectIdInvalidationMap invalidation_map =
-        BuildInvalidationMap(BOOKMARKS, 1, "bm_hint_1");
-    nudge_tracker_.RecordRemoteInvalidation(invalidation_map);
+    nudge_tracker_.RecordRemoteInvalidation(BOOKMARKS,
+                                            BuildInvalidation(1, "bm_hint_1"));
 
     sync_pb::GetUpdateTriggers gu_trigger;
     nudge_tracker_.FillProtoMessage(BOOKMARKS, &gu_trigger);
     ASSERT_EQ(1, gu_trigger.notification_hint_size());
     EXPECT_EQ("bm_hint_1", gu_trigger.notification_hint(0));
     EXPECT_FALSE(gu_trigger.client_dropped_hints());
   }
 
   // Record a second hint for the same type.
   {
-    ObjectIdInvalidationMap invalidation_map =
-        BuildInvalidationMap(BOOKMARKS, 2, "bm_hint_2");
-    nudge_tracker_.RecordRemoteInvalidation(invalidation_map);
+    nudge_tracker_.RecordRemoteInvalidation(BOOKMARKS,
+                                            BuildInvalidation(2, "bm_hint_2"));
 
     sync_pb::GetUpdateTriggers gu_trigger;
     nudge_tracker_.FillProtoMessage(BOOKMARKS, &gu_trigger);
     ASSERT_EQ(2, gu_trigger.notification_hint_size());
 
     // Expect the most hint recent is last in the list.
     EXPECT_EQ("bm_hint_1", gu_trigger.notification_hint(0));
     EXPECT_EQ("bm_hint_2", gu_trigger.notification_hint(1));
     EXPECT_FALSE(gu_trigger.client_dropped_hints());
   }
 
   // Record a hint for a different type.
   {
-    ObjectIdInvalidationMap invalidation_map =
-        BuildInvalidationMap(PASSWORDS, 1, "pw_hint_1");
-    nudge_tracker_.RecordRemoteInvalidation(invalidation_map);
+    nudge_tracker_.RecordRemoteInvalidation(PASSWORDS,
+                                            BuildInvalidation(1, "pw_hint_1"));
 
     // Re-verify the bookmarks to make sure they're unaffected.
     sync_pb::GetUpdateTriggers bm_gu_trigger;
     nudge_tracker_.FillProtoMessage(BOOKMARKS, &bm_gu_trigger);
     ASSERT_EQ(2, bm_gu_trigger.notification_hint_size());
     EXPECT_EQ("bm_hint_1", bm_gu_trigger.notification_hint(0));
     EXPECT_EQ("bm_hint_2",
               bm_gu_trigger.notification_hint(1)); // most recent last.
     EXPECT_FALSE(bm_gu_trigger.client_dropped_hints());
 
     // Verify the new type, too.
     sync_pb::GetUpdateTriggers pw_gu_trigger;
     nudge_tracker_.FillProtoMessage(PASSWORDS, &pw_gu_trigger);
     ASSERT_EQ(1, pw_gu_trigger.notification_hint_size());
     EXPECT_EQ("pw_hint_1", pw_gu_trigger.notification_hint(0));
     EXPECT_FALSE(pw_gu_trigger.client_dropped_hints());
   }
 }
 
 // Test the dropping of invalidation hints.  Receives invalidations one by one.
 TEST_F(NudgeTrackerTest, DropHintsLocally_OneAtATime) {
   for (size_t i = 0; i < GetHintBufferSize(); ++i) {
-    ObjectIdInvalidationMap invalidation_map =
-        BuildInvalidationMap(BOOKMARKS, i, "hint");
-    nudge_tracker_.RecordRemoteInvalidation(invalidation_map);
+    nudge_tracker_.RecordRemoteInvalidation(BOOKMARKS,
+                                            BuildInvalidation(i, "hint"));
   }
   {
     sync_pb::GetUpdateTriggers gu_trigger;
     nudge_tracker_.FillProtoMessage(BOOKMARKS, &gu_trigger);
     EXPECT_EQ(GetHintBufferSize(),
               static_cast<size_t>(gu_trigger.notification_hint_size()));
     EXPECT_FALSE(gu_trigger.client_dropped_hints());
   }
 
   // Force an overflow.
-  ObjectIdInvalidationMap invalidation_map2 =
-      BuildInvalidationMap(BOOKMARKS, 1000, "new_hint");
-  nudge_tracker_.RecordRemoteInvalidation(invalidation_map2);
+  nudge_tracker_.RecordRemoteInvalidation(BOOKMARKS,
+                                          BuildInvalidation(1000, "new_hint"));
 
   {
     sync_pb::GetUpdateTriggers gu_trigger;
     nudge_tracker_.FillProtoMessage(BOOKMARKS, &gu_trigger);
     EXPECT_TRUE(gu_trigger.client_dropped_hints());
     ASSERT_EQ(GetHintBufferSize(),
               static_cast<size_t>(gu_trigger.notification_hint_size()));
 
     // Verify the newest hint was not dropped and is the last in the list.
     EXPECT_EQ("new_hint", gu_trigger.notification_hint(GetHintBufferSize()-1));
 
     // Verify the oldest hint, too.
     EXPECT_EQ("hint", gu_trigger.notification_hint(0));
   }
 }
 
-// Test the dropping of invalidation hints.
-// Receives invalidations in large batches.
-TEST_F(NudgeTrackerTest, DropHintsLocally_ManyHints) {
-  ObjectIdInvalidationMap invalidation_map;
-  for (size_t i = 0; i < GetHintBufferSize(); ++i) {
-    invalidation_map.Insert(BuildInvalidation(BOOKMARKS, i, "hint"));
-  }
-  nudge_tracker_.RecordRemoteInvalidation(invalidation_map);
-  {
-    sync_pb::GetUpdateTriggers gu_trigger;
-    nudge_tracker_.FillProtoMessage(BOOKMARKS, &gu_trigger);
-    EXPECT_EQ(GetHintBufferSize(),
-              static_cast<size_t>(gu_trigger.notification_hint_size()));
-    EXPECT_FALSE(gu_trigger.client_dropped_hints());
-  }
-
-  // Force an overflow.
-  ObjectIdInvalidationMap invalidation_map2;
-  invalidation_map2.Insert(BuildInvalidation(BOOKMARKS, 1000, "new_hint"));
-  invalidation_map2.Insert(BuildInvalidation(BOOKMARKS, 1001, "newer_hint"));
-  nudge_tracker_.RecordRemoteInvalidation(invalidation_map2);
-
-  {
-    sync_pb::GetUpdateTriggers gu_trigger;
-    nudge_tracker_.FillProtoMessage(BOOKMARKS, &gu_trigger);
-    EXPECT_TRUE(gu_trigger.client_dropped_hints());
-    ASSERT_EQ(GetHintBufferSize(),
-              static_cast<size_t>(gu_trigger.notification_hint_size()));
-
-    // Verify the newest hints were not dropped and are the last in the list.
-    EXPECT_EQ("newer_hint",
-              gu_trigger.notification_hint(GetHintBufferSize()-1));
-    EXPECT_EQ("new_hint", gu_trigger.notification_hint(GetHintBufferSize()-2));
-
-    // Verify the oldest hint, too.
-    EXPECT_EQ("hint", gu_trigger.notification_hint(0));
-  }
-}
-
 // Tests the receipt of 'unknown version' invalidations.
 TEST_F(NudgeTrackerTest, DropHintsAtServer_Alone) {
-  ObjectIdInvalidationMap invalidation_map;
-  invalidation_map.Insert(BuildUnknownVersionInvalidation(BOOKMARKS));
-
   // Record the unknown version invalidation.
-  nudge_tracker_.RecordRemoteInvalidation(invalidation_map);
+  nudge_tracker_.RecordRemoteInvalidation(BOOKMARKS,
+                                          BuildUnknownVersionInvalidation());
   {
     sync_pb::GetUpdateTriggers gu_trigger;
     nudge_tracker_.FillProtoMessage(BOOKMARKS, &gu_trigger);
     EXPECT_TRUE(gu_trigger.server_dropped_hints());
     EXPECT_FALSE(gu_trigger.client_dropped_hints());
     ASSERT_EQ(0, gu_trigger.notification_hint_size());
   }
 
   // Clear status then verify.
   nudge_tracker_.RecordSuccessfulSyncCycle();
   {
     sync_pb::GetUpdateTriggers gu_trigger;
     nudge_tracker_.FillProtoMessage(BOOKMARKS, &gu_trigger);
     EXPECT_FALSE(gu_trigger.client_dropped_hints());
     EXPECT_FALSE(gu_trigger.server_dropped_hints());
     ASSERT_EQ(0, gu_trigger.notification_hint_size());
   }
 }
 
 // Tests the receipt of 'unknown version' invalidations.  This test also
 // includes a known version invalidation to mix things up a bit.
 TEST_F(NudgeTrackerTest, DropHintsAtServer_WithOtherInvalidations) {
-  ObjectIdInvalidationMap invalidation_map;
-  invalidation_map.Insert(BuildUnknownVersionInvalidation(BOOKMARKS));
-  invalidation_map.Insert(BuildInvalidation(BOOKMARKS, 10, "hint"));
+  // Record the two invalidations, one with unknown version, the other known.
+  nudge_tracker_.RecordRemoteInvalidation(BOOKMARKS,
+                                          BuildUnknownVersionInvalidation());
+  nudge_tracker_.RecordRemoteInvalidation(BOOKMARKS,
+                                          BuildInvalidation(10, "hint"));
 
-  // Record the two invalidations, one with unknown version, the other unknown.
-  nudge_tracker_.RecordRemoteInvalidation(invalidation_map);
   {
     sync_pb::GetUpdateTriggers gu_trigger;
     nudge_tracker_.FillProtoMessage(BOOKMARKS, &gu_trigger);
     EXPECT_TRUE(gu_trigger.server_dropped_hints());
     EXPECT_FALSE(gu_trigger.client_dropped_hints());
     ASSERT_EQ(1, gu_trigger.notification_hint_size());
     EXPECT_EQ("hint", gu_trigger.notification_hint(0));
   }
 
   // Clear status then verify.
@@ skipping 82 matching lines @@
   nudge_tracker_.RecordSuccessfulSyncCycle();
   EXPECT_FALSE(nudge_tracker_.IsSyncRequired());
 
   // Refresh requests.
   nudge_tracker_.RecordLocalRefreshRequest(ModelTypeSet(SESSIONS));
   EXPECT_TRUE(nudge_tracker_.IsSyncRequired());
   nudge_tracker_.RecordSuccessfulSyncCycle();
   EXPECT_FALSE(nudge_tracker_.IsSyncRequired());
 
   // Invalidations.
-  ObjectIdInvalidationMap invalidation_map =
-      BuildInvalidationMap(PREFERENCES, 1, "hint");
-  nudge_tracker_.RecordRemoteInvalidation(invalidation_map);
+  nudge_tracker_.RecordRemoteInvalidation(PREFERENCES,
+                                          BuildInvalidation(1, "hint"));
   EXPECT_TRUE(nudge_tracker_.IsSyncRequired());
   nudge_tracker_.RecordSuccessfulSyncCycle();
   EXPECT_FALSE(nudge_tracker_.IsSyncRequired());
 }
 
 // Basic tests for the IsGetUpdatesRequired() flag.
 TEST_F(NudgeTrackerTest, IsGetUpdatesRequired) {
   EXPECT_FALSE(nudge_tracker_.IsGetUpdatesRequired());
 
   // Local changes.
   nudge_tracker_.RecordLocalChange(ModelTypeSet(SESSIONS));
   EXPECT_FALSE(nudge_tracker_.IsGetUpdatesRequired());
   nudge_tracker_.RecordSuccessfulSyncCycle();
   EXPECT_FALSE(nudge_tracker_.IsGetUpdatesRequired());
 
   // Refresh requests.
   nudge_tracker_.RecordLocalRefreshRequest(ModelTypeSet(SESSIONS));
   EXPECT_TRUE(nudge_tracker_.IsGetUpdatesRequired());
   nudge_tracker_.RecordSuccessfulSyncCycle();
   EXPECT_FALSE(nudge_tracker_.IsGetUpdatesRequired());
 
   // Invalidations.
-  ObjectIdInvalidationMap invalidation_map =
-      BuildInvalidationMap(PREFERENCES, 1, "hint");
-  nudge_tracker_.RecordRemoteInvalidation(invalidation_map);
+  nudge_tracker_.RecordRemoteInvalidation(PREFERENCES,
+                                          BuildInvalidation(1, "hint"));
   EXPECT_TRUE(nudge_tracker_.IsGetUpdatesRequired());
   nudge_tracker_.RecordSuccessfulSyncCycle();
   EXPECT_FALSE(nudge_tracker_.IsGetUpdatesRequired());
 }
 
 // Test IsSyncRequired() responds correctly to data type throttling.
 TEST_F(NudgeTrackerTest, IsSyncRequired_Throttling) {
   const base::TimeTicks t0 = base::TimeTicks::FromInternalValue(1234);
   const base::TimeDelta throttle_length = base::TimeDelta::FromMinutes(10);
   const base::TimeTicks t1 = t0 + throttle_length;
@@ skipping 296 matching lines @@
   // becomes due.  Perform a successful sync cycle to service it.
   nudge_tracker_.SetSyncCycleStartTime(t6);
   EXPECT_TRUE(nudge_tracker_.IsRetryRequired());
   nudge_tracker_.RecordSuccessfulSyncCycle();
 }
 
 class NudgeTrackerAckTrackingTest : public NudgeTrackerTest {
  public:
   NudgeTrackerAckTrackingTest() {}
 
-  bool IsInvalidationUnacknowledged(const syncer::Invalidation& invalidation) {
-    // Run pending tasks before checking with the MockAckHandler.
-    // The WeakHandle may have posted some tasks for it.
-    base::RunLoop().RunUntilIdle();
-    return mock_ack_handler_.IsUnacked(invalidation);
+  bool IsInvalidationUnacknowledged(int tracking_id) {
+    return tracker_.IsUnacked(tracking_id);
   }
 
-  bool IsInvalidationAcknowledged(const syncer::Invalidation& invalidation) {
-    // Run pending tasks before checking with the MockAckHandler.
-    // The WeakHandle may have posted some tasks for it.
-    base::RunLoop().RunUntilIdle();
-    return mock_ack_handler_.IsAcknowledged(invalidation);
+  bool IsInvalidationAcknowledged(int tracking_id) {
+    return tracker_.IsAcknowledged(tracking_id);
   }
 
-  bool IsInvalidationDropped(const syncer::Invalidation& invalidation) {
-    // Run pending tasks before checking with the MockAckHandler.
-    // The WeakHandle may have posted some tasks for it.
-    base::RunLoop().RunUntilIdle();
-    return mock_ack_handler_.IsDropped(invalidation);
+  bool IsInvalidationDropped(int tracking_id) {
+    return tracker_.IsDropped(tracking_id);
   }
 
-  bool AllInvalidationsAccountedFor() {
-    return mock_ack_handler_.AllInvalidationsAccountedFor();
+  int SendInvalidation(ModelType type, int version, const std::string& hint) {
+    // Build and register the invalidation.
+    scoped_ptr<TrackableMockInvalidation> inv =
+        tracker_.IssueInvalidation(version, hint);
+    int id = inv->GetTrackingId();
+
+    // Send it to the NudgeTracker.
+    nudge_tracker_.RecordRemoteInvalidation(
+        type, inv.PassAs<InvalidationInterface>());
+
+    // Return its ID to the test framework for use in assertions.
+    return id;
   }
 
-  Invalidation SendInvalidation(
-      ModelType type,
-      int64 version,
-      const std::string& hint) {
+  int SendUnknownVersionInvalidation(ModelType type) {
     // Build and register the invalidation.
-    syncer::Invalidation invalidation = BuildInvalidation(type, version, hint);
-    mock_ack_handler_.RegisterInvalidation(&invalidation);
+    scoped_ptr<TrackableMockInvalidation> inv =
+        tracker_.IssueUnknownVersionInvalidation();
+    int id = inv->GetTrackingId();
 
     // Send it to the NudgeTracker.
-    ObjectIdInvalidationMap invalidation_map;
-    invalidation_map.Insert(invalidation);
-    nudge_tracker_.RecordRemoteInvalidation(invalidation_map);
+    nudge_tracker_.RecordRemoteInvalidation(
+        type, inv.PassAs<InvalidationInterface>());
 
-    // Return it to the test framework for use in assertions.
-    return invalidation;
+    // Return its ID to the test framework for use in assertions.
+    return id;
   }
 
-  Invalidation SendUnknownVersionInvalidation(ModelType type) {
-    // Build and register the invalidation.
-    syncer::Invalidation invalidation = BuildUnknownVersionInvalidation(type);
-    mock_ack_handler_.RegisterInvalidation(&invalidation);
-
-    // Send it to the NudgeTracker.
-    ObjectIdInvalidationMap invalidation_map;
-    invalidation_map.Insert(invalidation);
-    nudge_tracker_.RecordRemoteInvalidation(invalidation_map);
-
-    // Return it to the test framework for use in assertions.
-    return invalidation;
+  bool AllInvalidationsAccountedFor() const {
+    return tracker_.AllInvalidationsAccountedFor();
   }
 
   void RecordSuccessfulSyncCycle() {
     nudge_tracker_.RecordSuccessfulSyncCycle();
   }
 
  private:
-  syncer::MockAckHandler mock_ack_handler_;
-  base::MessageLoop loop_;
+  MockInvalidationTracker tracker_;
 };
 
 // Test the acknowledgement of a single invalidation.
 TEST_F(NudgeTrackerAckTrackingTest, SimpleAcknowledgement) {
-  Invalidation inv = SendInvalidation(BOOKMARKS, 10, "hint");
+  int inv_id = SendInvalidation(BOOKMARKS, 10, "hint");
 
-  EXPECT_TRUE(IsInvalidationUnacknowledged(inv));
+  EXPECT_TRUE(IsInvalidationUnacknowledged(inv_id));
 
   RecordSuccessfulSyncCycle();
-  EXPECT_TRUE(IsInvalidationAcknowledged(inv));
+  EXPECT_TRUE(IsInvalidationAcknowledged(inv_id));
 
   EXPECT_TRUE(AllInvalidationsAccountedFor());
 }
 
 // Test the acknowledgement of many invalidations.
 TEST_F(NudgeTrackerAckTrackingTest, ManyAcknowledgements) {
-  Invalidation inv1 = SendInvalidation(BOOKMARKS, 10, "hint");
-  Invalidation inv2 = SendInvalidation(BOOKMARKS, 14, "hint2");
-  Invalidation inv3 = SendInvalidation(PREFERENCES, 8, "hint3");
+  int inv1_id = SendInvalidation(BOOKMARKS, 10, "hint");
+  int inv2_id = SendInvalidation(BOOKMARKS, 14, "hint2");
+  int inv3_id = SendInvalidation(PREFERENCES, 8, "hint3");
 
-  EXPECT_TRUE(IsInvalidationUnacknowledged(inv1));
-  EXPECT_TRUE(IsInvalidationUnacknowledged(inv2));
-  EXPECT_TRUE(IsInvalidationUnacknowledged(inv3));
+  EXPECT_TRUE(IsInvalidationUnacknowledged(inv1_id));
+  EXPECT_TRUE(IsInvalidationUnacknowledged(inv2_id));
+  EXPECT_TRUE(IsInvalidationUnacknowledged(inv3_id));
 
   RecordSuccessfulSyncCycle();
-  EXPECT_TRUE(IsInvalidationAcknowledged(inv1));
-  EXPECT_TRUE(IsInvalidationAcknowledged(inv2));
-  EXPECT_TRUE(IsInvalidationAcknowledged(inv3));
+  EXPECT_TRUE(IsInvalidationAcknowledged(inv1_id));
+  EXPECT_TRUE(IsInvalidationAcknowledged(inv2_id));
+  EXPECT_TRUE(IsInvalidationAcknowledged(inv3_id));
 
   EXPECT_TRUE(AllInvalidationsAccountedFor());
 }
 
 // Test dropping when the buffer overflows and subsequent drop recovery.
 TEST_F(NudgeTrackerAckTrackingTest, OverflowAndRecover) {
-  std::vector<Invalidation> invalidations;
+  std::vector<int> invalidation_ids;
 
-  Invalidation inv10 = SendInvalidation(BOOKMARKS, 10, "hint");
+  int inv10_id = SendInvalidation(BOOKMARKS, 10, "hint");
   for (size_t i = 1; i < GetHintBufferSize(); ++i) {
-    invalidations.push_back(SendInvalidation(BOOKMARKS, i+10, "hint"));
+    invalidation_ids.push_back(SendInvalidation(BOOKMARKS, i + 10, "hint"));
   }
 
-  for (std::vector<Invalidation>::iterator it = invalidations.begin();
-       it != invalidations.end(); ++it) {
+  for (std::vector<int>::iterator it = invalidation_ids.begin();
+       it != invalidation_ids.end();
+       ++it) {
     EXPECT_TRUE(IsInvalidationUnacknowledged(*it));
   }
 
   // This invalidation, though arriving the most recently, has the oldest
   // version number so it should be dropped first.
-  Invalidation inv5 = SendInvalidation(BOOKMARKS, 5, "old_hint");
-  EXPECT_TRUE(IsInvalidationDropped(inv5));
+  int inv5_id = SendInvalidation(BOOKMARKS, 5, "old_hint");
+  EXPECT_TRUE(IsInvalidationDropped(inv5_id));
 
   // This invalidation has a larger version number, so it will force a
   // previously delivered invalidation to be dropped.
-  Invalidation inv100 = SendInvalidation(BOOKMARKS, 100, "new_hint");
-  EXPECT_TRUE(IsInvalidationDropped(inv10));
+  int inv100_id = SendInvalidation(BOOKMARKS, 100, "new_hint");
+  EXPECT_TRUE(IsInvalidationDropped(inv10_id));
 
   // This should recover from the drop and bring us back into sync.
   RecordSuccessfulSyncCycle();
 
-  for (std::vector<Invalidation>::iterator it = invalidations.begin();
-       it != invalidations.end(); ++it) {
+  for (std::vector<int>::iterator it = invalidation_ids.begin();
+       it != invalidation_ids.end();
+       ++it) {
     EXPECT_TRUE(IsInvalidationAcknowledged(*it));
   }
-  EXPECT_TRUE(IsInvalidationAcknowledged(inv100));
+  EXPECT_TRUE(IsInvalidationAcknowledged(inv100_id));
 
   EXPECT_TRUE(AllInvalidationsAccountedFor());
 }
 
 // Test receipt of an unknown version invalidation from the server.
 TEST_F(NudgeTrackerAckTrackingTest, UnknownVersionFromServer_Simple) {
-  Invalidation inv = SendUnknownVersionInvalidation(BOOKMARKS);
-  EXPECT_TRUE(IsInvalidationUnacknowledged(inv));
+  int inv_id = SendUnknownVersionInvalidation(BOOKMARKS);
+  EXPECT_TRUE(IsInvalidationUnacknowledged(inv_id));
   RecordSuccessfulSyncCycle();
-  EXPECT_TRUE(IsInvalidationAcknowledged(inv));
+  EXPECT_TRUE(IsInvalidationAcknowledged(inv_id));
   EXPECT_TRUE(AllInvalidationsAccountedFor());
 }
 
 // Test receipt of multiple unknown version invalidations from the server.
 TEST_F(NudgeTrackerAckTrackingTest, UnknownVersionFromServer_Complex) {
-  Invalidation inv1 = SendUnknownVersionInvalidation(BOOKMARKS);
-  Invalidation inv2 = SendInvalidation(BOOKMARKS, 10, "hint");
-  Invalidation inv3 = SendUnknownVersionInvalidation(BOOKMARKS);
-  Invalidation inv4 = SendUnknownVersionInvalidation(BOOKMARKS);
-  Invalidation inv5 = SendInvalidation(BOOKMARKS, 20, "hint2");
+  int inv1_id = SendUnknownVersionInvalidation(BOOKMARKS);
+  int inv2_id = SendInvalidation(BOOKMARKS, 10, "hint");
+  int inv3_id = SendUnknownVersionInvalidation(BOOKMARKS);
+  int inv4_id = SendUnknownVersionInvalidation(BOOKMARKS);
+  int inv5_id = SendInvalidation(BOOKMARKS, 20, "hint2");
 
   // These invalidations have been overridden, so they got acked early.
-  EXPECT_TRUE(IsInvalidationAcknowledged(inv1));
-  EXPECT_TRUE(IsInvalidationAcknowledged(inv3));
+  EXPECT_TRUE(IsInvalidationAcknowledged(inv1_id));
+  EXPECT_TRUE(IsInvalidationAcknowledged(inv3_id));
 
   // These invalidations are still waiting to be used.
-  EXPECT_TRUE(IsInvalidationUnacknowledged(inv2));
-  EXPECT_TRUE(IsInvalidationUnacknowledged(inv4));
-  EXPECT_TRUE(IsInvalidationUnacknowledged(inv5));
+  EXPECT_TRUE(IsInvalidationUnacknowledged(inv2_id));
+  EXPECT_TRUE(IsInvalidationUnacknowledged(inv4_id));
+  EXPECT_TRUE(IsInvalidationUnacknowledged(inv5_id));
 
   // Finish the sync cycle and expect all remaining invalidations to be acked.
   RecordSuccessfulSyncCycle();
-  EXPECT_TRUE(IsInvalidationAcknowledged(inv1));
-  EXPECT_TRUE(IsInvalidationAcknowledged(inv2));
-  EXPECT_TRUE(IsInvalidationAcknowledged(inv3));
-  EXPECT_TRUE(IsInvalidationAcknowledged(inv4));
-  EXPECT_TRUE(IsInvalidationAcknowledged(inv5));
+  EXPECT_TRUE(IsInvalidationAcknowledged(inv1_id));
+  EXPECT_TRUE(IsInvalidationAcknowledged(inv2_id));
+  EXPECT_TRUE(IsInvalidationAcknowledged(inv3_id));
+  EXPECT_TRUE(IsInvalidationAcknowledged(inv4_id));
+  EXPECT_TRUE(IsInvalidationAcknowledged(inv5_id));
 
   EXPECT_TRUE(AllInvalidationsAccountedFor());
 }
 
 }  // namespace sessions
 }  // namespace syncer