[Sync] Introduce SyncedSessionWindow type.

components/sync_sessions/sessions_sync_manager_unittest.cc

 // Copyright 2014 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/sessions_sync_manager.h"
 
 #include <stdint.h>
 
 #include <utility>
 
@@ skipping 745 matching lines @@
 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);
 
   SyncedSession* session = manager()->session_tracker_.GetSession(kTag1);
   manager()->session_tracker_.PutWindowInSession(kTag1, 0);
   manager()->BuildSyncedSessionFromSpecifics(kTag1, window_s, base::Time(),
                                              session->windows[0].get());
-  ASSERT_EQ(1U, session->windows[0]->tabs.size());
-  ASSERT_EQ(1, session->windows[0]->selected_tab_index);
-  ASSERT_EQ(sessions::SessionWindow::TYPE_TABBED, session->windows[0]->type);
+  ASSERT_EQ(1U, session->windows[0]->wrapped_window.tabs.size());
+  ASSERT_EQ(1, session->windows[0]->wrapped_window.selected_tab_index);
+  ASSERT_EQ(sessions::SessionWindow::TYPE_TABBED,
+            session->windows[0]->wrapped_window.type);
   ASSERT_EQ(1U, manager()->session_tracker_.num_synced_sessions());
   ASSERT_EQ(1U, manager()->session_tracker_.num_synced_tabs(kTag1));
 }
 
 // Populate the fake tab delegate with some data and navigation
 // entries and make sure that setting a SessionTab from it preserves
 // those entries (and clobbers any existing data).
 TEST_F(SessionsSyncManagerTest, SetSessionTabFromDelegate) {
   // Create a tab with three valid entries.
   TestSyncedTabDelegate* tab =
@@ skipping 334 matching lines @@
   SyncChangeList changes;
   changes.push_back(MakeRemoteChange(meta1, SyncChange::ACTION_UPDATE));
   AddTabsToChangeList(tabs2, SyncChange::ACTION_ADD, &changes);
   manager()->ProcessSyncChanges(FROM_HERE, changes);
   changes.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(1U, foreign_sessions.size());
-  ASSERT_EQ(4U, foreign_sessions[0]->windows.find(0)->second->tabs.size());
-  ASSERT_EQ(4U, foreign_sessions[0]->windows.find(1)->second->tabs.size());
+  ASSERT_EQ(
+      4U,
+      foreign_sessions[0]->windows.find(0)->second->wrapped_window.tabs.size());
+  ASSERT_EQ(
+      4U,
+      foreign_sessions[0]->windows.find(1)->second->wrapped_window.tabs.size());
   helper()->VerifySyncedSession(kTag1, meta1_reference, *(foreign_sessions[0]));
 
   // Add a new foreign session.
   std::vector<SessionID::id_type> tag2_tab_list = {107, 115};
   std::vector<sync_pb::SessionSpecifics> tag2_tabs;
   sync_pb::SessionSpecifics meta2(
       helper()->BuildForeignSession(kTag2, tag2_tab_list, &tag2_tabs));
   changes.push_back(MakeRemoteChange(meta2, SyncChange::ACTION_ADD));
   AddTabsToChangeList(tag2_tabs, SyncChange::ACTION_ADD, &changes);
 
   manager()->ProcessSyncChanges(FROM_HERE, changes);
   changes.clear();
 
   ASSERT_TRUE(manager()->GetAllForeignSessions(&foreign_sessions));
   std::vector<std::vector<SessionID::id_type>> meta2_reference;
   meta2_reference.push_back(tag2_tab_list);
   ASSERT_EQ(2U, foreign_sessions.size());
-  ASSERT_EQ(2U, foreign_sessions[1]->windows.find(0)->second->tabs.size());
+  ASSERT_EQ(
+      2U,
+      foreign_sessions[1]->windows.find(0)->second->wrapped_window.tabs.size());
   helper()->VerifySyncedSession(kTag2, meta2_reference, *(foreign_sessions[1]));
   foreign_sessions.clear();
 
   // Remove a tab from a window.
   meta1_reference[0].pop_back();
   tab_list1.pop_back();
   sync_pb::SessionWindow* win = meta1.mutable_header()->mutable_window(0);
   win->clear_tab();
   for (std::vector<int>::const_iterator iter = tab_list1.begin();
        iter != tab_list1.end(); ++iter) {
     win->add_tab(*iter);
   }
   SyncChangeList removal;
   removal.push_back(MakeRemoteChange(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());
+  ASSERT_EQ(
+      3U,
+      foreign_sessions[0]->windows.find(0)->second->wrapped_window.tabs.size());
   helper()->VerifySyncedSession(kTag1, meta1_reference, *(foreign_sessions[0]));
 }
 
 // Tests that this SyncSessionManager knows how to delete foreign sessions
 // if it wants to.
 TEST_F(SessionsSyncManagerTest, DeleteForeignSession) {
   InitWithNoSyncData();
   SyncChangeList changes;
 
   std::vector<const SyncedSession*> foreign_sessions;
@@ skipping 92 matching lines @@
   AddTabsToChangeList(tabs1, SyncChange::ACTION_ADD, &changes);
   AddTabsToChangeList(tabs2, SyncChange::ACTION_ADD, &changes);
   manager()->ProcessSyncChanges(FROM_HERE, changes);
   changes.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(1U, foreign_sessions.size());
   ASSERT_EQ(2U, foreign_sessions[0]->windows.size());
-  ASSERT_EQ(4U, foreign_sessions[0]->windows.find(0)->second->tabs.size());
-  ASSERT_EQ(4U, foreign_sessions[0]->windows.find(1)->second->tabs.size());
+  ASSERT_EQ(
+      4U,
+      foreign_sessions[0]->windows.find(0)->second->wrapped_window.tabs.size());
+  ASSERT_EQ(
+      4U,
+      foreign_sessions[0]->windows.find(1)->second->wrapped_window.tabs.size());
 
   // Close the second window.
   meta.mutable_header()->clear_window();
   helper()->AddWindowSpecifics(0, tab_list1, &meta);
   changes.push_back(MakeRemoteChange(meta, SyncChange::ACTION_UPDATE));
   // Update associator with the session's meta node containing one window.
   manager()->ProcessSyncChanges(FROM_HERE, changes);
 
   // Check that the foreign session was associated and retrieve the data.
   foreign_sessions.clear();
@@ skipping 847 matching lines @@
   initial_data.push_back(
       CreateRemoteData(entity, base::Time::FromDoubleT(3000)));
 
   SyncChangeList output;
   InitWithSyncDataTakeOutput(initial_data, &output);
 
   std::vector<const SyncedSession*> foreign_sessions;
   ASSERT_TRUE(manager()->GetAllForeignSessions(&foreign_sessions));
 
   const std::vector<std::unique_ptr<sessions::SessionTab>>& window_tabs =
-      foreign_sessions[0]->windows.find(0)->second->tabs;
+      foreign_sessions[0]->windows.find(0)->second->wrapped_window.tabs;
   ASSERT_EQ(4U, window_tabs.size());
   // The first one is from the original set of tabs.
   ASSERT_EQ(1, window_tabs[0]->tab_visual_index);
   // The one from the original set of tabs wins over duplicating_tab1.
   ASSERT_EQ(1, window_tabs[1]->tab_visual_index);
   // duplicating_tab2 wins due to the later timestamp.
   ASSERT_EQ(3, window_tabs[2]->tab_visual_index);
 }
 
 // Verify that GetAllForeignSessions returns all sessions sorted by recency.
@@ skipping 241 matching lines @@
   // Because tab 2 is a placeholder, tab 1's URL will be preserved.
   VerifyLocalTabChange(out[1], 1, kFoo1);
   EXPECT_EQ(sync_id, out[1].sync_data().GetSpecifics().session().tab_node_id());
   EXPECT_EQ(tab2.GetSessionId(),
             out[1].sync_data().GetSpecifics().session().tab().tab_id());
   EXPECT_EQ(window2->GetSessionId(),
             out[1].sync_data().GetSpecifics().session().tab().window_id());
 }
 
 }  // namespace sync_sessions