sync: add garbage collection to SessionsSyncManager

chrome/browser/sync/sessions2/sessions_sync_manager_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 "chrome/browser/sync/sessions2/sessions_sync_manager.h"
 
 #include "base/strings/string_util.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/sessions/session_id.h"
 #include "chrome/browser/sessions/session_tab_helper.h"
@@ skipping 183 matching lines @@
     EXPECT_TRUE(found);
     return list;
   }
 
  private:
   scoped_ptr<SessionsSyncManager> manager_;
   SessionSyncTestHelper helper_;
   TestSyncProcessorStub* test_processor_;
 };
 
+// Test that the SyncSessionManager can properly fill in a SessionHeader.
 TEST_F(SessionsSyncManagerTest, PopulateSessionHeader) {
   sync_pb::SessionHeader header_s;
   header_s.set_client_name("Client 1");
   header_s.set_device_type(sync_pb::SyncEnums_DeviceType_TYPE_WIN);
 
   SyncedSession session;
   base::Time time = base::Time::Now();
   SessionsSyncManager::PopulateSessionHeaderFromSpecifics(
       header_s, time, &session);
   ASSERT_EQ("Client 1", session.session_name);
   ASSERT_EQ(SyncedSession::TYPE_WIN, session.device_type);
   ASSERT_EQ(time, session.modified_time);
 }
 
+// Test translation between protobuf types and chrome session types.
 TEST_F(SessionsSyncManagerTest, PopulateSessionWindow) {
   sync_pb::SessionWindow window_s;
   window_s.add_tab(0);
   window_s.set_browser_type(sync_pb::SessionWindow_BrowserType_TYPE_TABBED);
   window_s.set_selected_tab_index(1);
 
   std::string tag = "tag";
   SyncedSession* session = manager()->session_tracker_.GetSession(tag);
   manager()->session_tracker_.PutWindowInSession(tag, 0);
   manager()->BuildSyncedSessionFromSpecifics(
@@ skipping 288 matching lines @@
   EXPECT_EQ(kTime3, session_tab.navigations[2].timestamp());
   EXPECT_EQ(SerializedNavigationEntry::STATE_ALLOWED,
             session_tab.navigations[0].blocked_state());
   EXPECT_EQ(SerializedNavigationEntry::STATE_BLOCKED,
             session_tab.navigations[1].blocked_state());
   EXPECT_EQ(SerializedNavigationEntry::STATE_BLOCKED,
             session_tab.navigations[2].blocked_state());
   EXPECT_TRUE(session_tab.session_storage_persistent_id.empty());
 }
 
+// Tests that the local session header objects is created properly in
+// presence of no other session activity, once and only once.
 TEST_F(SessionsSyncManagerTest, MergeLocalSessionNoTabs) {
   syncer::SyncChangeList out;
   InitWithSyncDataTakeOutput(syncer::SyncDataList(), &out);
   EXPECT_FALSE(manager()->current_machine_tag().empty());
 
   EXPECT_EQ(2U, out.size());
   EXPECT_TRUE(out[0].IsValid());
   EXPECT_EQ(SyncChange::ACTION_ADD, out[0].change_type());
   const SyncData data(out[0].sync_data());
   EXPECT_EQ(manager()->current_machine_tag(), data.GetTag());
@@ skipping 26 matching lines @@
           new TestSyncProcessorStub(&out)),
       scoped_ptr<syncer::SyncErrorFactory>(
           new syncer::SyncErrorFactoryMock()));
   ASSERT_FALSE(result.error().IsSet());
 
   EXPECT_EQ(1U, out.size());
   EXPECT_EQ(SyncChange::ACTION_UPDATE, out[0].change_type());
   EXPECT_TRUE(out[0].sync_data().GetSpecifics().session().has_header());
 }
 
+// Tests MergeDataAndStartSyncing with sync data but no local data.
 TEST_F(SessionsSyncManagerTest, MergeWithInitialForeignSession) {
   std::string tag = "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(
       tag, tab_list1, &tabs1));
   // Add a second window.
   SessionID::id_type n2[] = {7, 15, 18, 20};
