BASELINE: Update Chromium to 59.0.3071.134

Change-Id: Id02ef6fb2204c5fd21668a1c3e6911c83b17585a
Reviewed-by: Alexandru Croitor <alexandru.croitor@qt.io>

19 files changed, 182 insertions, 150 deletions

diff --git a/chromium/components/sync_sessions/fake_sync_sessions_client.cc b/chromium/components/sync_sessions/fake_sync_sessions_client.cc
index 9bdc8213a55..3ef4ae03835 100644
--- a/chromium/components/sync_sessions/fake_sync_sessions_client.cc
+++ b/chromium/components/sync_sessions/fake_sync_sessions_client.cc
@@ -33,8 +33,7 @@ FakeSyncSessionsClient::GetSyncedWindowDelegatesGetter() {
   return nullptr;
 }
 
-std::unique_ptr<LocalSessionEventRouter>
-FakeSyncSessionsClient::GetLocalSessionEventRouter() {
+LocalSessionEventRouter* FakeSyncSessionsClient::GetLocalSessionEventRouter() {
   return nullptr;
 }
 
diff --git a/chromium/components/sync_sessions/fake_sync_sessions_client.h b/chromium/components/sync_sessions/fake_sync_sessions_client.h
index 7b17f3a1d88..acffdce1f3a 100644
--- a/chromium/components/sync_sessions/fake_sync_sessions_client.h
+++ b/chromium/components/sync_sessions/fake_sync_sessions_client.h
@@ -24,8 +24,7 @@ class FakeSyncSessionsClient : public SyncSessionsClient {
   history::HistoryService* GetHistoryService() override;
   bool ShouldSyncURL(const GURL& url) const override;
   SyncedWindowDelegatesGetter* GetSyncedWindowDelegatesGetter() override;
-  std::unique_ptr<LocalSessionEventRouter> GetLocalSessionEventRouter()
-      override;
+  LocalSessionEventRouter* GetLocalSessionEventRouter() override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FakeSyncSessionsClient);
diff --git a/chromium/components/sync_sessions/revisit/sessions_page_revisit_observer.cc b/chromium/components/sync_sessions/revisit/sessions_page_revisit_observer.cc
index ccb603aa25e..1a99c70a7dd 100644
--- a/chromium/components/sync_sessions/revisit/sessions_page_revisit_observer.cc
+++ b/chromium/components/sync_sessions/revisit/sessions_page_revisit_observer.cc
@@ -57,7 +57,7 @@ void SessionsPageRevisitObserver::CheckForRevisit(
   if (provider_->GetAllForeignSessions(&foreign_sessions)) {
     for (const SyncedSession* session : foreign_sessions) {
       for (const auto& key_value : session->windows) {
-        for (const auto& tab : key_value.second->tabs) {
+        for (const auto& tab : key_value.second->wrapped_window.tabs) {
           // These matchers look identical and could easily implement an
           // interface and we could iterate through a vector of matchers here.
           // However this would cause quite a bit of overhead at the inner most
diff --git a/chromium/components/sync_sessions/revisit/sessions_page_revisit_observer_unittest.cc b/chromium/components/sync_sessions/revisit/sessions_page_revisit_observer_unittest.cc
index e7b3181d3d3..b86549eba22 100644
--- a/chromium/components/sync_sessions/revisit/sessions_page_revisit_observer_unittest.cc
+++ b/chromium/components/sync_sessions/revisit/sessions_page_revisit_observer_unittest.cc
@@ -87,39 +87,39 @@ TEST_F(SessionsPageRevisitObserverTest, RunMatchersNoSessions) {
 }
 
 TEST_F(SessionsPageRevisitObserverTest, RunMatchersNoWindows) {
-  std::unique_ptr<SyncedSession> session = base::MakeUnique<SyncedSession>();
+  auto session = base::MakeUnique<SyncedSession>();
   CheckAndExpect(session.get(), GURL(kExampleUrl), false, false);
 }
 
 TEST_F(SessionsPageRevisitObserverTest, RunMatchersNoTabs) {
-  std::unique_ptr<SyncedSession> session = base::MakeUnique<SyncedSession>();
-  session->windows[0] = base::MakeUnique<SessionWindow>();
+  auto session = base::MakeUnique<SyncedSession>();
+  session->windows[0] = base::MakeUnique<SyncedSessionWindow>();
   CheckAndExpect(session.get(), GURL(kExampleUrl), false, false);
 }
 
 TEST_F(SessionsPageRevisitObserverTest, RunMatchersNoEntries) {
-  std::unique_ptr<SessionWindow> window = base::MakeUnique<SessionWindow>();
-  window->tabs.push_back(base::MakeUnique<SessionTab>());
-  std::unique_ptr<SyncedSession> session = base::MakeUnique<SyncedSession>();
+  auto window = base::MakeUnique<SyncedSessionWindow>();
+  window->wrapped_window.tabs.push_back(base::MakeUnique<SessionTab>());
+  auto session = base::MakeUnique<SyncedSession>();
   session->windows[0] = std::move(window);
   CheckAndExpect(session.get(), GURL(kExampleUrl), false, false);
 }
 
 TEST_F(SessionsPageRevisitObserverTest, RunMatchersSingle) {
-  std::unique_ptr<SessionTab> tab = base::MakeUnique<SessionTab>();
+  auto tab = base::MakeUnique<SessionTab>();
   tab->navigations.push_back(
       sessions::SerializedNavigationEntryTestHelper::CreateNavigation(
           kExampleUrl, ""));
   tab->current_navigation_index = 0;
-  std::unique_ptr<SessionWindow> window = base::MakeUnique<SessionWindow>();
-  window->tabs.push_back(std::move(tab));
-  std::unique_ptr<SyncedSession> session = base::MakeUnique<SyncedSession>();
+  auto window = base::MakeUnique<SyncedSessionWindow>();
+  window->wrapped_window.tabs.push_back(std::move(tab));
+  auto session = base::MakeUnique<SyncedSession>();
   session->windows[0] = std::move(window);
   CheckAndExpect(session.get(), GURL(kExampleUrl), true, false);
 }
 
 TEST_F(SessionsPageRevisitObserverTest, RunMatchersFalseProvider) {
-  std::unique_ptr<SessionTab> tab = base::MakeUnique<SessionTab>();
+  auto tab = base::MakeUnique<SessionTab>();
   tab->navigations.push_back(
       sessions::SerializedNavigationEntryTestHelper::CreateNavigation(
           kExampleUrl, ""));
@@ -127,9 +127,9 @@ TEST_F(SessionsPageRevisitObserverTest, RunMatchersFalseProvider) {
       sessions::SerializedNavigationEntryTestHelper::CreateNavigation(
           kExampleUrl, ""));
   tab->current_navigation_index = 1;
-  std::unique_ptr<SessionWindow> window = base::MakeUnique<SessionWindow>();
-  window->tabs.push_back(std::move(tab));
-  std::unique_ptr<SyncedSession> session = base::MakeUnique<SyncedSession>();
+  auto window = base::MakeUnique<SyncedSessionWindow>();
+  window->wrapped_window.tabs.push_back(std::move(tab));
+  auto session = base::MakeUnique<SyncedSession>();
   session->windows[0] = std::move(window);
 
   // The provider returns false when asked for foreign sessions, even though
@@ -142,25 +142,25 @@ TEST_F(SessionsPageRevisitObserverTest, RunMatchersFalseProvider) {
 }
 
 TEST_F(SessionsPageRevisitObserverTest, RunMatchersMany) {
-  std::unique_ptr<SessionTab> tab1 = base::MakeUnique<SessionTab>();
+  auto tab1 = base::MakeUnique<SessionTab>();
   tab1->navigations.push_back(
       sessions::SerializedNavigationEntryTestHelper::CreateNavigation(
           kExampleUrl, ""));
   tab1->current_navigation_index = 0;
 
-  std::unique_ptr<SessionTab> tab2 = base::MakeUnique<SessionTab>();
+  auto tab2 = base::MakeUnique<SessionTab>();
   tab2->navigations.push_back(
       sessions::SerializedNavigationEntryTestHelper::CreateNavigation(
           kDifferentUrl, ""));
   tab2->current_navigation_index = 0;
 
-  std::unique_ptr<SessionTab> tab3 = base::MakeUnique<SessionTab>();
+  auto tab3 = base::MakeUnique<SessionTab>();
   tab3->navigations.push_back(
       sessions::SerializedNavigationEntryTestHelper::CreateNavigation(
           kDifferentUrl, ""));
   tab3->current_navigation_index = 0;
 
-  std::unique_ptr<SessionTab> tab4 = base::MakeUnique<SessionTab>();
+  auto tab4 = base::MakeUnique<SessionTab>();
   tab4->navigations.push_back(
       sessions::SerializedNavigationEntryTestHelper::CreateNavigation(
           kExampleUrl, ""));
@@ -169,17 +169,17 @@ TEST_F(SessionsPageRevisitObserverTest, RunMatchersMany) {
           kDifferentUrl, ""));
   tab4->current_navigation_index = 1;
 
-  std::unique_ptr<SessionWindow> window1 = base::MakeUnique<SessionWindow>();
-  window1->tabs.push_back(std::move(tab1));
-  std::unique_ptr<SessionWindow> window2 = base::MakeUnique<SessionWindow>();
-  window2->tabs.push_back(std::move(tab2));
-  std::unique_ptr<SessionWindow> window3 = base::MakeUnique<SessionWindow>();
-  window3->tabs.push_back(std::move(tab3));
-  window3->tabs.push_back(std::move(tab4));
+  auto window1 = base::MakeUnique<SyncedSessionWindow>();
+  window1->wrapped_window.tabs.push_back(std::move(tab1));
+  auto window2 = base::MakeUnique<SyncedSessionWindow>();
+  window2->wrapped_window.tabs.push_back(std::move(tab2));
+  auto window3 = base::MakeUnique<SyncedSessionWindow>();
+  window3->wrapped_window.tabs.push_back(std::move(tab3));
+  window3->wrapped_window.tabs.push_back(std::move(tab4));
 
-  std::unique_ptr<SyncedSession> session1 = base::MakeUnique<SyncedSession>();
+  auto session1 = base::MakeUnique<SyncedSession>();
   session1->windows[1] = std::move(window1);
-  std::unique_ptr<SyncedSession> session2 = base::MakeUnique<SyncedSession>();
+  auto session2 = base::MakeUnique<SyncedSession>();
   session2->windows[2] = std::move(window2);
   session2->windows[3] = std::move(window3);
 
diff --git a/chromium/components/sync_sessions/session_sync_test_helper.cc b/chromium/components/sync_sessions/session_sync_test_helper.cc
index ac5b699d988..90076fd542e 100644
--- a/chromium/components/sync_sessions/session_sync_test_helper.cc
+++ b/chromium/components/sync_sessions/session_sync_test_helper.cc
@@ -62,7 +62,7 @@ void SessionSyncTestHelper::VerifySyncedSession(
     sessions::SessionWindow* win_ptr;
     auto map_iter = session.windows.find(i);
     if (map_iter != session.windows.end())
-      win_ptr = map_iter->second.get();
+      win_ptr = &map_iter->second->wrapped_window;
     else
       FAIL();
     ASSERT_EQ(win_iter->size(), win_ptr->tabs.size());
diff --git a/chromium/components/sync_sessions/sessions_sync_manager.cc b/chromium/components/sync_sessions/sessions_sync_manager.cc
index d61d75591b9..665929fcd4e 100644
--- a/chromium/components/sync_sessions/sessions_sync_manager.cc
+++ b/chromium/components/sync_sessions/sessions_sync_manager.cc
@@ -25,7 +25,6 @@
 #include "components/sync_sessions/synced_window_delegate.h"
 #include "components/sync_sessions/synced_window_delegates_getter.h"
 #include "components/sync_sessions/tab_node_pool.h"
-#include "components/variations/variations_associated_data.h"
 
 using sessions::SerializedNavigationEntry;
 using syncer::DeviceInfo;
@@ -106,7 +105,7 @@ void AppendDeletionsForTabNodes(const std::set<int>& tab_node_ids,
 
 // Ensure that the tab id is not invalid.
 bool ShouldSyncTabId(SessionID::id_type tab_id) {
-  if (tab_id == TabNodePool::kInvalidTabID)
+  if (tab_id == kInvalidTabID)
     return false;
   return true;
 }
@@ -119,7 +118,7 @@ SessionsSyncManager::SessionsSyncManager(
     sync_sessions::SyncSessionsClient* sessions_client,
     syncer::SyncPrefs* sync_prefs,
     LocalDeviceInfoProvider* local_device,
-    std::unique_ptr<LocalSessionEventRouter> router,
+    LocalSessionEventRouter* router,
     const base::Closure& sessions_updated_callback,
     const base::Closure& datatype_refresh_callback)
     : sessions_client_(sessions_client),
@@ -391,7 +390,6 @@ void SessionsSyncManager::AssociateTab(SyncedTabDelegate* const tab_delegate,
 
   // Update the tracker's session representation.
   SetSessionTabFromDelegate(*tab_delegate, base::Time::Now(), session_tab);
-  SetVariationIds(session_tab);
   session_tracker_.GetSession(current_machine_tag())->modified_time =
       base::Time::Now();
 
@@ -512,13 +510,13 @@ syncer::SyncDataList SessionsSyncManager::GetAllSyncData(
   header_entity.mutable_session()->set_session_tag(current_machine_tag());
   sync_pb::SessionHeader* header_specifics =
       header_entity.mutable_session()->mutable_header();
-  header_specifics->MergeFrom(session->ToSessionHeader());
+  header_specifics->MergeFrom(session->ToSessionHeaderProto());
   syncer::SyncData data = syncer::SyncData::CreateLocalData(
       current_machine_tag(), current_session_name_, header_entity);
   list.push_back(data);
 
   for (auto& win_iter : session->windows) {
-    for (auto& tab : win_iter.second->tabs) {
+    for (auto& tab : win_iter.second->wrapped_window.tabs) {
       // TODO(zea): replace with with the correct tab node id once there's a
       // sync specific wrapper for SessionTab. This method is only used in
       // tests though, so it's fine for now. crbug.com/662597
@@ -681,7 +679,7 @@ bool SessionsSyncManager::InitFromSyncModel(
           syncer::SyncChange tombstone(TombstoneTab(specifics));
           if (tombstone.IsValid())
             new_changes->push_back(tombstone);
-        } else if (specifics.tab().tab_id() == TabNodePool::kInvalidTabID) {
+        } else if (specifics.tab().tab_id() == kInvalidTabID) {
           LOG(WARNING) << "Found tab node with invalid tab id.";
           syncer::SyncChange tombstone(TombstoneTab(specifics));
           if (tombstone.IsValid())
@@ -867,14 +865,15 @@ void SessionsSyncManager::BuildSyncedSessionFromSpecifics(
     const std::string& session_tag,
     const sync_pb::SessionWindow& specifics,
     base::Time mtime,
-    sessions::SessionWindow* session_window) {
+    SyncedSessionWindow* synced_session_window) {
+  sessions::SessionWindow* session_window =
+      &synced_session_window->wrapped_window;
   if (specifics.has_window_id())
     session_window->window_id.set_id(specifics.window_id());
   if (specifics.has_selected_tab_index())
     session_window->selected_tab_index = specifics.selected_tab_index();
+  synced_session_window->window_type = specifics.browser_type();
   if (specifics.has_browser_type()) {
-    // TODO(skuhne): Sync data writes |BrowserType| not
-    // |SessionWindow::WindowType|. This should get changed.
     if (specifics.browser_type() ==
         sync_pb::SessionWindow_BrowserType_TYPE_TABBED) {
       session_window->type = sessions::SessionWindow::TYPE_TABBED;
@@ -1093,18 +1092,6 @@ void SessionsSyncManager::SetSessionTabFromDelegate(
   session_tab->session_storage_persistent_id.clear();
 }
 
-// static
-void SessionsSyncManager::SetVariationIds(sessions::SessionTab* session_tab) {
-  base::FieldTrial::ActiveGroups active_groups;
-  base::FieldTrialList::GetActiveFieldTrialGroups(&active_groups);
-  for (const base::FieldTrial::ActiveGroup& group : active_groups) {
-    const variations::VariationID id = variations::GetGoogleVariationID(
-        variations::CHROME_SYNC_SERVICE, group.trial_name, group.group_name);
-    if (id != variations::EMPTY_ID)
-      session_tab->variation_ids.push_back(id);
-  }
-}
-
 FaviconCache* SessionsSyncManager::GetFaviconCache() {
   return &favicon_cache_;
 }
diff --git a/chromium/components/sync_sessions/sessions_sync_manager.h b/chromium/components/sync_sessions/sessions_sync_manager.h
index d685c65cd42..bf72e9e716e 100644
--- a/chromium/components/sync_sessions/sessions_sync_manager.h
+++ b/chromium/components/sync_sessions/sessions_sync_manager.h
@@ -62,7 +62,7 @@ class SessionsSyncManager : public syncer::SyncableService,
   SessionsSyncManager(SyncSessionsClient* sessions_client,
                       syncer::SyncPrefs* sync_prefs,
                       syncer::LocalDeviceInfoProvider* local_device,
-                      std::unique_ptr<LocalSessionEventRouter> router,
+                      LocalSessionEventRouter* router,
                       const base::Closure& sessions_updated_callback,
                       const base::Closure& datatype_refresh_callback);
   ~SessionsSyncManager() override;
@@ -146,7 +146,6 @@ class SessionsSyncManager : public syncer::SyncableService,
   FRIEND_TEST_ALL_PREFIXES(SessionsSyncManagerTest, SwappedOutOnRestore);
   FRIEND_TEST_ALL_PREFIXES(SessionsSyncManagerTest,
                            ProcessRemoteDeleteOfLocalSession);
-  FRIEND_TEST_ALL_PREFIXES(SessionsSyncManagerTest, SetVariationIds);
 
   void InitializeCurrentMachineTag(const std::string& cache_guid);
 
@@ -195,10 +194,11 @@ class SessionsSyncManager : public syncer::SyncableService,
 
   // Builds |session_window| from the session specifics window
   // provided and updates the SessionTracker with foreign session data created.
-  void BuildSyncedSessionFromSpecifics(const std::string& session_tag,
-                                       const sync_pb::SessionWindow& specifics,
-                                       base::Time mtime,
-                                       sessions::SessionWindow* session_window);
+  void BuildSyncedSessionFromSpecifics(
+      const std::string& session_tag,
+      const sync_pb::SessionWindow& specifics,
+      base::Time mtime,
+      SyncedSessionWindow* synced_session_window);
 
   // Resync local window information. Updates the local sessions header node
   // with the status of open windows and the order of tabs they contain. Should
@@ -230,10 +230,6 @@ class SessionsSyncManager : public syncer::SyncableService,
                                  base::Time mtime,
                                  sessions::SessionTab* session_tab);
 
-  // Sets |variation_ids| field of |session_tab| with the ids of the currently
-  // assigned variations which should be sent to sync.
-  static void SetVariationIds(sessions::SessionTab* session_tab);
-
   // Populates |specifics| based on the data in |tab_delegate|.
   void LocalTabDelegateToSpecifics(const SyncedTabDelegate& tab_delegate,
                                    sync_pb::SessionSpecifics* specifics);
@@ -309,7 +305,7 @@ class SessionsSyncManager : public syncer::SyncableService,
   // stale and a candidate for garbage collection.
   int stale_session_threshold_days_;
 
-  std::unique_ptr<LocalSessionEventRouter> local_event_router_;
+  LocalSessionEventRouter* local_event_router_;
 
   // Owns revisiting instrumentation logic for page visit events.
   PageRevisitBroadcaster page_revisit_broadcaster_;
diff --git a/chromium/components/sync_sessions/sessions_sync_manager_unittest.cc b/chromium/components/sync_sessions/sessions_sync_manager_unittest.cc
index ab5cbfde94d..7479a1833c5 100644
--- a/chromium/components/sync_sessions/sessions_sync_manager_unittest.cc
+++ b/chromium/components/sync_sessions/sessions_sync_manager_unittest.cc
@@ -211,6 +211,8 @@ class TestSyncedTabDelegate : public SyncedTabDelegate {
     return http_count > 0;
   }
 
+  SessionID::id_type GetSourceTabID() const override { return kInvalidTabID; }
+
   void AppendEntry(std::unique_ptr<sessions::SerializedNavigationEntry> entry) {
     entries_.push_back(std::move(entry));
   }
@@ -322,6 +324,8 @@ class PlaceholderTabDelegate : public SyncedTabDelegate {
     return false;
   }
 
+  SessionID::id_type GetSourceTabID() const override { return kInvalidTabID; }
+
  private:
   SessionID::id_type session_id_;
   int sync_id_;
@@ -370,7 +374,7 @@ class TestSyncedWindowDelegate : public SyncedWindowDelegate {
   SessionID::id_type GetTabIdAt(int index) const override {
     SyncedTabDelegate* delegate = GetTabAt(index);
     if (!delegate)
-      return TabNodePool::kInvalidTabID;
+      return kInvalidTabID;
     return delegate->GetSessionId();
   }
 
@@ -512,9 +516,10 @@ class SessionsSyncManagerTest : public testing::Test {
         base::MakeUnique<SyncSessionsClientShim>(&window_getter_);
     sync_prefs_ =
         base::MakeUnique<syncer::SyncPrefs>(sync_client_->GetPrefService());
+    router_ = base::MakeUnique<DummyRouter>();
     manager_ = base::MakeUnique<SessionsSyncManager>(
         sessions_client_shim(), sync_prefs_.get(), local_device_.get(),
-        std::unique_ptr<LocalSessionEventRouter>(NewDummyRouter()),
+        router_.get(),
         base::Bind(&SessionNotificationObserver::NotifyOfUpdate,
                    base::Unretained(&observer_)),
         base::Bind(&SessionNotificationObserver::NotifyOfRefresh,
@@ -546,12 +551,6 @@ class SessionsSyncManagerTest : public testing::Test {
   }
   SyncedWindowDelegatesGetter* window_getter() { return &window_getter_; }
 
-  std::unique_ptr<LocalSessionEventRouter> NewDummyRouter() {
-    std::unique_ptr<DummyRouter> router(new DummyRouter());
-    router_ = router.get();
-    return std::unique_ptr<LocalSessionEventRouter>(std::move(router));
-  }
-
   void InitWithSyncDataTakeOutput(const SyncDataList& initial_data,
                                   SyncChangeList* output) {
     test_processor_ = new TestSyncChangeProcessor(output);
@@ -728,7 +727,7 @@ class SessionsSyncManagerTest : public testing::Test {
   std::unique_ptr<SyncSessionsClientShim> sessions_client_shim_;
   std::unique_ptr<syncer::SyncPrefs> sync_prefs_;
   SessionNotificationObserver observer_;
-  DummyRouter* router_ = nullptr;
+  std::unique_ptr<DummyRouter> router_;
   std::unique_ptr<SessionsSyncManager> manager_;
   SessionSyncTestHelper helper_;
   TestSyncChangeProcessor* test_processor_ = nullptr;
@@ -764,9 +763,10 @@ TEST_F(SessionsSyncManagerTest, PopulateSessionWindow) {
   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));
 }
@@ -1121,8 +1121,12 @@ TEST_F(SessionsSyncManagerTest, UpdatesAfterMixedMerge) {
   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.
@@ -1140,7 +1144,9 @@ TEST_F(SessionsSyncManagerTest, UpdatesAfterMixedMerge) {
   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();
 
@@ -1160,7 +1166,9 @@ TEST_F(SessionsSyncManagerTest, UpdatesAfterMixedMerge) {
 
   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]));
 }
 
@@ -1273,8 +1281,12 @@ TEST_F(SessionsSyncManagerTest, WriteForeignSessionToNodeMissingTabs) {
   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();
@@ -2142,7 +2154,7 @@ TEST_F(SessionsSyncManagerTest, ReceiveDuplicateUnassociatedTabs) {
   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);
diff --git a/chromium/components/sync_sessions/sync_sessions_client.h b/chromium/components/sync_sessions/sync_sessions_client.h
index fab928ffeff..e8b4874a784 100644
--- a/chromium/components/sync_sessions/sync_sessions_client.h
+++ b/chromium/components/sync_sessions/sync_sessions_client.h
@@ -52,8 +52,7 @@ class SyncSessionsClient {
 
   // Returns a LocalSessionEventRouter instance that is customized for the
   // embedder's context.
-  virtual std::unique_ptr<LocalSessionEventRouter>
-  GetLocalSessionEventRouter() = 0;
+  virtual LocalSessionEventRouter* GetLocalSessionEventRouter() = 0;
 
   // TODO(zea): add getters for the history and favicon services for the favicon
   // cache to consume once it's componentized.
diff --git a/chromium/components/sync_sessions/sync_sessions_metrics.cc b/chromium/components/sync_sessions/sync_sessions_metrics.cc
index 1242b095e32..b5cf37e3473 100644
--- a/chromium/components/sync_sessions/sync_sessions_metrics.cc
+++ b/chromium/components/sync_sessions/sync_sessions_metrics.cc
@@ -9,7 +9,6 @@
 
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
-#include "base/metrics/user_metrics.h"
 #include "base/time/time.h"
 #include "components/sessions/core/session_types.h"
 #include "components/sync_sessions/sessions_sync_manager.h"
@@ -51,7 +50,7 @@ base::Time SyncSessionsMetrics::MaxTabTimestamp(
       break;
     }
     for (const auto& key_value : session->windows) {
-      for (const auto& tab : key_value.second->tabs) {
+      for (const auto& tab : key_value.second->wrapped_window.tabs) {
         best = std::max(best, tab->timestamp);
       }
     }
diff --git a/chromium/components/sync_sessions/sync_sessions_metrics_unittest.cc b/chromium/components/sync_sessions/sync_sessions_metrics_unittest.cc
index f351d3de168..987e0a52c79 100644
--- a/chromium/components/sync_sessions/sync_sessions_metrics_unittest.cc
+++ b/chromium/components/sync_sessions/sync_sessions_metrics_unittest.cc
@@ -70,17 +70,21 @@ class SyncSessionsMetricsTest : public ::testing::Test {
     if (sessions_[tabIndex]->windows.find(windowIndex) ==
         sessions_[tabIndex]->windows.end()) {
       sessions_[tabIndex]->windows[windowIndex] =
-          base::MakeUnique<SessionWindow>();
+          base::MakeUnique<SyncedSessionWindow>();
     }
 
     sessions_[tabIndex]->modified_time =
         std::max(sessions_[tabIndex]->modified_time, timestamp);
-    sessions_[tabIndex]->windows[windowIndex]->timestamp = std::max(
-        sessions_[tabIndex]->windows[windowIndex]->timestamp, timestamp);
-    sessions_[tabIndex]->windows[windowIndex]->tabs.push_back(
+    sessions_[tabIndex]->windows[windowIndex]->wrapped_window.timestamp =
+        std::max(
+            sessions_[tabIndex]->windows[windowIndex]->wrapped_window.timestamp,
+            timestamp);
+    sessions_[tabIndex]->windows[windowIndex]->wrapped_window.tabs.push_back(
         base::MakeUnique<SessionTab>());
-    sessions_[tabIndex]->windows[windowIndex]->tabs.back()->timestamp =
-        timestamp;
+    sessions_[tabIndex]
+        ->windows[windowIndex]
+        ->wrapped_window.tabs.back()
+        ->timestamp = timestamp;
   }
 
   // Removes the last tab at the given indexes. The idexes provided should be
@@ -89,9 +93,11 @@ class SyncSessionsMetricsTest : public ::testing::Test {
   void PopTab(size_t tabIndex, int windowIndex, Time timestamp) {
     sessions_[tabIndex]->modified_time =
         std::max(sessions_[tabIndex]->modified_time, timestamp);
-    sessions_[tabIndex]->windows[windowIndex]->timestamp = std::max(
-        sessions_[tabIndex]->windows[windowIndex]->timestamp, timestamp);
-    sessions_[tabIndex]->windows[windowIndex]->tabs.pop_back();
+    sessions_[tabIndex]->windows[windowIndex]->wrapped_window.timestamp =
+        std::max(
+            sessions_[tabIndex]->windows[windowIndex]->wrapped_window.timestamp,
+            timestamp);
+    sessions_[tabIndex]->windows[windowIndex]->wrapped_window.tabs.pop_back();
   }
 
   // Runs MaxTabTimestamp on the current sessions data.
diff --git a/chromium/components/sync_sessions/synced_session.cc b/chromium/components/sync_sessions/synced_session.cc
index c22e1728d20..0cba248c8f6 100644
--- a/chromium/components/sync_sessions/synced_session.cc
+++ b/chromium/components/sync_sessions/synced_session.cc
@@ -6,16 +6,32 @@
 
 namespace sync_sessions {
 
+SyncedSessionWindow::SyncedSessionWindow() {}
+
+SyncedSessionWindow::~SyncedSessionWindow() {}
+
+sync_pb::SessionWindow SyncedSessionWindow::ToSessionWindowProto() const {
+  sync_pb::SessionWindow sync_data;
+  sync_data.set_browser_type(window_type);
+  sync_data.set_window_id(wrapped_window.window_id.id());
+  sync_data.set_selected_tab_index(wrapped_window.selected_tab_index);
+
+  for (const auto& tab : wrapped_window.tabs)
+    sync_data.add_tab(tab->tab_id.id());
+
+  return sync_data;
+}
+
 SyncedSession::SyncedSession()
     : session_tag("invalid"), device_type(TYPE_UNSET) {}
 
 SyncedSession::~SyncedSession() {}
 
-sync_pb::SessionHeader SyncedSession::ToSessionHeader() const {
+sync_pb::SessionHeader SyncedSession::ToSessionHeaderProto() const {
   sync_pb::SessionHeader header;
   for (const auto& window_pair : windows) {
     sync_pb::SessionWindow* w = header.add_window();
-    w->CopyFrom(window_pair.second->ToSyncData());
+    w->CopyFrom(window_pair.second->ToSessionWindowProto());
   }
   header.set_client_name(session_name);
   switch (device_type) {
diff --git a/chromium/components/sync_sessions/synced_session.h b/chromium/components/sync_sessions/synced_session.h
index e0defd96623..c3471ae20d4 100644
--- a/chromium/components/sync_sessions/synced_session.h
+++ b/chromium/components/sync_sessions/synced_session.h
@@ -16,12 +16,26 @@
 #include "components/sessions/core/session_types.h"
 #include "components/sync/protocol/session_specifics.pb.h"
 
-namespace sessions {
-struct SessionWindow;
-}
-
 namespace sync_sessions {
 
+// A Sync wrapper for a SessionWindow.
+struct SyncedSessionWindow {
+  SyncedSessionWindow();
+  ~SyncedSessionWindow();
+
+  // Convert this object into its sync protocol buffer equivalent.
+  sync_pb::SessionWindow ToSessionWindowProto() const;
+
+  // Type of the window. See session_specifics.proto.
+  sync_pb::SessionWindow::BrowserType window_type;
+
+  // The SessionWindow this object wraps.
+  sessions::SessionWindow wrapped_window;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(SyncedSessionWindow);
+};
+
 // Defines a synced session for use by session sync. A synced session is a
 // list of windows along with a unique session identifer (tag) and meta-data
 // about the device being synced.
@@ -55,8 +69,7 @@ struct SyncedSession {
   base::Time modified_time;
 
   // Map of windows that make up this session.
-  std::map<SessionID::id_type, std::unique_ptr<sessions::SessionWindow>>
-      windows;
+  std::map<SessionID::id_type, std::unique_ptr<SyncedSessionWindow>> windows;
 
   // A tab node id is part of the identifier for the sync tab objects. Tab node
   // ids are not used for interacting with the model/browser tabs. However, when
@@ -95,7 +108,7 @@ struct SyncedSession {
 
   // Convert this object to its protocol buffer equivalent. Shallow conversion,
   // does not create SessionTab protobufs.
-  sync_pb::SessionHeader ToSessionHeader() const;
+  sync_pb::SessionHeader ToSessionHeaderProto() const;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SyncedSession);
diff --git a/chromium/components/sync_sessions/synced_session_tracker.cc b/chromium/components/sync_sessions/synced_session_tracker.cc
index 87ee848bc5d..94e6e9ff386 100644
--- a/chromium/components/sync_sessions/synced_session_tracker.cc
+++ b/chromium/components/sync_sessions/synced_session_tracker.cc
@@ -10,7 +10,7 @@
 #include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/sync_sessions/sync_sessions_client.h"
-
+#include "components/sync_sessions/synced_tab_delegate.h"
 namespace sync_sessions {
 
 namespace {
@@ -35,7 +35,8 @@ bool IsPresentable(SyncSessionsClient* sessions_client,
                    SyncedSession* foreign_session) {
   for (auto iter = foreign_session->windows.begin();
        iter != foreign_session->windows.end(); ++iter) {
-    if (ShouldSyncSessionWindow(sessions_client, *(iter->second))) {
+    if (ShouldSyncSessionWindow(sessions_client,
+                                iter->second->wrapped_window)) {
       return true;
     }
   }
@@ -83,7 +84,7 @@ bool SyncedSessionTracker::LookupSessionWindows(
   if (iter == synced_session_map_.end())
     return false;
   for (const auto& window_pair : iter->second->windows)
-    windows->push_back(window_pair.second.get());
+    windows->push_back(&window_pair.second->wrapped_window);
 
   return true;
 }
@@ -92,7 +93,7 @@ bool SyncedSessionTracker::LookupSessionTab(
     const std::string& tag,
     SessionID::id_type tab_id,
     const sessions::SessionTab** tab) const {
-  if (tab_id == TabNodePool::kInvalidTabID)
+  if (tab_id == kInvalidTabID)
     return false;
 
   DCHECK(tab);
@@ -181,11 +182,11 @@ void SyncedSessionTracker::ResetSessionTracking(
 
   for (auto& window_pair : session->windows) {
     // First unmap the tabs in the window.
-    for (auto& tab : window_pair.second->tabs) {
+    for (auto& tab : window_pair.second->wrapped_window.tabs) {
       SessionID::id_type tab_id = tab->tab_id.id();
       unmapped_tabs_[session_tag][tab_id] = std::move(tab);
     }
-    window_pair.second->tabs.clear();
+    window_pair.second->wrapped_window.tabs.clear();
 
     // Then unmap the window itself.
     unmapped_windows_[session_tag][window_pair.first] =
@@ -220,7 +221,7 @@ bool SyncedSessionTracker::IsTabUnmappedForTesting(SessionID::id_type tab_id) {
 
 void SyncedSessionTracker::PutWindowInSession(const std::string& session_tag,
                                               SessionID::id_type window_id) {
-  std::unique_ptr<sessions::SessionWindow> window;
+  std::unique_ptr<SyncedSessionWindow> window;
 
   auto iter = unmapped_windows_[session_tag].find(window_id);
   if (iter != unmapped_windows_[session_tag].end()) {
@@ -232,14 +233,14 @@ void SyncedSessionTracker::PutWindowInSession(const std::string& session_tag,
                                                             : session_tag);
   } else {
     // Create the window.
-    window = base::MakeUnique<sessions::SessionWindow>();
-    window->window_id.set_id(window_id);
+    window = base::MakeUnique<SyncedSessionWindow>();
+    window->wrapped_window.window_id.set_id(window_id);
     synced_window_map_[session_tag][window_id] = window.get();
     DVLOG(1) << "Putting new window " << window_id << " at " << window.get()
              << "in " << (session_tag == local_session_tag_ ? "local session"
                                                             : session_tag);
   }
-  DCHECK_EQ(window->window_id.id(), window_id);
+  DCHECK_EQ(window->wrapped_window.window_id.id(), window_id);
   DCHECK(GetSession(session_tag)->windows.end() ==
          GetSession(session_tag)->windows.find(window_id));
   GetSession(session_tag)->windows[window_id] = std::move(window);
@@ -273,14 +274,14 @@ void SyncedSessionTracker::PutTabInWindow(const std::string& session_tag,
     // window.
     for (auto& window_iter_pair : GetSession(session_tag)->windows) {
       auto tab_iter = std::find_if(
-          window_iter_pair.second->tabs.begin(),
-          window_iter_pair.second->tabs.end(),
+          window_iter_pair.second->wrapped_window.tabs.begin(),
+          window_iter_pair.second->wrapped_window.tabs.end(),
           [&tab_ptr](const std::unique_ptr<sessions::SessionTab>& tab) {
             return tab.get() == tab_ptr;
           });
-      if (tab_iter != window_iter_pair.second->tabs.end()) {
+      if (tab_iter != window_iter_pair.second->wrapped_window.tabs.end()) {
         tab = std::move(*tab_iter);
-        window_iter_pair.second->tabs.erase(tab_iter);
+        window_iter_pair.second->wrapped_window.tabs.erase(tab_iter);
 
         DVLOG(1) << "Moving tab " << tab_id << " from window "
                  << window_iter_pair.first << " to " << window_id;
@@ -297,8 +298,9 @@ void SyncedSessionTracker::PutTabInWindow(const std::string& session_tag,
   DVLOG(1) << "  - tab " << tab_id << " added to window " << window_id;
   DCHECK(GetSession(session_tag)->windows.find(window_id) !=
          GetSession(session_tag)->windows.end());
-  auto& window_tabs = GetSession(session_tag)->windows[window_id]->tabs;
-  window_tabs.push_back(std::move(tab));
+  GetSession(session_tag)
+      ->windows[window_id]
+      ->wrapped_window.tabs.push_back(std::move(tab));
 }
 
 void SyncedSessionTracker::OnTabNodeSeen(const std::string& session_tag,
@@ -382,15 +384,14 @@ bool SyncedSessionTracker::GetTabNodeFromLocalTabId(SessionID::id_type tab_id,
 bool SyncedSessionTracker::IsLocalTabNodeAssociated(int tab_node_id) {
   if (tab_node_id == TabNodePool::kInvalidTabNodeID)
     return false;
-  return local_tab_pool_.GetTabIdFromTabNodeId(tab_node_id) !=
-         TabNodePool::kInvalidTabID;
+  return local_tab_pool_.GetTabIdFromTabNodeId(tab_node_id) != kInvalidTabID;
 }
 
 void SyncedSessionTracker::ReassociateLocalTab(int tab_node_id,
                                                SessionID::id_type new_tab_id) {
   DCHECK(!local_session_tag_.empty());
   DCHECK_NE(TabNodePool::kInvalidTabNodeID, tab_node_id);
-  DCHECK_NE(TabNodePool::kInvalidTabID, new_tab_id);
+  DCHECK_NE(kInvalidTabID, new_tab_id);
 
   SessionID::id_type old_tab_id =
       local_tab_pool_.GetTabIdFromTabNodeId(tab_node_id);
@@ -399,7 +400,7 @@ void SyncedSessionTracker::ReassociateLocalTab(int tab_node_id,
   sessions::SessionTab* tab_ptr = nullptr;
 
   auto old_tab_iter = synced_tab_map_[local_session_tag_].find(old_tab_id);
-  if (old_tab_id != TabNodePool::kInvalidTabID &&
+  if (old_tab_id != kInvalidTabID &&
       old_tab_iter != synced_tab_map_[local_session_tag_].end()) {
     tab_ptr = old_tab_iter->second;
     // Remove the tab from the synced tab map under the old id.
@@ -412,7 +413,7 @@ void SyncedSessionTracker::ReassociateLocalTab(int tab_node_id,
 
   // If the old tab is unmapped, update the tab id under which it is indexed.
   auto unmapped_tabs_iter = unmapped_tabs_[local_session_tag_].find(old_tab_id);
-  if (old_tab_id != TabNodePool::kInvalidTabID &&
+  if (old_tab_id != kInvalidTabID &&
       unmapped_tabs_iter != unmapped_tabs_[local_session_tag_].end()) {
     std::unique_ptr<sessions::SessionTab> tab =
         std::move(unmapped_tabs_iter->second);
@@ -422,7 +423,7 @@ void SyncedSessionTracker::ReassociateLocalTab(int tab_node_id,
   }
 
   // Update the tab id.
-  if (old_tab_id != TabNodePool::kInvalidTabID) {
+  if (old_tab_id != kInvalidTabID) {
     DVLOG(1) << "Remapped tab " << old_tab_id << " with node " << tab_node_id
              << " to tab " << new_tab_id;
   } else {
diff --git a/chromium/components/sync_sessions/synced_session_tracker.h b/chromium/components/sync_sessions/synced_session_tracker.h
index ccd47839e24..506d3d0cbee 100644
--- a/chromium/components/sync_sessions/synced_session_tracker.h
+++ b/chromium/components/sync_sessions/synced_session_tracker.h
@@ -219,7 +219,7 @@ class SyncedSessionTracker {
   // Map: session tag -> (tab/window -> SessionTab*/SessionWindow*)
   std::map<std::string, std::map<SessionID::id_type, sessions::SessionTab*>>
       synced_tab_map_;
-  std::map<std::string, std::map<SessionID::id_type, sessions::SessionWindow*>>
+  std::map<std::string, std::map<SessionID::id_type, SyncedSessionWindow*>>
       synced_window_map_;
 
   // The collection that owns the SyncedSessions, and transitively, all of the
@@ -237,9 +237,8 @@ class SyncedSessionTracker {
   std::map<std::string,
            std::map<SessionID::id_type, std::unique_ptr<sessions::SessionTab>>>
       unmapped_tabs_;
-  std::map<
-      std::string,
-      std::map<SessionID::id_type, std::unique_ptr<sessions::SessionWindow>>>
+  std::map<std::string,
+           std::map<SessionID::id_type, std::unique_ptr<SyncedSessionWindow>>>
       unmapped_windows_;
 
   // The tag for this machine's local session, so we can distinguish the foreign
diff --git a/chromium/components/sync_sessions/synced_session_tracker_unittest.cc b/chromium/components/sync_sessions/synced_session_tracker_unittest.cc
index 0728a369cbd..9da19516ab0 100644
--- a/chromium/components/sync_sessions/synced_session_tracker_unittest.cc
+++ b/chromium/components/sync_sessions/synced_session_tracker_unittest.cc
@@ -9,6 +9,7 @@
 #include "base/strings/utf_string_conversions.h"
 #include "components/sessions/core/serialized_navigation_entry_test_helper.h"
 #include "components/sync_sessions/fake_sync_sessions_client.h"
+#include "components/sync_sessions/synced_tab_delegate.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace sync_sessions {
@@ -68,9 +69,9 @@ TEST_F(SyncedSessionTrackerTest, PutTabInWindow) {
   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.
 }
 
@@ -124,8 +125,7 @@ TEST_F(SyncedSessionTrackerTest, LookupSessionWindows) {
 
 TEST_F(SyncedSessionTrackerTest, LookupSessionTab) {
   const sessions::SessionTab* tab;
-  ASSERT_FALSE(
-      GetTracker()->LookupSessionTab(kTag, TabNodePool::kInvalidTabID, &tab));
+  ASSERT_FALSE(GetTracker()->LookupSessionTab(kTag, kInvalidTabID, &tab));
   ASSERT_FALSE(GetTracker()->LookupSessionTab(kTag, 5, &tab));
   GetTracker()->GetSession(kTag);
   GetTracker()->PutWindowInSession(kTag, 0);
@@ -295,8 +295,8 @@ TEST_F(SyncedSessionTrackerTest, SessionTracking) {
   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.
@@ -304,7 +304,7 @@ TEST_F(SyncedSessionTrackerTest, SessionTracking) {
   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.
@@ -328,9 +328,9 @@ TEST_F(SyncedSessionTrackerTest, SessionTracking) {
 
   // 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));
@@ -440,9 +440,9 @@ TEST_F(SyncedSessionTrackerTest, ReassociateTabMapped) {
   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);
@@ -462,7 +462,7 @@ TEST_F(SyncedSessionTrackerTest, ReassociateTabMapped) {
   // 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());
@@ -487,9 +487,9 @@ TEST_F(SyncedSessionTrackerTest, ReassociateTabMappedTwice) {
   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);
@@ -516,7 +516,7 @@ TEST_F(SyncedSessionTrackerTest, ReassociateTabMappedTwice) {
   // 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());
@@ -554,7 +554,7 @@ TEST_F(SyncedSessionTrackerTest, ReassociateTabUnmapped) {
   // 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());
diff --git a/chromium/components/sync_sessions/synced_tab_delegate.h b/chromium/components/sync_sessions/synced_tab_delegate.h
index 9781578c777..c69de8755d8 100644
--- a/chromium/components/sync_sessions/synced_tab_delegate.h
+++ b/chromium/components/sync_sessions/synced_tab_delegate.h
@@ -20,6 +20,8 @@ class SyncSessionsClient;
 
 namespace sync_sessions {
 
+enum InvalidTab { kInvalidTabID = -1 };
+
 // A SyncedTabDelegate is used to insulate the sync code from depending
 // directly on WebContents, NavigationController, and the extensions TabHelper.
 class SyncedTabDelegate {
@@ -31,6 +33,10 @@ class SyncedTabDelegate {
   virtual SessionID::id_type GetSessionId() const = 0;
   virtual bool IsBeingDestroyed() const = 0;
 
+  // Get the tab id of the tab responsible for opening this tab, if applicable.
+  // Returns kUnknownTabID(-1) if no such tab relationship is known.
+  virtual SessionID::id_type GetSourceTabID() const = 0;
+
   // Method derived from extensions TabHelper.
   virtual std::string GetExtensionAppId() const = 0;
 
diff --git a/chromium/components/sync_sessions/tab_node_pool.cc b/chromium/components/sync_sessions/tab_node_pool.cc
index f187d23dc76..1b4c1f88f62 100644
--- a/chromium/components/sync_sessions/tab_node_pool.cc
+++ b/chromium/components/sync_sessions/tab_node_pool.cc
@@ -10,6 +10,7 @@
 #include "components/sync/base/model_type.h"
 #include "components/sync/protocol/session_specifics.pb.h"
 #include "components/sync/protocol/sync.pb.h"
+#include "components/sync_sessions/synced_tab_delegate.h"
 
 namespace sync_sessions {
 
diff --git a/chromium/components/sync_sessions/tab_node_pool.h b/chromium/components/sync_sessions/tab_node_pool.h
index 365edc46328..84f2c347b66 100644
--- a/chromium/components/sync_sessions/tab_node_pool.h
+++ b/chromium/components/sync_sessions/tab_node_pool.h
@@ -32,7 +32,6 @@ class TabNodePool {
  public:
   TabNodePool();
   ~TabNodePool();
-  enum InvalidTab { kInvalidTabID = -1 };
 
   // If free nodes > kFreeNodesHighWatermark, delete all free nodes until
   // free nodes <= kFreeNodesLowWatermark.