[Sync] Moved tab_node_id tracking to session object and improved foreign session garbage collection.

components/sync_sessions/synced_session_tracker_unittest.cc

 // Copyright 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 <string>
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/rand_util.h"
 #include "base/strings/stringprintf.h"
@@ skipping 52 matching lines @@
                                0);  // win id 10, tab id 15, tab ind 0.
   sync_driver::SyncedSession* session = GetTracker()->GetSession("tag");
   ASSERT_EQ(1U, session->windows.size());
   ASSERT_EQ(1U, session->windows[10]->tabs.size());
   ASSERT_EQ(GetTracker()->GetTab("tag", 15, 1), session->windows[10]->tabs[0]);
   // Should clean up memory on its own.
 }
 
 TEST_F(SyncedSessionTrackerTest, LookupAllForeignSessions) {
   std::vector<const sync_driver::SyncedSession*> sessions;
-  ASSERT_FALSE(GetTracker()->LookupAllForeignSessions(&sessions));
+  ASSERT_FALSE(GetTracker()->LookupAllForeignSessions(
+      &sessions, SyncedSessionTracker::PRESENTABLE));
   GetTracker()->GetSession("tag1");
   GetTracker()->PutWindowInSession("tag1", 0);
   GetTracker()->PutTabInWindow("tag1", 0, 15, 0);
   sessions::SessionTab* tab = GetTracker()->GetTab("tag1", 15, 1);
   ASSERT_TRUE(tab);
   tab->navigations.push_back(
       sessions::SerializedNavigationEntryTestHelper::CreateNavigation(kValidUrl,
                                                                       "title"));
   GetTracker()->GetSession("tag2");
   GetTracker()->GetSession("tag3");
   GetTracker()->PutWindowInSession("tag3", 0);
   GetTracker()->PutTabInWindow("tag3", 0, 15, 0);
   tab = GetTracker()->GetTab("tag3", 15, 1);
   ASSERT_TRUE(tab);
   tab->navigations.push_back(
       sessions::SerializedNavigationEntryTestHelper::CreateNavigation(
           kInvalidUrl, "title"));
-  ASSERT_TRUE(GetTracker()->LookupAllForeignSessions(&sessions));
+  ASSERT_TRUE(GetTracker()->LookupAllForeignSessions(
+      &sessions, SyncedSessionTracker::PRESENTABLE));
   // Only the session with a valid window and tab gets returned.
   ASSERT_EQ(1U, sessions.size());
   ASSERT_EQ("tag1", sessions[0]->session_tag);
+
+  ASSERT_TRUE(GetTracker()->LookupAllForeignSessions(
+      &sessions, SyncedSessionTracker::RAW));
+  ASSERT_EQ(3U, sessions.size());
 }
 
 TEST_F(SyncedSessionTrackerTest, LookupSessionWindows) {
   std::vector<const sessions::SessionWindow*> windows;
   ASSERT_FALSE(GetTracker()->LookupSessionWindows("tag1", &windows));
   GetTracker()->GetSession("tag1");
   GetTracker()->PutWindowInSession("tag1", 0);
   GetTracker()->PutWindowInSession("tag1", 2);
   GetTracker()->GetSession("tag2");
   GetTracker()->PutWindowInSession("tag2", 0);
@@ skipping 21 matching lines @@
   const std::string tag3 = "tag3";
   std::vector<sessions::SessionTab *> tabs1, tabs2;
   sessions::SessionTab* temp_tab;
   ASSERT_TRUE(GetTracker()->Empty());
   ASSERT_EQ(0U, GetTracker()->num_synced_sessions());
   ASSERT_EQ(0U, GetTracker()->num_synced_tabs(tag1));
   tabs1.push_back(GetTracker()->GetTab(tag1, 0, 0));
   tabs1.push_back(GetTracker()->GetTab(tag1, 1, 1));
   tabs1.push_back(GetTracker()->GetTab(tag1, 2, 2));
   ASSERT_EQ(3U, GetTracker()->num_synced_tabs(tag1));
-  ASSERT_EQ(0U, GetTracker()->num_synced_sessions());
+  ASSERT_EQ(1U, GetTracker()->num_synced_sessions());
   temp_tab = GetTracker()->GetTab(tag1, 0, 0);  // Already created.
   ASSERT_EQ(3U, GetTracker()->num_synced_tabs(tag1));
-  ASSERT_EQ(0U, GetTracker()->num_synced_sessions());
+  ASSERT_EQ(1U, GetTracker()->num_synced_sessions());
   ASSERT_EQ(tabs1[0], temp_tab);
   tabs2.push_back(GetTracker()->GetTab(tag2, 0, 0));
   ASSERT_EQ(1U, GetTracker()->num_synced_tabs(tag2));
-  ASSERT_EQ(0U, GetTracker()->num_synced_sessions());
+  ASSERT_EQ(2U, GetTracker()->num_synced_sessions());
   ASSERT_FALSE(GetTracker()->DeleteSession(tag3));
 
   sync_driver::SyncedSession* session = GetTracker()->GetSession(tag1);
   sync_driver::SyncedSession* session2 = GetTracker()->GetSession(tag2);
   sync_driver::SyncedSession* session3 = GetTracker()->GetSession(tag3);
+  session3->device_type = sync_driver::SyncedSession::TYPE_OTHER;
   ASSERT_EQ(3U, GetTracker()->num_synced_sessions());
 
   ASSERT_TRUE(session);
   ASSERT_TRUE(session2);
   ASSERT_TRUE(session3);
   ASSERT_NE(session, session2);
   ASSERT_NE(session2, session3);
   ASSERT_TRUE(GetTracker()->DeleteSession(tag3));
   ASSERT_EQ(2U, GetTracker()->num_synced_sessions());
 
@@ skipping 10 matching lines @@
   ASSERT_EQ(static_cast<const sessions::SessionTab*>(NULL), tab_ptr);
 
   std::vector<const sessions::SessionWindow*> windows;
   ASSERT_TRUE(GetTracker()->LookupSessionWindows(tag1, &windows));
   ASSERT_EQ(1U, windows.size());
   ASSERT_TRUE(GetTracker()->LookupSessionWindows(tag2, &windows));
   ASSERT_EQ(0U, windows.size());
 
   // The sessions don't have valid tabs, lookup should not succeed.
   std::vector<const sync_driver::SyncedSession*> sessions;
-  ASSERT_FALSE(GetTracker()->LookupAllForeignSessions(&sessions));
+  ASSERT_FALSE(GetTracker()->LookupAllForeignSessions(
+      &sessions, SyncedSessionTracker::PRESENTABLE));
+  ASSERT_TRUE(GetTracker()->LookupAllForeignSessions(
+      &sessions, SyncedSessionTracker::RAW));
+  ASSERT_EQ(2U, sessions.size());
 
   GetTracker()->Clear();
   ASSERT_EQ(0U, GetTracker()->num_synced_tabs(tag1));
   ASSERT_EQ(0U, GetTracker()->num_synced_tabs(tag2));
   ASSERT_EQ(0U, GetTracker()->num_synced_sessions());
 }
 
 TEST_F(SyncedSessionTrackerTest, ManyGetTabs) {
   ASSERT_TRUE(GetTracker()->Empty());
   const int kMaxSessions = 10;
@@ skipping 13 matching lines @@
 }
 
 TEST_F(SyncedSessionTrackerTest, LookupTabNodeIds) {
   std::set<int> result;
   std::string tag1 = "session1";
   std::string tag2 = "session2";
   std::string tag3 = "session3";
 
   GetTracker()->GetTab(tag1, 1, 1);
   GetTracker()->GetTab(tag1, 2, 2);
-  EXPECT_TRUE(GetTracker()->LookupTabNodeIds(tag1, &result));
+  GetTracker()->LookupTabNodeIds(tag1, &result);
   EXPECT_EQ(2U, result.size());
   EXPECT_FALSE(result.end() == result.find(1));
   EXPECT_FALSE(result.end() == result.find(2));
-  EXPECT_FALSE(GetTracker()->LookupTabNodeIds(tag2, &result));
+  GetTracker()->LookupTabNodeIds(tag2, &result);
+  EXPECT_TRUE(result.empty());
 
   GetTracker()->PutWindowInSession(tag1, 0);
   GetTracker()->PutTabInWindow(tag1, 0, 3, 0);
-  EXPECT_TRUE(GetTracker()->LookupTabNodeIds(tag1, &result));
+  GetTracker()->LookupTabNodeIds(tag1, &result);
   EXPECT_EQ(2U, result.size());
 
   GetTracker()->GetTab(tag1, 3, 3);
-  EXPECT_TRUE(GetTracker()->LookupTabNodeIds(tag1, &result));
+  GetTracker()->LookupTabNodeIds(tag1, &result);
   EXPECT_EQ(3U, result.size());
   EXPECT_FALSE(result.end() == result.find(3));
 
   GetTracker()->GetTab(tag2, 1, 21);
   GetTracker()->GetTab(tag2, 2, 22);
-  EXPECT_TRUE(GetTracker()->LookupTabNodeIds(tag2, &result));
+  GetTracker()->LookupTabNodeIds(tag2, &result);
   EXPECT_EQ(2U, result.size());
   EXPECT_FALSE(result.end() == result.find(21));
   EXPECT_FALSE(result.end() == result.find(22));
-  EXPECT_TRUE(GetTracker()->LookupTabNodeIds(tag1, &result));
+  GetTracker()->LookupTabNodeIds(tag1, &result);
   EXPECT_EQ(3U, result.size());
   EXPECT_FALSE(result.end() == result.find(1));
   EXPECT_FALSE(result.end() == result.find(2));
 
-  EXPECT_FALSE(GetTracker()->LookupTabNodeIds(tag3, &result));
+  GetTracker()->LookupTabNodeIds(tag3, &result);
+  EXPECT_TRUE(result.empty());
   GetTracker()->PutWindowInSession(tag3, 1);
   GetTracker()->PutTabInWindow(tag3, 1, 5, 0);
-  EXPECT_TRUE(GetTracker()->LookupTabNodeIds(tag3, &result));
+  GetTracker()->LookupTabNodeIds(tag3, &result);
   EXPECT_TRUE(result.empty());
-  EXPECT_TRUE(GetTracker()->DeleteSession(tag3));
-  EXPECT_FALSE(GetTracker()->LookupTabNodeIds(tag3, &result));
+  EXPECT_FALSE(GetTracker()->DeleteSession(tag3));
+  GetTracker()->LookupTabNodeIds(tag3, &result);
+  EXPECT_TRUE(result.empty());
 
-  EXPECT_TRUE(GetTracker()->DeleteSession(tag1));
-  EXPECT_FALSE(GetTracker()->LookupTabNodeIds(tag1, &result));
-  EXPECT_TRUE(GetTracker()->LookupTabNodeIds(tag2, &result));
+  EXPECT_FALSE(GetTracker()->DeleteSession(tag1));
+  GetTracker()->LookupTabNodeIds(tag1, &result);
+  EXPECT_TRUE(result.empty());
+  GetTracker()->LookupTabNodeIds(tag2, &result);
   EXPECT_EQ(2U, result.size());
   EXPECT_FALSE(result.end() == result.find(21));
   EXPECT_FALSE(result.end() == result.find(22));
-  EXPECT_TRUE(GetTracker()->DeleteSession(tag2));
-  EXPECT_FALSE(GetTracker()->LookupTabNodeIds(tag2, &result));
+
+  GetTracker()->GetTab(tag2, 1, 21);
+  GetTracker()->GetTab(tag2, 2, 23);
+  GetTracker()->LookupTabNodeIds(tag2, &result);
+  EXPECT_EQ(3U, result.size());
+  EXPECT_FALSE(result.end() == result.find(21));
+  EXPECT_FALSE(result.end() == result.find(22));
+  EXPECT_FALSE(result.end() == result.find(23));
+
+  EXPECT_FALSE(GetTracker()->DeleteSession(tag2));
+  GetTracker()->LookupTabNodeIds(tag2, &result);
+  EXPECT_TRUE(result.empty());
 }
 
 TEST_F(SyncedSessionTrackerTest, SessionTracking) {
   ASSERT_TRUE(GetTracker()->Empty());
   std::string tag1 = "tag1";
   std::string tag2 = "tag2";
 
   // Create some session information that is stale.
   sync_driver::SyncedSession* session1 = GetTracker()->GetSession(tag1);
   GetTracker()->PutWindowInSession(tag1, 0);
@@ skipping 42 matching lines @@
   ASSERT_EQ(1U, session2->windows.size());
   ASSERT_EQ(1U, session2->windows[2]->tabs.size());
   ASSERT_EQ(2U, GetTracker()->num_synced_sessions());
   ASSERT_EQ(4U, GetTracker()->num_synced_tabs(tag1));
   ASSERT_EQ(1U, GetTracker()->num_synced_tabs(tag2));
 
   // All memory should be properly deallocated by destructor for the
   // SyncedSessionTracker.
 }
 