@@ skipping 95 matching lines @@
   ASSERT_TRUE(manager()->GetAllForeignSessions(&foreign_sessions));
   std::vector<std::vector<SessionID::id_type> > session_reference;
   session_reference.push_back(tab_list1);
   helper()->VerifySyncedSession(tag, session_reference, *(foreign_sessions[0]));
   // There should be one and only one foreign session. If VerifySyncedSession
   // was successful above this EXPECT call ensures the local session didn't
   // get mistakenly added to foreign tracking (Similar to ExistingTabs test).
   EXPECT_EQ(1U, foreign_sessions.size());
 }
 
+// Tests the common scenario.  Merge with both local and foreign session data
+// followed by updates flowing from sync and local.
 TEST_F(SessionsSyncManagerTest, UpdatesAfterMixedMerge) {
   // Add local and foreign data.
   AddTab(browser(), GURL("http://foo1"));
   NavigateAndCommitActiveTab(GURL("http://foo2"));
 
   std::string tag1 = "tag1";
   syncer::SyncDataList foreign_data1;
   std::vector<std::vector<SessionID::id_type> > meta1_reference;
   sync_pb::SessionSpecifics meta1;
 
@@ skipping 73 matching lines @@
   removal.push_back(MakeRemoteChange(1, meta1, SyncChange::ACTION_UPDATE));
   AddTabsToChangeList(tabs1, SyncChange::ACTION_UPDATE, &removal);
   manager()->ProcessSyncChanges(FROM_HERE, removal);
 
   ASSERT_TRUE(manager()->GetAllForeignSessions(&foreign_sessions));
   ASSERT_EQ(2U, foreign_sessions.size());
   ASSERT_EQ(3U, foreign_sessions[0]->windows.find(0)->second->tabs.size());
   helper()->VerifySyncedSession(tag1, meta1_reference, *(foreign_sessions[0]));
 }
 
+// Tests that this SyncSessionManager knows how to delete foreign sessions
+// if it wants to.
 TEST_F(SessionsSyncManagerTest, DeleteForeignSession) {
   InitWithNoSyncData();
   std::string tag = "tag1";
   syncer::SyncChangeList changes;
 
   std::vector<const SyncedSession*> foreign_sessions;
   ASSERT_FALSE(manager()->GetAllForeignSessions(&foreign_sessions));
   manager()->DeleteForeignSessionInternal(tag, &changes);
   ASSERT_FALSE(manager()->GetAllForeignSessions(&foreign_sessions));
   EXPECT_TRUE(changes.empty());
@@ skipping 108 matching lines @@
   // Check that the foreign session was associated and retrieve the data.
   foreign_sessions.clear();
   ASSERT_TRUE(manager()->GetAllForeignSessions(&foreign_sessions));
   ASSERT_EQ(1U, foreign_sessions.size());
   ASSERT_EQ(1U, foreign_sessions[0]->windows.size());
   std::vector<std::vector<SessionID::id_type> > session_reference;
   session_reference.push_back(tab_list1);
   helper()->VerifySyncedSession(tag, session_reference, *(foreign_sessions[0]));
 }
 
+// Test that receiving a session delete from sync removes the session
+// from tracking.
 TEST_F(SessionsSyncManagerTest, ProcessForeignDelete) {
   InitWithNoSyncData();
   SessionID::id_type n[] = {5};
   std::vector<sync_pb::SessionSpecifics> tabs1;
   std::vector<SessionID::id_type> tab_list(n, n + arraysize(n));
   sync_pb::SessionSpecifics meta(helper()->BuildForeignSession(
       "tag1", tab_list, &tabs1));
 
   syncer::SyncChangeList changes;
   changes.push_back(MakeRemoteChange(1, meta, SyncChange::ACTION_ADD));
@@ skipping 95 matching lines @@
   const SyncData data(out[2].sync_data());
   EXPECT_EQ(manager()->current_machine_tag(), data.GetTag());
   const sync_pb::SessionSpecifics& specifics(data.GetSpecifics().session());
   EXPECT_EQ(manager()->current_machine_tag(), specifics.session_tag());
   EXPECT_TRUE(specifics.has_header());
   const sync_pb::SessionHeader& header_s = specifics.header();
   EXPECT_EQ(1, header_s.window_size());
   EXPECT_EQ(1, header_s.window(0).tab_size());
 }
 
