sync: add garbage collection to SessionsSyncManager

chrome/browser/sync/sessions2/sessions_sync_manager_unittest.cc

Index: chrome/browser/sync/sessions2/sessions_sync_manager_unittest.cc
diff --git a/chrome/browser/sync/sessions2/sessions_sync_manager_unittest.cc b/chrome/browser/sync/sessions2/sessions_sync_manager_unittest.cc
index f7beef9e2969a10708649aa1f9c054115df0c767..0396bbf885a8252c1fe8c1b1fecd17735ff6778f 100644
--- a/chrome/browser/sync/sessions2/sessions_sync_manager_unittest.cc
+++ b/chrome/browser/sync/sessions2/sessions_sync_manager_unittest.cc
@@ -1189,6 +1189,108 @@ TEST_F(SessionsSyncManagerTest, MergeLocalSessionExistingTabs) {
       GetEntryAtIndex(1)->GetVirtualURL());
 }
 
+TEST_F(SessionsSyncManagerTest, DoGarbageCollection) {

[rlarocque, 2013/11/22 01:42:06]

nit: Comment on the purpose of this test.  And the other one, too.

I think there should be a rule that all tests should be tagged with a brief
comment, though I admit we're currently not very consistent about it.

+  // Fill two instances of session specifics with a foreign session's data.
+  std::string tag1 = "tag1";
+  SessionID::id_type n1[] = {5, 10, 13, 17};
+  std::vector<SessionID::id_type> tab_list1(n1, n1 + arraysize(n1));
+  std::vector<sync_pb::SessionSpecifics> tabs1;
+  sync_pb::SessionSpecifics meta(helper()->BuildForeignSession(
+      tag1, tab_list1, &tabs1));
+  std::string tag2 = "tag2";
+  SessionID::id_type n2[] = {8, 15, 18, 20};
+  std::vector<SessionID::id_type> tab_list2(n2, n2 + arraysize(n2));
+  std::vector<sync_pb::SessionSpecifics> tabs2;
+  sync_pb::SessionSpecifics meta2(helper()->BuildForeignSession(
+      tag2, tab_list2, &tabs2));
+  // Set the modification time for tag1 to be 21 days ago, tag2 to 5 days ago.
+  base::Time tag1_time = base::Time::Now() - base::TimeDelta::FromDays(21);
+  base::Time tag2_time = base::Time::Now() - base::TimeDelta::FromDays(5);
+
+  syncer::SyncDataList foreign_data;
+  sync_pb::EntitySpecifics entity1, entity2;
+  entity1.mutable_session()->CopyFrom(meta);
+  entity2.mutable_session()->CopyFrom(meta2);
+  foreign_data.push_back(SyncData::CreateRemoteData(1, entity1, tag1_time));
+  foreign_data.push_back(SyncData::CreateRemoteData(1, entity2, tag2_time));
+  AddTabsToSyncDataList(tabs1, &foreign_data);
+  AddTabsToSyncDataList(tabs2, &foreign_data);
+
+  syncer::SyncChangeList output;
+  InitWithSyncDataTakeOutput(foreign_data, &output);
+  ASSERT_EQ(2U, output.size());
+  output.clear();
+
+  // Check that the foreign session was associated and retrieve the data.
+  std::vector<const SyncedSession*> foreign_sessions;
+  ASSERT_TRUE(manager()->GetAllForeignSessions(&foreign_sessions));
+  ASSERT_EQ(2U, foreign_sessions.size());
+  foreign_sessions.clear();
+
+  // Now garbage collect and verify the non-stale session is still there.
+  manager()->DoGarbageCollection();
+  ASSERT_EQ(5U, output.size());
+  EXPECT_EQ(SyncChange::ACTION_DELETE, output[0].change_type());
+  const SyncData data(output[0].sync_data());
+  EXPECT_EQ(tag1, data.GetTag());
+  for (int i = 1; i < 5; i++) {
+    EXPECT_EQ(SyncChange::ACTION_DELETE, output[i].change_type());
+    const SyncData data(output[i].sync_data());
+    EXPECT_EQ(TabNodePool2::TabIdToTag(tag1, i), data.GetTag());
+  }
+
+  ASSERT_TRUE(manager()->GetAllForeignSessions(&foreign_sessions));
+  ASSERT_EQ(1U, foreign_sessions.size());
+  std::vector<std::vector<SessionID::id_type> > session_reference;
+  session_reference.push_back(tab_list2);
+  helper()->VerifySyncedSession(tag2, session_reference,
+                                *(foreign_sessions[0]));
+}
+
+TEST_F(SessionsSyncManagerTest, GarbageCollectionHonoursUpdate) {
+  std::string tag1 = "tag1";
+  SessionID::id_type n1[] = {5, 10, 13, 17};
+  std::vector<SessionID::id_type> tab_list1(n1, n1 + arraysize(n1));
+  std::vector<sync_pb::SessionSpecifics> tabs1;
+  sync_pb::SessionSpecifics meta(helper()->BuildForeignSession(
+      tag1, tab_list1, &tabs1));
+  syncer::SyncDataList foreign_data;
+  sync_pb::EntitySpecifics entity1;
+  base::Time tag1_time = base::Time::Now() - base::TimeDelta::FromDays(21);
+  entity1.mutable_session()->CopyFrom(meta);
+  foreign_data.push_back(SyncData::CreateRemoteData(1, entity1, tag1_time));
+  AddTabsToSyncDataList(tabs1, &foreign_data);
+  syncer::SyncChangeList output;
+  InitWithSyncDataTakeOutput(foreign_data, &output);
+  ASSERT_EQ(2U, output.size());
+
+  // Update to a non-stale time.
+  sync_pb::EntitySpecifics update_entity;
+  update_entity.mutable_session()->CopyFrom(tabs1[0]);
+  syncer::SyncChangeList changes;
+  changes.push_back(syncer::SyncChange(
+      FROM_HERE,
+      SyncChange::ACTION_UPDATE,
+      syncer::SyncData::CreateRemoteData(1, update_entity,
+                                         base::Time::Now())));
+  manager()->ProcessSyncChanges(FROM_HERE, changes);
+
+  // Check that the foreign session was associated and retrieve the data.
+  std::vector<const SyncedSession*> foreign_sessions;
+  ASSERT_TRUE(manager()->GetAllForeignSessions(&foreign_sessions));
+  ASSERT_EQ(1U, foreign_sessions.size());
+  foreign_sessions.clear();
+
+  // Verify the now non-stale session does not get deleted.
+  manager()->DoGarbageCollection();
+  ASSERT_TRUE(manager()->GetAllForeignSessions(&foreign_sessions));
+  ASSERT_EQ(1U, foreign_sessions.size());
+  std::vector<std::vector<SessionID::id_type> > session_reference;
+  session_reference.push_back(tab_list1);
+  helper()->VerifySyncedSession(
+      tag1, session_reference, *(foreign_sessions[0]));
+}
+
 TEST_F(SessionsSyncManagerTest, CheckPrerenderedWebContentsSwap) {
   AddTab(browser(), GURL("http://foo1"));
   NavigateAndCommitActiveTab(GURL("http://foo2"));