[Sync] Introduce SyncedSessionWindow type.

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 "components/sync_sessions/synced_session_tracker.h"
 
 #include "base/rand_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/sessions/core/serialized_navigation_entry_test_helper.h"
@@ skipping 51 matching lines @@
   SyncedSession* session = GetTracker()->GetSession(kTag);
   ASSERT_EQ(1U, session->windows.size());
   // Should clean up memory on its own.
 }
 
 TEST_F(SyncedSessionTrackerTest, PutTabInWindow) {
   GetTracker()->PutWindowInSession(kTag, 10);
   GetTracker()->PutTabInWindow(kTag, 10, 15);  // win id 10, tab id 15
   SyncedSession* session = GetTracker()->GetSession(kTag);
   ASSERT_EQ(1U, session->windows.size());
-  ASSERT_EQ(1U, session->windows[10]->tabs.size());
+  ASSERT_EQ(1U, session->windows[10]->wrapped_window.tabs.size());
   ASSERT_EQ(GetTracker()->GetTab(kTag, 15),
-            session->windows[10]->tabs[0].get());
+            session->windows[10]->wrapped_window.tabs[0].get());
   // Should clean up memory on its own.
 }
 
 TEST_F(SyncedSessionTrackerTest, LookupAllForeignSessions) {
   std::vector<const SyncedSession*> sessions;
   ASSERT_FALSE(GetTracker()->LookupAllForeignSessions(
       &sessions, SyncedSessionTracker::PRESENTABLE));
   GetTracker()->GetSession(kTag);
   GetTracker()->PutWindowInSession(kTag, 0);
   GetTracker()->PutTabInWindow(kTag, 0, 15);
@@ skipping 203 matching lines @@
   SyncedSession* session1 = GetTracker()->GetSession(kTag);
   GetTracker()->PutWindowInSession(kTag, 0);
   GetTracker()->PutTabInWindow(kTag, 0, 0);
   GetTracker()->PutTabInWindow(kTag, 0, 1);
   GetTracker()->GetTab(kTag, 2)->window_id.set_id(0);  // Will be unmapped.
   GetTracker()->GetTab(kTag, 3)->window_id.set_id(0);  // Will be unmapped.
   GetTracker()->PutWindowInSession(kTag, 1);
   GetTracker()->PutTabInWindow(kTag, 1, 4);
   GetTracker()->PutTabInWindow(kTag, 1, 5);
   ASSERT_EQ(2U, session1->windows.size());
-  ASSERT_EQ(2U, session1->windows[0]->tabs.size());
-  ASSERT_EQ(2U, session1->windows[1]->tabs.size());
+  ASSERT_EQ(2U, session1->windows[0]->wrapped_window.tabs.size());
+  ASSERT_EQ(2U, session1->windows[1]->wrapped_window.tabs.size());
   ASSERT_EQ(6U, GetTracker()->num_synced_tabs(kTag));
 
   // Create a session that should not be affected.
   SyncedSession* session2 = GetTracker()->GetSession(kTag2);
   GetTracker()->PutWindowInSession(kTag2, 2);
   GetTracker()->PutTabInWindow(kTag2, 2, 1);
   ASSERT_EQ(1U, session2->windows.size());
-  ASSERT_EQ(1U, session2->windows[2]->tabs.size());
+  ASSERT_EQ(1U, session2->windows[2]->wrapped_window.tabs.size());
   ASSERT_EQ(1U, GetTracker()->num_synced_tabs(kTag2));
 
   // Reset tracking and get the current windows/tabs.
   // We simulate moving a tab from one window to another, then closing the
   // first window (including its one remaining tab), and opening a new tab
   // on the remaining window.
 
   // New tab, arrived before meta node so unmapped.
   GetTracker()->GetTab(kTag, 6);
   GetTracker()->ResetSessionTracking(kTag);
   GetTracker()->PutWindowInSession(kTag, 0);
   GetTracker()->PutTabInWindow(kTag, 0, 0);
   // Tab 1 is closed.
   GetTracker()->PutTabInWindow(kTag, 0, 2);  // No longer unmapped.
   // Tab 3 was unmapped and does not get used.
   GetTracker()->PutTabInWindow(kTag, 0, 4);  // Moved from window 1.
   // Window 1 was closed, along with tab 5.
   GetTracker()->PutTabInWindow(kTag, 0, 6);  // No longer unmapped.
   // Session 2 should not be affected.
   GetTracker()->CleanupForeignSession(kTag);
 
   // Verify that only those parts of the session not owned have been removed.
   ASSERT_EQ(1U, session1->windows.size());
-  ASSERT_EQ(4U, session1->windows[0]->tabs.size());
+  ASSERT_EQ(4U, session1->windows[0]->wrapped_window.tabs.size());
   ASSERT_EQ(1U, session2->windows.size());
-  ASSERT_EQ(1U, session2->windows[2]->tabs.size());
+  ASSERT_EQ(1U, session2->windows[2]->wrapped_window.tabs.size());
   ASSERT_EQ(2U, GetTracker()->num_synced_sessions());
   ASSERT_EQ(4U, GetTracker()->num_synced_tabs(kTag));
   ASSERT_EQ(1U, GetTracker()->num_synced_tabs(kTag2));
 
   // All memory should be properly deallocated by destructor for the
   // SyncedSessionTracker.
 }
 
 TEST_F(SyncedSessionTrackerTest, DeleteForeignTab) {
   int tab_node_id_1 = 1;
@@ skipping 89 matching lines @@
   EXPECT_TRUE(GetTracker()->IsTabUnmappedForTesting(kTab1));
 
   // Map it to a window with the same tab id as it was created with.
   GetTracker()->ResetSessionTracking(kTag);
   GetTracker()->PutWindowInSession(kTag, kWindow1);
   GetTracker()->PutTabInWindow(kTag, kWindow1, kTab1);
   GetTracker()->CleanupLocalTabs(&free_node_ids);
   EXPECT_FALSE(GetTracker()->IsTabUnmappedForTesting(kTab1));
   SyncedSession* session = GetTracker()->GetSession(kTag);
   ASSERT_EQ(1U, session->windows.size());
-  ASSERT_EQ(1U, session->windows[kWindow1]->tabs.size());
+  ASSERT_EQ(1U, session->windows[kWindow1]->wrapped_window.tabs.size());
   ASSERT_EQ(GetTracker()->GetTab(kTag, kTab1),
-            session->windows[kWindow1]->tabs[0].get());
+            session->windows[kWindow1]->wrapped_window.tabs[0].get());
 
   // Then reassociate with a new tab id.
   GetTracker()->ReassociateLocalTab(kTabNode, kTab2);
   EXPECT_TRUE(GetTracker()->IsLocalTabNodeAssociated(kTabNode));
   EXPECT_FALSE(GetTracker()->IsTabUnmappedForTesting(kTab2));
   EXPECT_FALSE(GetTracker()->IsTabUnmappedForTesting(kTab1));
 
   // Reset tracking, and put the new tab id into the window.
   GetTracker()->ResetSessionTracking(kTag);
   EXPECT_TRUE(GetTracker()->IsTabUnmappedForTesting(kTab2));
   GetTracker()->PutWindowInSession(kTag, kWindow1);
   GetTracker()->PutTabInWindow(kTag, kWindow1, kTab2);
   GetTracker()->CleanupLocalTabs(&free_node_ids);
   EXPECT_TRUE(free_node_ids.empty());
   EXPECT_FALSE(GetTracker()->IsTabUnmappedForTesting(kTab2));
 
   // Now that it's been mapped, it should be accessible both via the
   // GetSession as well as the GetTab.
   ASSERT_EQ(GetTracker()->GetTab(kTag, kTab2),
-            session->windows[kWindow1]->tabs[0].get());
+            session->windows[kWindow1]->wrapped_window.tabs[0].get());
   ASSERT_EQ(session->tab_node_ids.size(),
             session->tab_node_ids.count(kTabNode));
   ASSERT_EQ(1U, GetTabNodePool()->Capacity());
 }
 
 TEST_F(SyncedSessionTrackerTest, ReassociateTabMappedTwice) {
   std::set<int> free_node_ids;
 
   // First create the tab normally.
   GetTracker()->SetLocalSessionTag(kTag);
   EXPECT_FALSE(GetTracker()->IsLocalTabNodeAssociated(kTabNode));
   GetTracker()->ReassociateLocalTab(kTabNode, kTab1);
   EXPECT_TRUE(GetTracker()->IsLocalTabNodeAssociated(kTabNode));
   EXPECT_TRUE(GetTracker()->IsTabUnmappedForTesting(kTab1));
 
   // Map it to a window with the same tab id as it was created with.
   GetTracker()->ResetSessionTracking(kTag);
   GetTracker()->PutWindowInSession(kTag, kWindow1);
   GetTracker()->PutTabInWindow(kTag, kWindow1, kTab1);
   GetTracker()->CleanupLocalTabs(&free_node_ids);
   EXPECT_TRUE(free_node_ids.empty());
   EXPECT_FALSE(GetTracker()->IsTabUnmappedForTesting(kTab1));
   SyncedSession* session = GetTracker()->GetSession(kTag);
   ASSERT_EQ(1U, session->windows.size());
-  ASSERT_EQ(1U, session->windows[kWindow1]->tabs.size());
+  ASSERT_EQ(1U, session->windows[kWindow1]->wrapped_window.tabs.size());
   EXPECT_EQ(GetTracker()->GetTab(kTag, kTab1),
-            session->windows[kWindow1]->tabs[0].get());
+            session->windows[kWindow1]->wrapped_window.tabs[0].get());
 
   // Then reassociate with a new tab id.
   GetTracker()->ReassociateLocalTab(kTabNode, kTab2);
   EXPECT_TRUE(GetTracker()->IsLocalTabNodeAssociated(kTabNode));
   EXPECT_FALSE(GetTracker()->IsTabUnmappedForTesting(kTab2));
   EXPECT_FALSE(GetTracker()->IsTabUnmappedForTesting(kTab1));
 
   // Tab 1 should no longer be associated with any SessionTab object. At this
   // point there's no need to verify it's unmapped state.
   const sessions::SessionTab* tab_ptr = nullptr;
   EXPECT_FALSE(GetTracker()->LookupSessionTab(kTag, kTab1, &tab_ptr));
 
   // Reset tracking and add back both the old tab and the new tab (both of which
   // refer to the same tab node id).
   GetTracker()->ResetSessionTracking(kTag);
   EXPECT_TRUE(GetTracker()->IsTabUnmappedForTesting(kTab2));
   GetTracker()->PutWindowInSession(kTag, kWindow1);
   GetTracker()->PutTabInWindow(kTag, kWindow1, kTab1);
   GetTracker()->PutTabInWindow(kTag, kWindow1, kTab2);
   GetTracker()->CleanupLocalTabs(&free_node_ids);
   EXPECT_TRUE(free_node_ids.empty());
   EXPECT_FALSE(GetTracker()->IsTabUnmappedForTesting(kTab2));
 
   // Now that it's been mapped, it should be accessible both via the
   // GetSession as well as the GetTab.
   EXPECT_EQ(GetTracker()->GetTab(kTag, kTab2),
-            session->windows[kWindow1]->tabs[1].get());
+            session->windows[kWindow1]->wrapped_window.tabs[1].get());
   EXPECT_EQ(session->tab_node_ids.size(),
             session->tab_node_ids.count(kTabNode));
   EXPECT_EQ(1U, GetTabNodePool()->Capacity());
 
   // Attempting to access the original tab will create a new SessionTab object.
   EXPECT_NE(GetTracker()->GetTab(kTag, kTab1),
             GetTracker()->GetTab(kTag, kTab2));
   int tab_node_id = -1;
   EXPECT_FALSE(GetTracker()->GetTabNodeFromLocalTabId(kTab1, &tab_node_id));
 }
@@ skipping 17 matching lines @@
   GetTracker()->PutWindowInSession(kTag, kWindow1);
   GetTracker()->PutTabInWindow(kTag, kWindow1, kTab2);
   GetTracker()->CleanupLocalTabs(&free_node_ids);
   EXPECT_TRUE(free_node_ids.empty());
   EXPECT_FALSE(GetTracker()->IsTabUnmappedForTesting(kTab2));
 
   // Now that it's been mapped, it should be accessible both via the
   // GetSession as well as GetTab.
   SyncedSession* session = GetTracker()->GetSession(kTag);
   ASSERT_EQ(GetTracker()->GetTab(kTag, kTab2),
-            session->windows[kWindow1]->tabs[0].get());
+            session->windows[kWindow1]->wrapped_window.tabs[0].get());
   ASSERT_EQ(session->tab_node_ids.size(),
             session->tab_node_ids.count(kTabNode));
   ASSERT_EQ(1U, GetTabNodePool()->Capacity());
 }
 
 }  // namespace sync_sessions