+// Tests that the SyncSessionManager responds to local tab events properly.
 TEST_F(SessionsSyncManagerTest, OnLocalTabModified) {
   syncer::SyncChangeList out;
   // Init with no local data, relies on MergeLocalSessionNoTabs.
   InitWithSyncDataTakeOutput(syncer::SyncDataList(), &out);
   ASSERT_FALSE(manager()->current_machine_tag().empty());
   ASSERT_EQ(2U, out.size());
 
   // Copy the original header.
   sync_pb::EntitySpecifics header(out[0].sync_data().GetSpecifics());
   out.clear();
@@ skipping 149 matching lines @@
   EXPECT_EQ(GURL("http://foo2"), iter->second->tab()->
           GetEntryAtIndex(1)->GetVirtualURL());
   iter++;
   ASSERT_EQ(2, iter->second->tab()->GetEntryCount());
   EXPECT_EQ(GURL("http://bar1"), iter->second->tab()->
       GetEntryAtIndex(0)->GetVirtualURL());
   EXPECT_EQ(GURL("http://bar2"), iter->second->tab()->
       GetEntryAtIndex(1)->GetVirtualURL());
 }
 
+// Test garbage collection of stale foreign sessions.
+TEST_F(SessionsSyncManagerTest, DoGarbageCollection) {
+  // 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 that an update to a previously considered "stale" session,
+// prior to garbage collection, will save the session from deletion.
+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 that swapping WebContents for a tab is properly observed and handled
+// by the SessionsSyncManager.
 TEST_F(SessionsSyncManagerTest, CheckPrerenderedWebContentsSwap) {
   AddTab(browser(), GURL("http://foo1"));
   NavigateAndCommitActiveTab(GURL("http://foo2"));
 
   syncer::SyncChangeList out;
   InitWithSyncDataTakeOutput(syncer::SyncDataList(), &out);
   ASSERT_EQ(4U, out.size());  // Header, tab ADD, tab UPDATE, header UPDATE.
 
   // To simulate WebContents swap during prerendering, create new WebContents
   // and swap with old WebContents.
@@ skipping 65 matching lines @@
     notified_of_update_ = false;
     notified_of_refresh_ = false;
   }
  private:
   content::NotificationRegistrar registrar_;
   bool notified_of_update_;
   bool notified_of_refresh_;
 };
 }  // namespace
 
+// Test that NOTIFICATION_FOREIGN_SESSION_UPDATED is sent.
 TEST_F(SessionsSyncManagerTest, NotifiedOfUpdates) {
   SessionNotificationObserver observer;
   ASSERT_FALSE(observer.notified_of_update());
   InitWithNoSyncData();
 
   SessionID::id_type n[] = {5};
   std::vector<sync_pb::SessionSpecifics> tabs1;
   std::vector<SessionID::id_type> tab_list(n, n + arraysize(n));
   sync_pb::SessionSpecifics meta(helper()->BuildForeignSession(
       "tag1", tab_list, &tabs1));
@@ skipping 25 matching lines @@
   ASSERT_FALSE(observer.notified_of_refresh());
   InitWithNoSyncData();
   AddTab(browser(), GURL("http://foo1"));
   EXPECT_FALSE(observer.notified_of_refresh());
   NavigateAndCommitActiveTab(GURL("chrome://newtab/#open_tabs"));
   EXPECT_TRUE(observer.notified_of_refresh());
 }
 #endif  // defined(OS_ANDROID) || defined(OS_IOS)
 
 }  // namespace browser_sync