Reland v5 of Sessions Refactor

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 111 matching lines @@
                   [&change_string](const SyncChange& change) {
                     change_string += change.ToString();
                   });
     return testing::AssertionFailure()
            << "Change type mismatch: " << type_string << " vs "
            << change_string;
   }
   return testing::AssertionSuccess();
 }
 
-// Creates a field trial with the specified |trial_name| and |group_name| and
-// registers an associated |variation_id| for it for the given |service|.
-void CreateAndActivateFieldTrial(const std::string& trial_name,
-                                 const std::string& group_name,
-                                 variations::VariationID variation_id,
-                                 variations::IDCollectionKey service) {
-  base::FieldTrialList::CreateFieldTrial(trial_name, group_name);
-  variations::AssociateGoogleVariationID(service, trial_name, group_name,
-                                         variation_id);
-  // Access the trial to activate it.
-  base::FieldTrialList::FindFullName(trial_name);
-}
-
 class SessionNotificationObserver {
  public:
   SessionNotificationObserver()
       : notified_of_update_(false), notified_of_refresh_(false) {}
   void NotifyOfUpdate() { notified_of_update_ = true; }
   void NotifyOfRefresh() { notified_of_refresh_ = true; }
 
   bool notified_of_update() const { return notified_of_update_; }
   bool notified_of_refresh() const { return notified_of_refresh_; }
 
@@ skipping 241 matching lines @@
   SessionID window_id_;
   sync_pb::SessionWindow_BrowserType window_type_ =
       sync_pb::SessionWindow_BrowserType_TYPE_TABBED;
 };
 
 class TestSyncedWindowDelegatesGetter : public SyncedWindowDelegatesGetter {
  public:
   TestSyncedWindowDelegatesGetter() {}
   ~TestSyncedWindowDelegatesGetter() override {}
 
-  std::set<const SyncedWindowDelegate*> GetSyncedWindowDelegates() override {
+  SyncedWindowDelegateMap GetSyncedWindowDelegates() override {
     return delegates_;
   }
 
   const SyncedWindowDelegate* FindById(SessionID::id_type id) override {
-    for (auto* window : delegates_) {
-      if (window->GetSessionId() == id)
-        return window;
+    for (auto window_iter_pair : delegates_) {
+      if (window_iter_pair.second->GetSessionId() == id)
+        return window_iter_pair.second;
     }
     return nullptr;
   }
 
   void AddSyncedWindowDelegate(const SyncedWindowDelegate* delegate) {
-    delegates_.insert(delegate);
+    delegates_[delegate->GetSessionId()] = delegate;
   }
 
  private:
-  std::set<const SyncedWindowDelegate*> delegates_;
+  SyncedWindowDelegateMap delegates_;
 };
 
 class TestSyncChangeProcessor : public syncer::SyncChangeProcessor {
  public:
   explicit TestSyncChangeProcessor(SyncChangeList* output) : output_(output) {}
   SyncError ProcessSyncChanges(const tracked_objects::Location& from_here,
                                const SyncChangeList& change_list) override {
     if (error_.IsSet()) {
       SyncError error = error_;
       error_ = SyncError();
@@ skipping 73 matching lines @@
   }
 
  private:
   SyncedWindowDelegatesGetter* synced_window_getter_;
 };
 
 }  // namespace
 
 class SessionsSyncManagerTest : public testing::Test {
  protected:
-  SessionsSyncManagerTest() : test_processor_(nullptr) {
+  SessionsSyncManagerTest() {}
+
+  void SetUp() override {
     local_device_ = base::MakeUnique<LocalDeviceInfoProviderMock>(
         "cache_guid", "Wayne Gretzky's Hacking Box", "Chromium 10k",
         "Chrome 10k", sync_pb::SyncEnums_DeviceType_TYPE_LINUX, "device_id");
-  }
-
-  void SetUp() override {
     sync_client_ = base::MakeUnique<syncer::FakeSyncClient>();
     sessions_client_shim_ =
         base::MakeUnique<SyncSessionsClientShim>(&window_getter_);
     sync_prefs_ =
         base::MakeUnique<syncer::SyncPrefs>(sync_client_->GetPrefService());
     manager_ = base::MakeUnique<SessionsSyncManager>(
         sessions_client_shim(), sync_prefs_.get(), local_device_.get(),
         std::unique_ptr<LocalSessionEventRouter>(NewDummyRouter()),
         base::Bind(&SessionNotificationObserver::NotifyOfUpdate,
                    base::Unretained(&observer_)),
         base::Bind(&SessionNotificationObserver::NotifyOfRefresh,
                    base::Unretained(&observer_)));
   }
 
   void TearDown() override {
     test_processor_ = nullptr;
     helper()->Reset();
     sync_prefs_.reset();
     manager_.reset();
   }
 
   const DeviceInfo* GetLocalDeviceInfo() {
     return local_device_->GetLocalDeviceInfo();
   }
 
+  TabNodePool* GetTabPool() {
+    return &manager()->session_tracker_.local_tab_pool_;
+  }
+
   SessionsSyncManager* manager() { return manager_.get(); }
   SessionSyncTestHelper* helper() { return &helper_; }
   LocalDeviceInfoProvider* local_device() { return local_device_.get(); }
   SessionNotificationObserver* observer() { return &observer_; }
   syncer::SyncPrefs* sync_prefs() { return sync_prefs_.get(); }
   SyncSessionsClient* sessions_client_shim() {
     return sessions_client_shim_.get();
   }
   SyncedWindowDelegatesGetter* window_getter() { return &window_getter_; }
 
@@ skipping 121 matching lines @@
 
   SyncData CreateRemoteData(const sync_pb::EntitySpecifics& entity,
                             base::Time mtime = base::Time()) const {
     // The server ID is never relevant to these tests, so just use 1.
     return SyncData::CreateRemoteData(
         1, entity, mtime, syncer::AttachmentIdList(),
         syncer::AttachmentServiceProxyForTest::Create(),
         SessionsSyncManager::TagHashFromSpecifics(entity.session()));
   }
 
-  TestSyncedWindowDelegate* GetWindowAtIndex(size_t index) {
-    if (index >= windows_.size())
-      return nullptr;
-    return windows_[index].get();
-  }
-
   // Creates a new tab within the window specified by |window_id|, and points it
   // at |url|. Returns the newly created TestSyncedTabDelegate (not owned).
   TestSyncedTabDelegate* AddTab(SessionID::id_type window_id,
                                 const std::string& url,
                                 base::Time time) {
     tabs_.push_back(base::MakeUnique<TestSyncedTabDelegate>());
     for (auto& window : windows_) {
       if (window->GetSessionId() == window_id) {
         int tab_index = window->GetTabCount();
         window->OverrideTabAt(tab_index, tabs_.back().get());
@@ skipping 31 matching lines @@
     windows_.push_back(base::MakeUnique<TestSyncedWindowDelegate>());
     window_getter_.AddSyncedWindowDelegate(windows_.back().get());
     return windows_.back().get();
   }
 
  private:
   std::unique_ptr<syncer::FakeSyncClient> sync_client_;
   std::unique_ptr<SyncSessionsClientShim> sessions_client_shim_;
   std::unique_ptr<syncer::SyncPrefs> sync_prefs_;
   SessionNotificationObserver observer_;
-  DummyRouter* router_;
+  DummyRouter* router_ = nullptr;
   std::unique_ptr<SessionsSyncManager> manager_;
   SessionSyncTestHelper helper_;
-  TestSyncChangeProcessor* test_processor_;
+  TestSyncChangeProcessor* test_processor_ = nullptr;
   TestSyncedWindowDelegatesGetter window_getter_;
   std::vector<std::unique_ptr<TestSyncedWindowDelegate>> windows_;
   std::vector<std::unique_ptr<TestSyncedTabDelegate>> tabs_;
   std::unique_ptr<LocalDeviceInfoProviderMock> local_device_;
 };
 
 // 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");
@@ skipping 108 matching lines @@
   NavigateTab(tab, kBar2, kTime3);
   tab->set_current_entry_index(1);
 
   sessions::SessionTab session_tab;
   manager()->SetSessionTabFromDelegate(*tab, kTime9, &session_tab);
 
   EXPECT_EQ(2, session_tab.current_navigation_index);
   ASSERT_EQ(3u, session_tab.navigations.size());
 }
 
-// Tests that variation ids are set correctly.
-TEST_F(SessionsSyncManagerTest, SetVariationIds) {
-  // Create two trials with a group which has a variation id for Chrome Sync
-  // and one with a variation id for another service.
-  const variations::VariationID kVariationId1 = 3300200;
-  const variations::VariationID kVariationId2 = 3300300;
-  const variations::VariationID kVariationId3 = 3300400;
-
-  base::FieldTrialList field_trial_list(nullptr);
-  CreateAndActivateFieldTrial("trial name 1", "group name", kVariationId1,
-                              variations::CHROME_SYNC_SERVICE);
-  CreateAndActivateFieldTrial("trial name 2", "group name", kVariationId2,
-                              variations::CHROME_SYNC_SERVICE);
-  CreateAndActivateFieldTrial("trial name 3", "group name", kVariationId3,
-                              variations::GOOGLE_WEB_PROPERTIES);
-
-  sessions::SessionTab session_tab;
-  manager()->SetVariationIds(&session_tab);
-
-  ASSERT_EQ(2u, session_tab.variation_ids.size());
-  EXPECT_EQ(kVariationId1, session_tab.variation_ids[0]);
-  EXPECT_EQ(kVariationId2, session_tab.variation_ids[1]);
-}
-
 // Tests that for supervised users blocked navigations are recorded and marked
 // as such, while regular navigations are marked as allowed.
 TEST_F(SessionsSyncManagerTest, BlockedNavigations) {
   TestSyncedTabDelegate* tab =
       AddTab(AddWindow()->GetSessionId(), kFoo1, kTime1);
 
   auto entry2 = base::MakeUnique<sessions::SerializedNavigationEntry>();
   GURL url2("http://blocked.com/foo");
   SerializedNavigationEntryTestHelper::SetVirtualURL(GURL(url2), entry2.get());
   SerializedNavigationEntryTestHelper::SetTimestamp(kTime2, entry2.get());
@@ skipping 63 matching lines @@
   // Header creation + update.
   ASSERT_TRUE(ChangeTypeMatches(
       out, {SyncChange::ACTION_ADD, SyncChange::ACTION_UPDATE}));
   EXPECT_EQ(out.size(),
             CountIfTagMatches(out, manager()->current_machine_tag()));
   VerifyLocalHeaderChange(out[0], 0, 0);
   VerifyLocalHeaderChange(out[1], 0, 0);
 
   // Now take that header node and feed it in as input.
   SyncData d = CreateRemoteData(out[1].sync_data().GetSpecifics());
-  SyncDataList in(&d, &d + 1);
+  SyncDataList in = {d};
   out.clear();
   manager()->StopSyncing(syncer::SESSIONS);
   InitWithSyncDataTakeOutput(in, &out);
 
   ASSERT_TRUE(ChangeTypeMatches(out, {SyncChange::ACTION_UPDATE}));
   EXPECT_TRUE(out[0].sync_data().GetSpecifics().session().has_header());
 }
 
 // Tests MergeDataAndStartSyncing with sync data but no local data.
 TEST_F(SessionsSyncManagerTest, MergeWithInitialForeignSession) {
@@ skipping 26 matching lines @@
   ASSERT_EQ(1U, foreign_sessions.size());
   std::vector<std::vector<SessionID::id_type>> session_reference;
   session_reference.push_back(tab_list1);
   session_reference.push_back(tab_list2);
   helper()->VerifySyncedSession(kTag1, session_reference,
                                 *(foreign_sessions[0]));
 }
 
 // Ensure model association associates the pre-existing tabs.
 TEST_F(SessionsSyncManagerTest, MergeLocalSessionExistingTabs) {
-  SessionID::id_type window_id = AddWindow()->GetSessionId();
+  TestSyncedWindowDelegate* window = AddWindow();
+  SessionID::id_type window_id = window->GetSessionId();
   TestSyncedTabDelegate* tab = AddTab(window_id, kFoo1);
   NavigateTab(tab, kBar1);  // Adds back entry.
   NavigateTab(tab, kBaz1);  // Adds back entry.
   TestSyncedTabDelegate* tab2 = AddTab(window_id, kFoo2);
   NavigateTab(tab2, kBar2);  // Adds back entry.
 
   SyncChangeList out;
   InitWithSyncDataTakeOutput(SyncDataList(), &out);
-  // Header creation, add two tabs (and update them), header update.
-  ASSERT_TRUE(ChangeTypeMatches(
-      out, {SyncChange::ACTION_ADD, SyncChange::ACTION_ADD,
-            SyncChange::ACTION_UPDATE, SyncChange::ACTION_ADD,
-            SyncChange::ACTION_UPDATE, SyncChange::ACTION_UPDATE}));
+  // Header creation, add two tabs, header update.
+  ASSERT_TRUE(
+      ChangeTypeMatches(out,
+                        {SyncChange::ACTION_ADD, SyncChange::ACTION_ADD,
+                         SyncChange::ACTION_ADD, SyncChange::ACTION_UPDATE}));
   EXPECT_EQ(out.size(),
             CountIfTagMatches(out, manager()->current_machine_tag()));
 
   // Check that this machine's data is not included in the foreign windows.
   std::vector<const SyncedSession*> foreign_sessions;
   ASSERT_FALSE(manager()->GetAllForeignSessions(&foreign_sessions));
 
   VerifyLocalHeaderChange(out[0], 0, 0);
-  VerifyLocalTabChange(out[2], tab->GetEntryCount(), kBaz1);
-  VerifyLocalTabChange(out[4], tab2->GetEntryCount(), kBar2);
-  VerifyLocalHeaderChange(out[5], 1, 2);
+  VerifyLocalTabChange(out[1], tab->GetEntryCount(), kBaz1);
+  VerifyLocalTabChange(out[2], tab2->GetEntryCount(), kBar2);
+  VerifyLocalHeaderChange(out[3], 1, 2);
 
   // Verify tab delegates have Sync ids.
-  std::set<const SyncedWindowDelegate*> window_delegates =
-      window_getter()->GetSyncedWindowDelegates();
-  // Sync ids are in same order as tabs because the association happens after
-  // the tabs are opened (and therefore iterates through same order).
-  EXPECT_EQ(0, (*window_delegates.begin())->GetTabAt(0)->GetSyncId());
-  EXPECT_EQ(1, (*window_delegates.begin())->GetTabAt(1)->GetSyncId());
+  EXPECT_EQ(0, window->GetTabAt(0)->GetSyncId());
+  EXPECT_EQ(1, window->GetTabAt(1)->GetSyncId());
 }
 
 // This is a combination of MergeWithInitialForeignSession and
 // MergeLocalSessionExistingTabs. We repeat some checks performed in each of
 // those tests to ensure the common mixed scenario works.
 TEST_F(SessionsSyncManagerTest, MergeWithLocalAndForeignTabs) {
   // Local.
   TestSyncedTabDelegate* tab = AddTab(AddWindow()->GetSessionId(), kFoo1);
   NavigateTab(tab, kFoo2);
 
   // Foreign.
   std::vector<SessionID::id_type> tab_list1(std::begin(kTabIds1),
                                             std::end(kTabIds1));
   std::vector<sync_pb::SessionSpecifics> tabs1;
   sync_pb::SessionSpecifics meta(
       helper()->BuildForeignSession(kTag1, tab_list1, &tabs1));
   SyncDataList foreign_data;
   foreign_data.push_back(CreateRemoteData(meta));
   AddTabsToSyncDataList(tabs1, &foreign_data);
 
   SyncChangeList out;
   InitWithSyncDataTakeOutput(foreign_data, &out);
-  // Should be one header add, 1 tab add (and update), and one header update.
 
-  ASSERT_TRUE(ChangeTypeMatches(
-      out, {SyncChange::ACTION_ADD, SyncChange::ACTION_ADD,
-            SyncChange::ACTION_UPDATE, SyncChange::ACTION_UPDATE}));
+  // Should be one header add, 1 tab add, and one header update.
+  ASSERT_TRUE(ChangeTypeMatches(out,
+                                {SyncChange::ACTION_ADD, SyncChange::ACTION_ADD,
+                                 SyncChange::ACTION_UPDATE}));
   EXPECT_EQ(out.size(),
             CountIfTagMatches(out, manager()->current_machine_tag()));
 
   // Verify local data.
   VerifyLocalHeaderChange(out[0], 0, 0);
-  VerifyLocalTabChange(out[2], tab->GetEntryCount(), kFoo2);
-  VerifyLocalHeaderChange(out[3], 1, 1);
+  VerifyLocalTabChange(out[1], tab->GetEntryCount(), kFoo2);
+  VerifyLocalHeaderChange(out[2], 1, 1);
 
   // Verify foreign data.
   std::vector<const SyncedSession*> foreign_sessions;
   ASSERT_TRUE(manager()->GetAllForeignSessions(&foreign_sessions));
   std::vector<std::vector<SessionID::id_type>> session_reference;
   session_reference.push_back(tab_list1);
   helper()->VerifySyncedSession(kTag1, 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
@@ skipping 18 matching lines @@
   meta1_reference.push_back(tab_list1);
   std::vector<sync_pb::SessionSpecifics> tabs1;
   meta1 = helper()->BuildForeignSession(kTag1, tab_list1, &tabs1);
   foreign_data1.push_back(CreateRemoteData(meta1));
   AddTabsToSyncDataList(tabs1, &foreign_data1);
 
   SyncChangeList out;
   InitWithSyncDataTakeOutput(foreign_data1, &out);
 
   // 1 header add, two tab adds, one header update.
-  ASSERT_TRUE(ChangeTypeMatches(
-      out, {SyncChange::ACTION_ADD, SyncChange::ACTION_ADD,
-            SyncChange::ACTION_UPDATE, SyncChange::ACTION_ADD,
-            SyncChange::ACTION_UPDATE, SyncChange::ACTION_UPDATE}));
+  ASSERT_TRUE(
+      ChangeTypeMatches(out,
+                        {SyncChange::ACTION_ADD, SyncChange::ACTION_ADD,
+                         SyncChange::ACTION_ADD, SyncChange::ACTION_UPDATE}));
   EXPECT_EQ(out.size(),
             CountIfTagMatches(out, manager()->current_machine_tag()));
-  VerifyLocalHeaderChange(out[5], 2, 2);
+  VerifyLocalHeaderChange(out[3], 2, 2);
 
   // Add a second window to the foreign session.
   std::vector<SessionID::id_type> tab_list2(std::begin(kTabIds2),
                                             std::end(kTabIds2));
   meta1_reference.push_back(tab_list2);
   helper()->AddWindowSpecifics(1, tab_list2, &meta1);
   std::vector<sync_pb::SessionSpecifics> tabs2;
   tabs2.resize(tab_list2.size());
   for (size_t i = 0; i < tab_list2.size(); ++i) {
     helper()->BuildTabSpecifics(kTag1, 0, tab_list2[i], &tabs2[i]);
@@ skipping 65 matching lines @@
   EXPECT_TRUE(changes.empty());
 
   // Fill an instance of session specifics with a foreign session's data.
   std::vector<sync_pb::SessionSpecifics> tabs;
   std::vector<SessionID::id_type> tab_list1(std::begin(kTabIds1),
                                             std::end(kTabIds1));
   sync_pb::SessionSpecifics meta(
       helper()->BuildForeignSession(kTag1, tab_list1, &tabs));
 
   // Update associator with the session's meta node, window, and tabs.
-  manager()->UpdateTrackerWithForeignSession(meta, base::Time());
+  manager()->UpdateTrackerWithSpecifics(meta, base::Time());
   for (std::vector<sync_pb::SessionSpecifics>::iterator iter = tabs.begin();
        iter != tabs.end(); ++iter) {
-    manager()->UpdateTrackerWithForeignSession(*iter, base::Time());
+    manager()->UpdateTrackerWithSpecifics(*iter, base::Time());
   }
   ASSERT_TRUE(manager()->GetAllForeignSessions(&foreign_sessions));
   ASSERT_EQ(1U, foreign_sessions.size());
 
   // Now delete the foreign session.
   manager()->DeleteForeignSessionInternal(kTag1, &changes);
   EXPECT_FALSE(manager()->GetAllForeignSessions(&foreign_sessions));
 
   EXPECT_EQ(5U, changes.size());
   ASSERT_TRUE(AllOfChangesAreType(changes, SyncChange::ACTION_DELETE));
@@ skipping 106 matching lines @@
   out.clear();
   manager()->ProcessSyncChanges(FROM_HERE, changes);
   EXPECT_TRUE(manager()->local_tab_pool_out_of_sync_);
   EXPECT_TRUE(out.empty());  // ChangeProcessor shouldn't see any activity.
 
   // This should trigger repair of the TabNodePool.
   AddTab(window_id, kFoo1);
   EXPECT_FALSE(manager()->local_tab_pool_out_of_sync_);
 
   // Rebuilding associations will trigger an initial header add and update,
-  // coupled with the tab creation/update and the header update to reflect the
-  // new tab. In total, that means four changes.
+  // coupled with the tab creation and the header update to reflect the new tab.
+  // In total, that means four changes.
   ASSERT_TRUE(
-      ChangeTypeMatches(out, {SyncChange::ACTION_ADD, SyncChange::ACTION_UPDATE,
-                              SyncChange::ACTION_ADD, SyncChange::ACTION_UPDATE,
-                              SyncChange::ACTION_UPDATE}));
+      ChangeTypeMatches(out,
+                        {SyncChange::ACTION_ADD, SyncChange::ACTION_UPDATE,
+                         SyncChange::ACTION_ADD, SyncChange::ACTION_UPDATE}));
 
   // Verify the actual content.
-  VerifyLocalTabChange(out[3], 1, kFoo1);
-  VerifyLocalHeaderChange(out[4], 1, 1);
+  VerifyLocalTabChange(out[2], 1, kFoo1);
+  VerifyLocalHeaderChange(out[3], 1, 1);
 
   // Verify TabLinks.
-  SessionsSyncManager::TabLinksMap tab_map = manager()->local_tab_map_;
-  ASSERT_EQ(1U, tab_map.size());
-  int tab_node_id = out[3].sync_data().GetSpecifics().session().tab_node_id();
-  int tab_id = out[3].sync_data().GetSpecifics().session().tab().tab_id();
-  EXPECT_EQ(tab_node_id, tab_map.find(tab_id)->second->tab_node_id());
+  EXPECT_EQ(1U, GetTabPool()->Capacity());
+  EXPECT_TRUE(GetTabPool()->Empty());
+  int tab_node_id = out[2].sync_data().GetSpecifics().session().tab_node_id();
+  int tab_id = out[2].sync_data().GetSpecifics().session().tab().tab_id();
+  EXPECT_EQ(tab_id, GetTabPool()->GetTabIdFromTabNodeId(tab_node_id));
 }
 
 // Test that receiving a session delete from sync removes the session
 // from tracking.
 TEST_F(SessionsSyncManagerTest, ProcessForeignDelete) {
   InitWithNoSyncData();
   std::vector<sync_pb::SessionSpecifics> tabs1;
   std::vector<SessionID::id_type> tab_list1(std::begin(kTabIds1),
                                             std::end(kTabIds1));
   sync_pb::SessionSpecifics meta(
@@ skipping 123 matching lines @@
   output.clear();
 
   // Verify that cleanup post-merge cleanup correctly removes all tabs objects.
   const sessions::SessionTab* tab;
   ASSERT_FALSE(
       manager()->session_tracker_.LookupSessionTab(session_tag, 1, &tab));
   ASSERT_FALSE(
       manager()->session_tracker_.LookupSessionTab(session_tag, 2, &tab));
 
   std::set<int> tab_node_ids;
-  manager()->session_tracker_.LookupTabNodeIds(session_tag, &tab_node_ids);
+  manager()->session_tracker_.LookupForeignTabNodeIds(session_tag,
+                                                      &tab_node_ids);
   EXPECT_EQ(6U, tab_node_ids.size());
   EXPECT_TRUE(tab_node_ids.find(tab1A.tab_node_id()) != tab_node_ids.end());
   EXPECT_TRUE(tab_node_ids.find(tab1B.tab_node_id()) != tab_node_ids.end());
   EXPECT_TRUE(tab_node_ids.find(tab1C.tab_node_id()) != tab_node_ids.end());
   EXPECT_TRUE(tab_node_ids.find(tab2A.tab_node_id()) != tab_node_ids.end());
   EXPECT_TRUE(tab_node_ids.find(tab2B.tab_node_id()) != tab_node_ids.end());
   EXPECT_TRUE(tab_node_ids.find(tab2C.tab_node_id()) != tab_node_ids.end());
 
   SyncChangeList changes;
   changes.push_back(MakeRemoteChange(tab1A, SyncChange::ACTION_DELETE));
   changes.push_back(MakeRemoteChange(tab1B, SyncChange::ACTION_DELETE));
   changes.push_back(MakeRemoteChange(tab2C, SyncChange::ACTION_DELETE));
   manager()->ProcessSyncChanges(FROM_HERE, changes);
 
   tab_node_ids.clear();
-  manager()->session_tracker_.LookupTabNodeIds(session_tag, &tab_node_ids);
+  manager()->session_tracker_.LookupForeignTabNodeIds(session_tag,
+                                                      &tab_node_ids);
   EXPECT_EQ(3U, tab_node_ids.size());
   EXPECT_TRUE(tab_node_ids.find(tab1C.tab_node_id()) != tab_node_ids.end());
   EXPECT_TRUE(tab_node_ids.find(tab2A.tab_node_id()) != tab_node_ids.end());
   EXPECT_TRUE(tab_node_ids.find(tab2B.tab_node_id()) != tab_node_ids.end());
 
   manager()->DoGarbageCollection();
   ASSERT_EQ(3U, output.size());
 }
 
 TEST_F(SessionsSyncManagerTest, ProcessForeignDeleteTabsWithReusedNodeIds) {
@@ skipping 18 matching lines @@
   AddToSyncDataList(tab2A, &foreign_data,
                     stale_mtime + base::TimeDelta::FromMinutes(1));
 
   AddWindow();
   SyncChangeList output;
   InitWithSyncDataTakeOutput(foreign_data, &output);
   ASSERT_EQ(2U, output.size());
   output.clear();
 
   std::set<int> tab_node_ids;
-  manager()->session_tracker_.LookupTabNodeIds(session_tag, &tab_node_ids);
+  manager()->session_tracker_.LookupForeignTabNodeIds(session_tag,
+                                                      &tab_node_ids);
   EXPECT_EQ(2U, tab_node_ids.size());
   EXPECT_TRUE(tab_node_ids.find(tab_node_id_shared) != tab_node_ids.end());
   EXPECT_TRUE(tab_node_ids.find(tab_node_id_unique) != tab_node_ids.end());
 
   SyncChangeList changes;
   changes.push_back(MakeRemoteChange(tab1A, SyncChange::ACTION_DELETE));
   manager()->ProcessSyncChanges(FROM_HERE, changes);
 
   tab_node_ids.clear();
-  manager()->session_tracker_.LookupTabNodeIds(session_tag, &tab_node_ids);
+  manager()->session_tracker_.LookupForeignTabNodeIds(session_tag,
+                                                      &tab_node_ids);
   EXPECT_EQ(1U, tab_node_ids.size());
   EXPECT_TRUE(tab_node_ids.find(tab_node_id_unique) != tab_node_ids.end());
 
   manager()->DoGarbageCollection();
   EXPECT_EQ(1U, output.size());
 }
 
 TEST_F(SessionsSyncManagerTest, AssociationReusesNodes) {
   SyncChangeList changes;
   AddTab(AddWindow()->GetSessionId(), kFoo1);
   InitWithSyncDataTakeOutput(SyncDataList(), &changes);
-  ASSERT_TRUE(ChangeTypeMatches(
-      changes, {SyncChange::ACTION_ADD, SyncChange::ACTION_ADD,
-                SyncChange::ACTION_UPDATE, SyncChange::ACTION_UPDATE}));
-  ASSERT_TRUE(changes[2].sync_data().GetSpecifics().session().has_tab());
+  ASSERT_TRUE(ChangeTypeMatches(changes,
+                                {SyncChange::ACTION_ADD, SyncChange::ACTION_ADD,
+                                 SyncChange::ACTION_UPDATE}));
+  ASSERT_TRUE(changes[1].sync_data().GetSpecifics().session().has_tab());
   int tab_node_id =
       changes[1].sync_data().GetSpecifics().session().tab_node_id();
 
   // Pass back the previous tab and header nodes at association, along with a
   // second tab node (with a rewritten tab node id).
   SyncDataList in;
   in.push_back(
-      CreateRemoteData(changes[3].sync_data().GetSpecifics()));  // Header node.
+      CreateRemoteData(changes[2].sync_data().GetSpecifics()));  // Header node.
   sync_pb::SessionSpecifics new_tab(
-      changes[2].sync_data().GetSpecifics().session());
+      changes[1].sync_data().GetSpecifics().session());
   new_tab.set_tab_node_id(tab_node_id + 1);
   in.push_back(CreateRemoteData(new_tab));  // New tab node.
   in.push_back(CreateRemoteData(
-      changes[2].sync_data().GetSpecifics()));  // Old tab node.
+      changes[1].sync_data().GetSpecifics()));  // Old tab node.
   changes.clear();
 
   // Reassociate (with the same single tab/window open).
   manager()->StopSyncing(syncer::SESSIONS);
   InitWithSyncDataTakeOutput(in, &changes);
 
   // No tab entities should be deleted. The original (lower) tab node id should
   // be reused for association.
   FilterOutLocalHeaderChanges(&changes);
   ASSERT_TRUE(ChangeTypeMatches(changes, {SyncChange::ACTION_UPDATE}));
@@ skipping 78 matching lines @@
       AddTab(AddWindow()->GetSessionId(), "chrome://preferences/");
   InitWithSyncDataTakeOutput(SyncDataList(), &out);
   ASSERT_TRUE(ChangeTypeMatches(
       out, {SyncChange::ACTION_ADD, SyncChange::ACTION_UPDATE}));
   VerifyLocalHeaderChange(out[1], 0, 0);
   out.clear();
 
   // Go to a sync-interesting URL.
   NavigateTab(tab, kFoo1);
 
-  // The tab should be created/updated, coupled with a header update.
-  ASSERT_TRUE(
-      ChangeTypeMatches(out, {SyncChange::ACTION_ADD, SyncChange::ACTION_UPDATE,
-                              SyncChange::ACTION_UPDATE}));
-  VerifyLocalTabChange(out[1], 2, kFoo1);
-  VerifyLocalHeaderChange(out[2], 1, 1);
+  // The tab should be created, coupled with a header update.
+  ASSERT_TRUE(ChangeTypeMatches(
+      out, {SyncChange::ACTION_ADD, SyncChange::ACTION_UPDATE}));
+  VerifyLocalTabChange(out[0], 2, kFoo1);
+  VerifyLocalHeaderChange(out[1], 1, 1);
 }
 
 // Tests that the SyncSessionManager responds to local tab events properly.
 TEST_F(SessionsSyncManagerTest, OnLocalTabModified) {
   SyncChangeList out;
   // Init with no local data, relies on MergeLocalSessionNoTabs.
-  SessionID::id_type window_id = AddWindow()->GetSessionId();
+  TestSyncedWindowDelegate* window = AddWindow();
+  SessionID::id_type window_id = window->GetSessionId();
   InitWithSyncDataTakeOutput(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();
 
   NavigateTab(AddTab(window_id, kFoo1), kFoo2);
   NavigateTab(AddTab(window_id, kBar1), kBar2);
   std::vector<std::string> urls = {kFoo1, kFoo2, kBar1, kBar2};
 
   // Change type breakdown:
-  // 1 tab add/update + 2 header updates.
-  const size_t kChangesPerTabCreation = 4;
+  // 1 tab add + 2 header updates.
+  const size_t kChangesPerTabCreation = 3;
   // 1 tab update + 1 header update.
   const size_t kChangesPerTabNav = 2;
   const size_t kChangesPerTab = kChangesPerTabNav + kChangesPerTabCreation;
   const size_t kNumTabs = 2;
   const size_t kTotalUpdates = kChangesPerTab * kNumTabs;
 
   std::vector<SyncChange::SyncChangeType> types = {
       // Tab 1
       SyncChange::ACTION_UPDATE, SyncChange::ACTION_ADD,
       SyncChange::ACTION_UPDATE, SyncChange::ACTION_UPDATE,
-      SyncChange::ACTION_UPDATE, SyncChange::ACTION_UPDATE,
+      SyncChange::ACTION_UPDATE,
       // Tab 2
       SyncChange::ACTION_UPDATE, SyncChange::ACTION_ADD,
       SyncChange::ACTION_UPDATE, SyncChange::ACTION_UPDATE,
-      SyncChange::ACTION_UPDATE, SyncChange::ACTION_UPDATE};
+      SyncChange::ACTION_UPDATE};
   ASSERT_EQ(kTotalUpdates, types.size());
 
   // Verify the tab node creations and updates to ensure the SyncProcessor sees
   // the right operations. Do this by inspecting the set of changes for each
   // tab separately by iterating through the tabs.
   ASSERT_TRUE(ChangeTypeMatches(out, types));
   for (size_t i = 0; i < kNumTabs; ++i) {
     int index = kChangesPerTab * i;
     int nav_per_tab_count = 0;
     {
       SCOPED_TRACE(index);
       // The initial tab parent event triggers a header update (which is in
       // effect a no-op).
       VerifyLocalHeaderChange(out[index++], (i == 0 ? 0 : 1), i);
     }
-    index++;  // Ignore the tab add, which has no useful data.
     {
       SCOPED_TRACE(index);
       nav_per_tab_count++;
       // Tab update after initial creation..
       VerifyLocalTabChange(out[index++], nav_per_tab_count,
                            urls[i * kChangesPerTabNav + nav_per_tab_count - 1]);
     }
     {
       SCOPED_TRACE(index);
       // The associate windows after the tab creation.
       VerifyLocalHeaderChange(out[index++], 1, i + 1);
     }
     {
       SCOPED_TRACE(index);
       nav_per_tab_count++;
       // Tab navigation.
       VerifyLocalTabChange(out[index++], nav_per_tab_count,
                            urls[i * kChangesPerTabNav + nav_per_tab_count - 1]);
     }
     {
       SCOPED_TRACE(index);
       // The associate windows after the tab navigation.
       VerifyLocalHeaderChange(out[index++], 1, i + 1);
     }
   }
 
   // Verify tab delegates have Sync ids.
-  std::set<const SyncedWindowDelegate*> window_delegates =
-      window_getter()->GetSyncedWindowDelegates();
-  EXPECT_EQ(0, (*window_delegates.begin())->GetTabAt(0)->GetSyncId());
-  EXPECT_EQ(1, (*window_delegates.begin())->GetTabAt(1)->GetSyncId());
+  EXPECT_EQ(0, window->GetTabAt(0)->GetSyncId());
+  EXPECT_EQ(1, window->GetTabAt(1)->GetSyncId());
 }
 
 TEST_F(SessionsSyncManagerTest, ForeignSessionModifiedTime) {
   SyncDataList foreign_data;
   base::Time newest_time = base::Time::Now() - base::TimeDelta::FromDays(1);
   base::Time middle_time = base::Time::Now() - base::TimeDelta::FromDays(2);
   base::Time oldest_time = base::Time::Now() - base::TimeDelta::FromDays(3);
 
   {
     std::string session_tag = "tag1";
@@ skipping 267 matching lines @@
   EXPECT_TRUE(observer()->notified_of_refresh());
 }
 
 // Tests receipt of duplicate tab IDs in the same window.  This should never
 // happen, but we want to make sure the client won't do anything bad if it does
 // receive such garbage input data.
 TEST_F(SessionsSyncManagerTest, ReceiveDuplicateTabInSameWindow) {
   std::string tag = "tag1";
 
   // Reuse tab ID 10 in an attempt to trigger bad behavior.
-  std::vector<SessionID::id_type> tab_list1 = {5, 10, 10, 17};
+  std::vector<SessionID::id_type> tab_list1(std::begin(kTabIds1),
+                                            std::end(kTabIds1));
   std::vector<sync_pb::SessionSpecifics> tabs1;
   sync_pb::SessionSpecifics meta(
       helper()->BuildForeignSession(tag, tab_list1, &tabs1));
 
   // Set up initial data.
   SyncDataList initial_data;
   sync_pb::EntitySpecifics entity;
   entity.mutable_session()->CopyFrom(meta);
   initial_data.push_back(CreateRemoteData(entity));
   AddTabsToSyncDataList(tabs1, &initial_data);
 
   SyncChangeList output;
   InitWithSyncDataTakeOutput(initial_data, &output);
 }
 
 // Tests receipt of duplicate tab IDs for the same session.  The duplicate tab
 // ID is present in two different windows.  A client can't be expected to do
 // anything reasonable with this input, but we can expect that it doesn't
 // crash.
 TEST_F(SessionsSyncManagerTest, ReceiveDuplicateTabInOtherWindow) {
-  std::vector<SessionID::id_type> tab_list1 = {5, 10, 17};
+  std::vector<SessionID::id_type> tab_list1(std::begin(kTabIds1),
+                                            std::end(kTabIds1));
   std::vector<sync_pb::SessionSpecifics> tabs1;
   sync_pb::SessionSpecifics meta(
       helper()->BuildForeignSession(kTag1, tab_list1, &tabs1));
 
   // Add a second window.  Tab ID 10 is a duplicate.
-  std::vector<SessionID::id_type> tab_list2 = {10, 18, 20};
+  std::vector<SessionID::id_type> tab_list2(std::begin(kTabIds2),
+                                            std::end(kTabIds2));
   helper()->AddWindowSpecifics(1, tab_list2, &meta);
 
   // Set up initial data.
   SyncDataList initial_data;
   sync_pb::EntitySpecifics entity;
   entity.mutable_session()->CopyFrom(meta);
   initial_data.push_back(CreateRemoteData(entity));
   AddTabsToSyncDataList(tabs1, &initial_data);
 
   for (size_t i = 0; i < tab_list2.size(); ++i) {
     sync_pb::EntitySpecifics entity;
     helper()->BuildTabSpecifics(kTag1, 0, tab_list2[i],
                                 entity.mutable_session());
     initial_data.push_back(CreateRemoteData(entity));
   }
 
   SyncChangeList output;
   InitWithSyncDataTakeOutput(initial_data, &output);
 }
 
 // Tests receipt of multiple unassociated tabs and makes sure that
 // the ones with later timestamp win
 TEST_F(SessionsSyncManagerTest, ReceiveDuplicateUnassociatedTabs) {
-  std::vector<SessionID::id_type> tab_list1 = {5, 10, 17};
+  std::vector<SessionID::id_type> tab_list1(std::begin(kTabIds1),
+                                            std::end(kTabIds1));
   std::vector<sync_pb::SessionSpecifics> tabs1;
   sync_pb::SessionSpecifics meta(
       helper()->BuildForeignSession(kTag1, tab_list1, &tabs1));
 
   // Set up initial data.
   SyncDataList initial_data;
   initial_data.push_back(CreateRemoteData(meta));
 
   sync_pb::EntitySpecifics entity;
 
   for (size_t i = 0; i < tabs1.size(); ++i) {
     entity.mutable_session()->CopyFrom(tabs1[i]);
     initial_data.push_back(
         CreateRemoteData(entity, base::Time::FromDoubleT(2000)));
   }
 
   // Add two more tabs with duplicating IDs but with different modification
   // times, one before and one after the tabs above.
   // These two tabs get a different visual indices to distinguish them from the
   // tabs above that get visual index 1 by default.
   sync_pb::SessionSpecifics duplicating_tab1;
-  helper()->BuildTabSpecifics(kTag1, 0, 10, &duplicating_tab1);
+  helper()->BuildTabSpecifics(kTag1, 0, kTabIds1[1], &duplicating_tab1);
   duplicating_tab1.mutable_tab()->set_tab_visual_index(2);
   entity.mutable_session()->CopyFrom(duplicating_tab1);
   initial_data.push_back(
       CreateRemoteData(entity, base::Time::FromDoubleT(1000)));
 
   sync_pb::SessionSpecifics duplicating_tab2;
-  helper()->BuildTabSpecifics(kTag1, 0, 17, &duplicating_tab2);
+  helper()->BuildTabSpecifics(kTag1, 0, kTabIds1[2], &duplicating_tab2);
   duplicating_tab2.mutable_tab()->set_tab_visual_index(3);
   entity.mutable_session()->CopyFrom(duplicating_tab2);
   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;
-  ASSERT_EQ(3U, window_tabs.size());
+  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.
 TEST_F(SessionsSyncManagerTest, GetAllForeignSessions) {
@@ skipping 85 matching lines @@
   TestSyncedTabDelegate* tab2 = AddTab(window->GetSessionId(), kBar1);
   NavigateTab(tab2, kBar2);
   TestSyncedTabDelegate* tab3 = AddTab(window->GetSessionId(), kBaz1);
   NavigateTab(tab3, kBaz2);
 
   SyncDataList in;
   SyncChangeList out;
   InitWithSyncDataTakeOutput(in, &out);
 
   // Should be one header add, 3 tab adds/updates, one header update.
-  ASSERT_EQ(8U, out.size());
+  ASSERT_EQ(5U, out.size());
 
   // Now update the sync data to be:
   // * one "normal" fully loaded tab
   // * one placeholder tab with no WebContents and a tab_id change
   // * one placeholder tab with no WebContents and no tab_id change
-  sync_pb::EntitySpecifics t0_entity = out[2].sync_data().GetSpecifics();
-  sync_pb::EntitySpecifics t1_entity = out[4].sync_data().GetSpecifics();
+  sync_pb::EntitySpecifics t0_entity = out[1].sync_data().GetSpecifics();
+  sync_pb::EntitySpecifics t1_entity = out[2].sync_data().GetSpecifics();
   t1_entity.mutable_session()->mutable_tab()->set_tab_id(kRestoredTabId);
-  sync_pb::EntitySpecifics t2_entity = out[6].sync_data().GetSpecifics();
+  sync_pb::EntitySpecifics t2_entity = out[3].sync_data().GetSpecifics();
   in.push_back(CreateRemoteData(t0_entity));
   in.push_back(CreateRemoteData(t1_entity));
   in.push_back(CreateRemoteData(t2_entity));
   out.clear();
   manager()->StopSyncing(syncer::SESSIONS);
 
   PlaceholderTabDelegate t1_override(kNewTabId, 1);
   PlaceholderTabDelegate t2_override(t2_entity.session().tab().tab_id(), 2);
   window->OverrideTabAt(1, &t1_override);
   window->OverrideTabAt(2, &t2_override);
@@ skipping 18 matching lines @@
 TEST_F(SessionsSyncManagerTest, WindowIdUpdatedOnRestore) {
   const int kNewWindowId = 1337;
   SyncDataList in;
   SyncChangeList out;
 
   // Set up one tab and start sync with it.
   TestSyncedWindowDelegate* window = AddWindow();
   AddTab(window->GetSessionId(), kFoo1);
   InitWithSyncDataTakeOutput(in, &out);
 
-  // Should be one header add, 1 tab add/update, and one header update.
-  ASSERT_EQ(4U, out.size());
-  const sync_pb::EntitySpecifics t0_entity = out[2].sync_data().GetSpecifics();
+  // Should be one header add, 1 tab add, and one header update.
+  ASSERT_EQ(3U, out.size());
+  const sync_pb::EntitySpecifics t0_entity = out[1].sync_data().GetSpecifics();
   ASSERT_TRUE(t0_entity.session().has_tab());
 
   in.push_back(CreateRemoteData(t0_entity));
   out.clear();
   manager()->StopSyncing(syncer::SESSIONS);
 
   // Override the tab with a placeholder tab delegate.
   PlaceholderTabDelegate t0_override(t0_entity.session().tab().tab_id(),
                                      t0_entity.session().tab_node_id());
 
   // Set up the window override with the new window ID and placeholder tab.
   window->OverrideTabAt(0, &t0_override);
   window->OverrideWindowId(kNewWindowId);
   InitWithSyncDataTakeOutput(in, &out);
 
   // There should be one change for t0's window ID update.
   ASSERT_EQ(1U, FilterOutLocalHeaderChanges(&out)->size());
   VerifyLocalTabChange(out[0], 1, kFoo1);
   EXPECT_EQ(kNewWindowId,
             out[0].sync_data().GetSpecifics().session().tab().window_id());
 }
 
+// Ensure that the manager properly ignores a restored placeholder that refers
+// to a tab node that doesn't exist
+TEST_F(SessionsSyncManagerTest, RestoredPlacholderTabNodeDeleted) {
+  syncer::SyncDataList in;
+  syncer::SyncChangeList out;
+
+  // Set up one tab and start sync with it.
+  TestSyncedWindowDelegate* window = AddWindow();
+  AddTab(window->GetSessionId(), kFoo1);
+  InitWithSyncDataTakeOutput(in, &out);
+
+  // Should be one header add, 1 tab add, and one header update.
+  ASSERT_EQ(3U, out.size());
+  const sync_pb::EntitySpecifics t0_entity = out[1].sync_data().GetSpecifics();
+  ASSERT_TRUE(t0_entity.session().has_tab());
+
+  out.clear();
+  manager()->StopSyncing(syncer::SESSIONS);
+
+  // Override the tab with a placeholder tab delegate.
+  PlaceholderTabDelegate t0_override(t0_entity.session().tab().tab_id(),
+                                     t0_entity.session().tab_node_id());
+
+  // Override the tab with a placeholder whose sync entity won't exist.
+  window->OverrideTabAt(0, &t0_override);
+  InitWithSyncDataTakeOutput(in, &out);
+
+  // Because no entities were passed in at associate time, there should be no
+  // tab changes.
+  ASSERT_EQ(0U, FilterOutLocalHeaderChanges(&out)->size());
+}
+
+// Check the behavior for a placeholder tab in one window being mapped to the
+// same sync entity as a tab in another window. If the placeholder is associated
+// last, the original tab should be unmapped from the first window, and reused
+// by the placeholder in the new window..
+TEST_F(SessionsSyncManagerTest, PlaceholderConflictAcrossWindows) {
+  syncer::SyncDataList in;
+  syncer::SyncChangeList out;
+
+  // First sync with one tab and one window.
+  TestSyncedWindowDelegate* window = AddWindow();
+  TestSyncedTabDelegate* tab1 = AddTab(window->GetSessionId(), kFoo1);
+  InitWithSyncDataTakeOutput(in, &out);
+  ASSERT_TRUE(out[1].sync_data().GetSpecifics().session().has_tab());
+  manager()->StopSyncing(syncer::SESSIONS);
+
+  // Now create a second window with a placeholder that has the same sync id,
+  // but a different tab id.
+  TestSyncedWindowDelegate* window2 = AddWindow();
+  int sync_id = out[1].sync_data().GetSpecifics().session().tab_node_id();
+  PlaceholderTabDelegate tab2(SessionID().id(), sync_id);
+  window2->OverrideTabAt(0, &tab2);
+
+  // Resync, reusing the old sync data.
+  in.push_back(CreateRemoteData(out[0].sync_data().GetSpecifics()));
+  in.push_back(CreateRemoteData(out[1].sync_data().GetSpecifics()));
+  out.clear();
+  InitWithSyncDataTakeOutput(in, &out);
+
+  // The tab entity will be overwritten twice. Once with the information for
+  // tab 1 and then again with the information for tab 2. This will be followed
+  // by a header change reflecting both tabs.
+  ASSERT_TRUE(
+      ChangeTypeMatches(out,
+                        {SyncChange::ACTION_UPDATE, SyncChange::ACTION_UPDATE,
+                         SyncChange::ACTION_UPDATE}));
+  VerifyLocalHeaderChange(out[2], 2, 2);
+  VerifyLocalTabChange(out[0], 1, kFoo1);
+  EXPECT_EQ(sync_id, out[0].sync_data().GetSpecifics().session().tab_node_id());
+  EXPECT_EQ(tab1->GetSessionId(),
+            out[0].sync_data().GetSpecifics().session().tab().tab_id());
+  // 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