+TEST_F(SyncedSessionTrackerTest, DeleteForeignTab) {
+  std::string session_tag = "session_tag";
+  int tab_id_1 = 1;
+  int tab_id_2 = 2;
+  int tab_node_id_3 = 3;
+  int tab_node_id_4 = 4;
+  std::set<int> result;
+
+  GetTracker()->GetTab(session_tag, tab_id_1, tab_node_id_3);
+  GetTracker()->GetTab(session_tag, tab_id_1, tab_node_id_4);
+  GetTracker()->GetTab(session_tag, tab_id_2, tab_node_id_3);
+  GetTracker()->GetTab(session_tag, tab_id_2, tab_node_id_4);
+
+  GetTracker()->LookupTabNodeIds(session_tag, &result);
+  EXPECT_EQ(2U, result.size());
+  EXPECT_TRUE(result.find(tab_node_id_3) != result.end());
+  EXPECT_TRUE(result.find(tab_node_id_4) != result.end());
+
+  GetTracker()->DeleteForeignTab(session_tag, tab_node_id_3);
+  GetTracker()->LookupTabNodeIds(session_tag, &result);
+  EXPECT_EQ(1U, result.size());
+  EXPECT_TRUE(result.find(tab_node_id_4) != result.end());
+
+  GetTracker()->DeleteForeignTab(session_tag, tab_node_id_4);
+  GetTracker()->LookupTabNodeIds(session_tag, &result);
+  EXPECT_TRUE(result.empty());
+}
+
 }  // namespace browser_sync