[Sync] Handle reassociation of tabs where the old tab is already mapped.

components/sync_sessions/synced_session_tracker_unittest.cc

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/sync_sessions/synced_session_tracker.h"
 
 #include "base/rand_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/sessions/core/serialized_navigation_entry_test_helper.h"
 #include "components/sync_sessions/fake_sync_sessions_client.h"
 #include "components/sync_sessions/synced_tab_delegate.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using testing::AssertionFailure;
+using testing::AssertionResult;
+using testing::AssertionSuccess;
+
 namespace sync_sessions {
 
 namespace {
 
 const char kValidUrl[] = "http://www.example.com";
 const char kInvalidUrl[] = "invalid.url";
 const char kTag[] = "tag";
 const char kTag2[] = "tag2";
 const char kTag3[] = "tag3";
 const char kTitle[] = "title";
 const int kWindow1 = 1;
-const int kTabNode = 0;
+const int kTabNode1 = 1;
+const int kTabNode2 = 2;
+const int kTabNode3 = 3;
 const int kTab1 = 15;
 const int kTab2 = 25;
 const int kTab3 = 35;
 
 }  // namespace
 
 class SyncedSessionTrackerTest : public testing::Test {
  public:
   SyncedSessionTrackerTest() : tracker_(&sessions_client_) {}
   ~SyncedSessionTrackerTest() override {}
 
   SyncedSessionTracker* GetTracker() { return &tracker_; }
   TabNodePool* GetTabNodePool() { return &tracker_.local_tab_pool_; }
 
+  // Verify that each tab within a session is allocated one SessionTab object,
+  // and that that tab object is owned either by the Session itself or the
+  // |unmapped_tabs_| tab holder.
+  AssertionResult VerifyTabIntegrity(const std::string& session_tag) {
+    // First get all the tabs associated with this session.
+    int total_tab_count = 0;
+    auto tab_map_iter = tracker_.synced_tab_map_.find(session_tag);
+    if (tab_map_iter != tracker_.synced_tab_map_.end())
+      total_tab_count = tab_map_iter->second.size();
+
+    // Now traverse the SyncedSession tree to verify the mapped tabs all match
+    // up.
+    int mapped_tab_count = 0;
+    if (tracker_.synced_session_map_.find(session_tag) !=
+        tracker_.synced_session_map_.end()) {
+      SyncedSession* session = tracker_.synced_session_map_[session_tag].get();
+      for (auto& window_pair : session->windows) {
+        mapped_tab_count += window_pair.second->wrapped_window.tabs.size();
+        for (auto& tab : window_pair.second->wrapped_window.tabs) {
+          if (tab_map_iter->second[tab->tab_id.id()] != tab.get()) {
+            return AssertionFailure()
+                   << "Mapped tab " << tab->tab_id.id()
+                   << " does not match synced tab map " << tab->tab_id.id();
+          }
+        }
+      }
+    }
+
+    // Wrap up by verifying all unmapped tabs are tracked.
+    int unmapped_tab_count = 0;
+    if (tracker_.unmapped_tabs_.find(session_tag) !=
+        tracker_.unmapped_tabs_.end()) {
+      unmapped_tab_count = tracker_.unmapped_tabs_[session_tag].size();
+      for (const auto& tab_pair : tracker_.unmapped_tabs_[session_tag]) {
+        if (tab_pair.first != tab_pair.second->tab_id.id()) {
+          return AssertionFailure()
+                 << "Unmapped tab " << tab_pair.second->tab_id.id()
+                 << " associated with wrong tab " << tab_pair.first;
+        }
+        if (tab_map_iter->second[tab_pair.second->tab_id.id()] !=
+            tab_pair.second.get()) {
+          return AssertionFailure()
+                 << "Unmapped tab " << tab_pair.second->tab_id.id()
+                 << " does not match synced tab map "
+                 << tab_pair.second->tab_id.id();
+        }
+      }
+    }
+
+    return mapped_tab_count + unmapped_tab_count == total_tab_count
+               ? AssertionSuccess()
+               : AssertionFailure()
+                     << " Tab count mismatch. Total: " << total_tab_count
+                     << ". Mapped + Unmapped: " << mapped_tab_count << " + "
+                     << unmapped_tab_count;
+  }
+
  private:
   FakeSyncSessionsClient sessions_client_;
   SyncedSessionTracker tracker_;
 };
 
 TEST_F(SyncedSessionTrackerTest, GetSession) {
   SyncedSession* session1 = GetTracker()->GetSession(kTag);
   SyncedSession* session2 = GetTracker()->GetSession(kTag2);
   ASSERT_EQ(session1, GetTracker()->GetSession(kTag));
   ASSERT_NE(session1, session2);
@@ skipping 18 matching lines @@
 }
 
 TEST_F(SyncedSessionTrackerTest, PutTabInWindow) {
   GetTracker()->PutWindowInSession(kTag, 10);
   GetTracker()->PutTabInWindow(kTag, 10, 15);  // win id 10, tab id 15
   SyncedSession* session = GetTracker()->GetSession(kTag);
   ASSERT_EQ(1U, session->windows.size());
   ASSERT_EQ(1U, session->windows[10]->wrapped_window.tabs.size());
   ASSERT_EQ(GetTracker()->GetTab(kTag, 15),
             session->windows[10]->wrapped_window.tabs[0].get());
+  ASSERT_TRUE(VerifyTabIntegrity(kTag));
   // Should clean up memory on its own.
 }
 
 TEST_F(SyncedSessionTrackerTest, LookupAllForeignSessions) {
   std::vector<const SyncedSession*> sessions;
   ASSERT_FALSE(GetTracker()->LookupAllForeignSessions(
       &sessions, SyncedSessionTracker::PRESENTABLE));
   GetTracker()->GetSession(kTag);
   GetTracker()->PutWindowInSession(kTag, 0);
   GetTracker()->PutTabInWindow(kTag, 0, 15);
@@ skipping 106 matching lines @@
   ASSERT_FALSE(GetTracker()->LookupAllForeignSessions(
       &sessions, SyncedSessionTracker::PRESENTABLE));
   ASSERT_TRUE(GetTracker()->LookupAllForeignSessions(
       &sessions, SyncedSessionTracker::RAW));
   ASSERT_EQ(2U, sessions.size());
 
   GetTracker()->Clear();
   ASSERT_EQ(0U, GetTracker()->num_synced_tabs(kTag));
   ASSERT_EQ(0U, GetTracker()->num_synced_tabs(kTag2));
   ASSERT_EQ(0U, GetTracker()->num_synced_sessions());
+  ASSERT_TRUE(VerifyTabIntegrity(kTag));
 }
 
 TEST_F(SyncedSessionTrackerTest, ManyGetTabs) {
   ASSERT_TRUE(GetTracker()->Empty());
   const int kMaxSessions = 10;
   const int kMaxTabs = 1000;
   const int kMaxAttempts = 10000;
   for (int j = 0; j < kMaxSessions; ++j) {
     std::string tag = base::StringPrintf("tag%d", j);
     for (int i = 0; i < kMaxAttempts; ++i) {
@@ skipping 116 matching lines @@
   GetTracker()->CleanupSession(kTag);
 
   // Verify that only those parts of the session not owned have been removed.
   ASSERT_EQ(1U, session1->windows.size());
   ASSERT_EQ(4U, session1->windows[0]->wrapped_window.tabs.size());
   ASSERT_EQ(1U, session2->windows.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));
+  ASSERT_TRUE(VerifyTabIntegrity(kTag));
 
   // All memory should be properly deallocated by destructor for the
   // SyncedSessionTracker.
 }
 
 TEST_F(SyncedSessionTrackerTest, DeleteForeignTab) {
   int tab_node_id_1 = 1;
   int tab_node_id_2 = 2;
   std::set<int> result;
 
   GetTracker()->OnTabNodeSeen(kTag, tab_node_id_1);
   GetTracker()->OnTabNodeSeen(kTag, tab_node_id_2);
 
   GetTracker()->LookupForeignTabNodeIds(kTag, &result);
   EXPECT_EQ(2U, result.size());
   EXPECT_TRUE(result.find(tab_node_id_1) != result.end());
   EXPECT_TRUE(result.find(tab_node_id_2) != result.end());
 
   GetTracker()->DeleteForeignTab(kTag, tab_node_id_1);
   GetTracker()->LookupForeignTabNodeIds(kTag, &result);
   EXPECT_EQ(1U, result.size());
   EXPECT_TRUE(result.find(tab_node_id_2) != result.end());
 
   GetTracker()->DeleteForeignTab(kTag, tab_node_id_2);
   GetTracker()->LookupForeignTabNodeIds(kTag, &result);
   EXPECT_TRUE(result.empty());
+  ASSERT_TRUE(VerifyTabIntegrity(kTag));
 }
 
 TEST_F(SyncedSessionTrackerTest, CleanupLocalTabs) {
   std::set<int> free_node_ids;
   int tab_node_id = TabNodePool::kInvalidTabNodeID;
-  const int kTabNode1 = 1;
-  const int kTabNode2 = 2;
-  const int kTabNode3 = 3;
 
   GetTracker()->SetLocalSessionTag(kTag);
 
   // Start with two restored tab nodes.
   GetTracker()->ReassociateLocalTab(kTabNode1, kTab1);
   GetTracker()->ReassociateLocalTab(kTabNode2, kTab2);
   EXPECT_TRUE(GetTabNodePool()->Empty());
   EXPECT_FALSE(GetTabNodePool()->Full());
   EXPECT_EQ(2U, GetTabNodePool()->Capacity());
 
@@ skipping 32 matching lines @@
   EXPECT_EQ(kTabNode3, tab_node_id);
   EXPECT_TRUE(GetTabNodePool()->Empty());
 
   // Associate with no tabs. All tabs should be freed again, and the pool
   // should now be full.
   GetTracker()->ResetSessionTracking(kTag);
   GetTracker()->CleanupLocalTabs(&free_node_ids);
   EXPECT_TRUE(free_node_ids.empty());
   EXPECT_TRUE(GetTabNodePool()->Full());
   EXPECT_FALSE(GetTabNodePool()->Empty());
+  ASSERT_TRUE(VerifyTabIntegrity(kTag));
 }
 
 TEST_F(SyncedSessionTrackerTest, ReassociateTabMapped) {
   std::set<int> free_node_ids;
 
   // First create the tab normally.
   GetTracker()->SetLocalSessionTag(kTag);
-  EXPECT_FALSE(GetTracker()->IsLocalTabNodeAssociated(kTabNode));
-  GetTracker()->ReassociateLocalTab(kTabNode, kTab1);
-  EXPECT_TRUE(GetTracker()->IsLocalTabNodeAssociated(kTabNode));
+  EXPECT_FALSE(GetTracker()->IsLocalTabNodeAssociated(kTabNode1));
+  GetTracker()->ReassociateLocalTab(kTabNode1, kTab1);
+  ASSERT_TRUE(VerifyTabIntegrity(kTag));
+  EXPECT_TRUE(GetTracker()->IsLocalTabNodeAssociated(kTabNode1));
   EXPECT_TRUE(GetTracker()->IsTabUnmappedForTesting(kTab1));
 
   // Map it to a window with the same tab id as it was created with.
   GetTracker()->ResetSessionTracking(kTag);
   GetTracker()->PutWindowInSession(kTag, kWindow1);
   GetTracker()->PutTabInWindow(kTag, kWindow1, kTab1);
   GetTracker()->CleanupLocalTabs(&free_node_ids);
+  ASSERT_TRUE(VerifyTabIntegrity(kTag));
   EXPECT_FALSE(GetTracker()->IsTabUnmappedForTesting(kTab1));
   SyncedSession* session = GetTracker()->GetSession(kTag);
   ASSERT_EQ(1U, session->windows.size());
   ASSERT_EQ(1U, session->windows[kWindow1]->wrapped_window.tabs.size());
   ASSERT_EQ(GetTracker()->GetTab(kTag, kTab1),
             session->windows[kWindow1]->wrapped_window.tabs[0].get());
 
   // Then reassociate with a new tab id.
-  GetTracker()->ReassociateLocalTab(kTabNode, kTab2);
-  EXPECT_TRUE(GetTracker()->IsLocalTabNodeAssociated(kTabNode));
+  GetTracker()->ReassociateLocalTab(kTabNode1, kTab2);
+  ASSERT_TRUE(VerifyTabIntegrity(kTag));
+  EXPECT_TRUE(GetTracker()->IsLocalTabNodeAssociated(kTabNode1));
   EXPECT_FALSE(GetTracker()->IsTabUnmappedForTesting(kTab2));
   EXPECT_FALSE(GetTracker()->IsTabUnmappedForTesting(kTab1));
 
   // Reset tracking, and put the new tab id into the window.
   GetTracker()->ResetSessionTracking(kTag);
   EXPECT_TRUE(GetTracker()->IsTabUnmappedForTesting(kTab2));
   GetTracker()->PutWindowInSession(kTag, kWindow1);
   GetTracker()->PutTabInWindow(kTag, kWindow1, kTab2);
   GetTracker()->CleanupLocalTabs(&free_node_ids);
+  ASSERT_TRUE(VerifyTabIntegrity(kTag));
   EXPECT_TRUE(free_node_ids.empty());
   EXPECT_FALSE(GetTracker()->IsTabUnmappedForTesting(kTab2));
 
   // Now that it's been mapped, it should be accessible both via the
   // GetSession as well as the GetTab.
   ASSERT_EQ(GetTracker()->GetTab(kTag, kTab2),
             session->windows[kWindow1]->wrapped_window.tabs[0].get());
   ASSERT_EQ(session->tab_node_ids.size(),
-            session->tab_node_ids.count(kTabNode));
+            session->tab_node_ids.count(kTabNode1));
   ASSERT_EQ(1U, GetTabNodePool()->Capacity());
+  ASSERT_TRUE(VerifyTabIntegrity(kTag));
 }
 
 TEST_F(SyncedSessionTrackerTest, ReassociateTabMappedTwice) {
   std::set<int> free_node_ids;
 
   // First create the tab normally.
   GetTracker()->SetLocalSessionTag(kTag);
-  EXPECT_FALSE(GetTracker()->IsLocalTabNodeAssociated(kTabNode));
-  GetTracker()->ReassociateLocalTab(kTabNode, kTab1);
-  EXPECT_TRUE(GetTracker()->IsLocalTabNodeAssociated(kTabNode));
+  EXPECT_FALSE(GetTracker()->IsLocalTabNodeAssociated(kTabNode1));
+  GetTracker()->ReassociateLocalTab(kTabNode1, kTab1);
+  ASSERT_TRUE(VerifyTabIntegrity(kTag));
+  EXPECT_TRUE(GetTracker()->IsLocalTabNodeAssociated(kTabNode1));
   EXPECT_TRUE(GetTracker()->IsTabUnmappedForTesting(kTab1));
 
   // Map it to a window with the same tab id as it was created with.
   GetTracker()->ResetSessionTracking(kTag);
   GetTracker()->PutWindowInSession(kTag, kWindow1);
   GetTracker()->PutTabInWindow(kTag, kWindow1, kTab1);
   GetTracker()->CleanupLocalTabs(&free_node_ids);
+  ASSERT_TRUE(VerifyTabIntegrity(kTag));
   EXPECT_TRUE(free_node_ids.empty());
   EXPECT_FALSE(GetTracker()->IsTabUnmappedForTesting(kTab1));
   SyncedSession* session = GetTracker()->GetSession(kTag);
   ASSERT_EQ(1U, session->windows.size());
   ASSERT_EQ(1U, session->windows[kWindow1]->wrapped_window.tabs.size());
   EXPECT_EQ(GetTracker()->GetTab(kTag, kTab1),
             session->windows[kWindow1]->wrapped_window.tabs[0].get());
 
   // Then reassociate with a new tab id.
-  GetTracker()->ReassociateLocalTab(kTabNode, kTab2);
-  EXPECT_TRUE(GetTracker()->IsLocalTabNodeAssociated(kTabNode));
+  GetTracker()->ReassociateLocalTab(kTabNode1, kTab2);
+  ASSERT_TRUE(VerifyTabIntegrity(kTag));
+  EXPECT_TRUE(GetTracker()->IsLocalTabNodeAssociated(kTabNode1));
   EXPECT_FALSE(GetTracker()->IsTabUnmappedForTesting(kTab2));
   EXPECT_FALSE(GetTracker()->IsTabUnmappedForTesting(kTab1));
 
   // Tab 1 should no longer be associated with any SessionTab object. At this
   // point there's no need to verify it's unmapped state.
   const sessions::SessionTab* tab_ptr = nullptr;
   EXPECT_FALSE(GetTracker()->LookupSessionTab(kTag, kTab1, &tab_ptr));
 
   // Reset tracking and add back both the old tab and the new tab (both of which
   // refer to the same tab node id).
   GetTracker()->ResetSessionTracking(kTag);
   EXPECT_TRUE(GetTracker()->IsTabUnmappedForTesting(kTab2));
   GetTracker()->PutWindowInSession(kTag, kWindow1);
   GetTracker()->PutTabInWindow(kTag, kWindow1, kTab1);
   GetTracker()->PutTabInWindow(kTag, kWindow1, kTab2);
   GetTracker()->CleanupLocalTabs(&free_node_ids);
+  ASSERT_TRUE(VerifyTabIntegrity(kTag));
   EXPECT_TRUE(free_node_ids.empty());
   EXPECT_FALSE(GetTracker()->IsTabUnmappedForTesting(kTab2));
 
   // Now that it's been mapped, it should be accessible both via the
   // GetSession as well as the GetTab.
   EXPECT_EQ(GetTracker()->GetTab(kTag, kTab2),
             session->windows[kWindow1]->wrapped_window.tabs[1].get());
   EXPECT_EQ(session->tab_node_ids.size(),
-            session->tab_node_ids.count(kTabNode));
+            session->tab_node_ids.count(kTabNode1));
   EXPECT_EQ(1U, GetTabNodePool()->Capacity());
 
   // Attempting to access the original tab will create a new SessionTab object.
   EXPECT_NE(GetTracker()->GetTab(kTag, kTab1),
             GetTracker()->GetTab(kTag, kTab2));
   int tab_node_id = -1;
   EXPECT_FALSE(GetTracker()->GetTabNodeFromLocalTabId(kTab1, &tab_node_id));
+  ASSERT_TRUE(VerifyTabIntegrity(kTag));
 }
 
 TEST_F(SyncedSessionTrackerTest, ReassociateTabUnmapped) {
   std::set<int> free_node_ids;
 
   // First create the old tab in an unmapped state.
   GetTracker()->SetLocalSessionTag(kTag);
-  EXPECT_FALSE(GetTracker()->IsLocalTabNodeAssociated(kTabNode));
-  GetTracker()->ReassociateLocalTab(kTabNode, kTab1);
-  EXPECT_TRUE(GetTracker()->IsLocalTabNodeAssociated(kTabNode));
+  EXPECT_FALSE(GetTracker()->IsLocalTabNodeAssociated(kTabNode1));
+  GetTracker()->ReassociateLocalTab(kTabNode1, kTab1);
+  ASSERT_TRUE(VerifyTabIntegrity(kTag));
+  EXPECT_TRUE(GetTracker()->IsLocalTabNodeAssociated(kTabNode1));
   EXPECT_TRUE(GetTracker()->IsTabUnmappedForTesting(kTab1));
 
   // Map it to a window, but reassociated with a new tab id.
   GetTracker()->ResetSessionTracking(kTag);
-  GetTracker()->ReassociateLocalTab(kTabNode, kTab2);
-  EXPECT_TRUE(GetTracker()->IsLocalTabNodeAssociated(kTabNode));
+  GetTracker()->ReassociateLocalTab(kTabNode1, kTab2);
+  ASSERT_TRUE(VerifyTabIntegrity(kTag));
+  EXPECT_TRUE(GetTracker()->IsLocalTabNodeAssociated(kTabNode1));
   EXPECT_TRUE(GetTracker()->IsTabUnmappedForTesting(kTab2));
   EXPECT_FALSE(GetTracker()->IsTabUnmappedForTesting(kTab1));
   GetTracker()->PutWindowInSession(kTag, kWindow1);
   GetTracker()->PutTabInWindow(kTag, kWindow1, kTab2);
   GetTracker()->CleanupLocalTabs(&free_node_ids);
+  ASSERT_TRUE(VerifyTabIntegrity(kTag));
   EXPECT_TRUE(free_node_ids.empty());
   EXPECT_FALSE(GetTracker()->IsTabUnmappedForTesting(kTab2));
 
   // Now that it's been mapped, it should be accessible both via the
   // GetSession as well as GetTab.
   SyncedSession* session = GetTracker()->GetSession(kTag);
   ASSERT_EQ(GetTracker()->GetTab(kTag, kTab2),
             session->windows[kWindow1]->wrapped_window.tabs[0].get());
   ASSERT_EQ(session->tab_node_ids.size(),
-            session->tab_node_ids.count(kTabNode));
+            session->tab_node_ids.count(kTabNode1));
   ASSERT_EQ(1U, GetTabNodePool()->Capacity());
+  ASSERT_TRUE(VerifyTabIntegrity(kTag));
 }
 
-TEST_F(SyncedSessionTrackerTest, ReassociateTabMapMismatch) {
+TEST_F(SyncedSessionTrackerTest, ReassociateTabOldUnmappedNewMapped) {
   std::set<int> free_node_ids;
 
   // First create the old tab in an unmapped state.
   GetTracker()->SetLocalSessionTag(kTag);
-  EXPECT_FALSE(GetTracker()->IsLocalTabNodeAssociated(kTabNode));
-  GetTracker()->ReassociateLocalTab(kTabNode, kTab1);
-  EXPECT_TRUE(GetTracker()->IsLocalTabNodeAssociated(kTabNode));
+  EXPECT_FALSE(GetTracker()->IsLocalTabNodeAssociated(kTabNode1));
+  GetTracker()->ReassociateLocalTab(kTabNode1, kTab1);
+  ASSERT_TRUE(VerifyTabIntegrity(kTag));
+  EXPECT_TRUE(GetTracker()->IsLocalTabNodeAssociated(kTabNode1));
   EXPECT_TRUE(GetTracker()->IsTabUnmappedForTesting(kTab1));
 
   // Map an unseen tab to a window, then reassociate the existing tab to the
   // mapped tab id.
   GetTracker()->ResetSessionTracking(kTag);
-  EXPECT_TRUE(GetTracker()->IsLocalTabNodeAssociated(kTabNode));
+  EXPECT_TRUE(GetTracker()->IsLocalTabNodeAssociated(kTabNode1));
   GetTracker()->PutWindowInSession(kTag, kWindow1);
   GetTracker()->PutTabInWindow(kTag, kWindow1, kTab2);
   GetTracker()->CleanupLocalTabs(&free_node_ids);
+  ASSERT_TRUE(VerifyTabIntegrity(kTag));
   EXPECT_FALSE(GetTracker()->IsTabUnmappedForTesting(kTab1));
   EXPECT_FALSE(GetTracker()->IsTabUnmappedForTesting(kTab2));
-  GetTracker()->ReassociateLocalTab(kTabNode, kTab2);
+  GetTracker()->ReassociateLocalTab(kTabNode1, kTab2);
+  ASSERT_TRUE(VerifyTabIntegrity(kTag));
   EXPECT_TRUE(free_node_ids.empty());
   EXPECT_FALSE(GetTracker()->IsTabUnmappedForTesting(kTab1));
   EXPECT_FALSE(GetTracker()->IsTabUnmappedForTesting(kTab2));
 
   // Now that it's been mapped, it should be accessible both via the
   // GetSession as well as GetTab.
   SyncedSession* session = GetTracker()->GetSession(kTag);
   ASSERT_EQ(GetTracker()->GetTab(kTag, kTab2),
             session->windows[kWindow1]->wrapped_window.tabs[0].get());
   ASSERT_EQ(session->tab_node_ids.size(),
-            session->tab_node_ids.count(kTabNode));
+            session->tab_node_ids.count(kTabNode1));
   ASSERT_EQ(1U, GetTabNodePool()->Capacity());
+  ASSERT_TRUE(VerifyTabIntegrity(kTag));
+}
+
+TEST_F(SyncedSessionTrackerTest, ReassociateTabSameTabId) {
+  std::set<int> free_node_ids;
+
+  // First create the tab normally.
+  GetTracker()->SetLocalSessionTag(kTag);
+  EXPECT_FALSE(GetTracker()->IsLocalTabNodeAssociated(kTabNode1));
+  GetTracker()->ReassociateLocalTab(kTabNode1, kTab1);
+  ASSERT_TRUE(VerifyTabIntegrity(kTag));
+  EXPECT_TRUE(GetTracker()->IsLocalTabNodeAssociated(kTabNode1));
+  EXPECT_TRUE(GetTracker()->IsTabUnmappedForTesting(kTab1));
+
+  // Map it to a window.
+  GetTracker()->ResetSessionTracking(kTag);
+  GetTracker()->PutWindowInSession(kTag, kWindow1);
+  GetTracker()->PutTabInWindow(kTag, kWindow1, kTab1);
+  GetTracker()->CleanupLocalTabs(&free_node_ids);
+  ASSERT_TRUE(VerifyTabIntegrity(kTag));
+  EXPECT_FALSE(GetTracker()->IsTabUnmappedForTesting(kTab1));
+  SyncedSession* session = GetTracker()->GetSession(kTag);
+  ASSERT_EQ(1U, session->windows.size());
+  ASSERT_EQ(1U, session->windows[kWindow1]->wrapped_window.tabs.size());
+  ASSERT_EQ(GetTracker()->GetTab(kTag, kTab1),
+            session->windows[kWindow1]->wrapped_window.tabs[0].get());
+
+  // Reassociate, using the same tab id.
+  GetTracker()->ReassociateLocalTab(kTabNode1, kTab1);
+  ASSERT_TRUE(VerifyTabIntegrity(kTag));
+  EXPECT_TRUE(GetTracker()->IsLocalTabNodeAssociated(kTabNode1));
+  EXPECT_FALSE(GetTracker()->IsTabUnmappedForTesting(kTab1));
+
+  // Reset tracking, and put the tab id back into the same window.
+  GetTracker()->ResetSessionTracking(kTag);
+  EXPECT_TRUE(GetTracker()->IsTabUnmappedForTesting(kTab1));
+  GetTracker()->PutWindowInSession(kTag, kWindow1);
+  GetTracker()->PutTabInWindow(kTag, kWindow1, kTab1);
+  GetTracker()->CleanupLocalTabs(&free_node_ids);
+  ASSERT_TRUE(VerifyTabIntegrity(kTag));
+  EXPECT_TRUE(free_node_ids.empty());
+  EXPECT_FALSE(GetTracker()->IsTabUnmappedForTesting(kTab1));
+
+  // Now that it's been mapped, it should be accessible both via the
+  // GetSession as well as the GetTab.
+  ASSERT_EQ(GetTracker()->GetTab(kTag, kTab1),
+            session->windows[kWindow1]->wrapped_window.tabs[0].get());
+  ASSERT_EQ(session->tab_node_ids.size(),
+            session->tab_node_ids.count(kTabNode1));
+  ASSERT_EQ(1U, GetTabNodePool()->Capacity());
+  ASSERT_TRUE(VerifyTabIntegrity(kTag));
+}
+
+TEST_F(SyncedSessionTrackerTest, ReassociateTabOldMappedNewUnmapped) {
+  std::set<int> free_node_ids;
+
+  // First create an unmapped tab.
+  GetTracker()->SetLocalSessionTag(kTag);
+  EXPECT_FALSE(GetTracker()->IsLocalTabNodeAssociated(kTabNode1));
+  GetTracker()->ReassociateLocalTab(kTabNode1, kTab1);
+  ASSERT_TRUE(VerifyTabIntegrity(kTag));
+  EXPECT_TRUE(GetTracker()->IsLocalTabNodeAssociated(kTabNode1));
+  EXPECT_TRUE(GetTracker()->IsTabUnmappedForTesting(kTab1));
+
+  // Now, map the first one, deleting the second one.
+  GetTracker()->ResetSessionTracking(kTag);
+  GetTracker()->PutWindowInSession(kTag, kWindow1);
+  GetTracker()->PutTabInWindow(kTag, kWindow1, kTab1);
+  GetTracker()->CleanupLocalTabs(&free_node_ids);
+  ASSERT_TRUE(VerifyTabIntegrity(kTag));
+  EXPECT_FALSE(GetTracker()->IsTabUnmappedForTesting(kTab1));
+  SyncedSession* session = GetTracker()->GetSession(kTag);
+  ASSERT_EQ(1U, session->windows.size());
+  ASSERT_EQ(1U, session->windows[kWindow1]->wrapped_window.tabs.size());
+  ASSERT_EQ(GetTracker()->GetTab(kTag, kTab1),
+            session->windows[kWindow1]->wrapped_window.tabs[0].get());
+
+  // Create a second unmapped tab.
+  GetTracker()->ReassociateLocalTab(kTabNode2, kTab2);
+  ASSERT_TRUE(VerifyTabIntegrity(kTag));
+  EXPECT_TRUE(GetTracker()->IsLocalTabNodeAssociated(kTabNode2));
+  EXPECT_TRUE(GetTracker()->IsTabUnmappedForTesting(kTab2));
+
+  // Reassociate the second tab with node of the first tab.
+  GetTracker()->ReassociateLocalTab(kTabNode1, kTab2);
+  ASSERT_TRUE(VerifyTabIntegrity(kTag));
+  EXPECT_TRUE(GetTracker()->IsLocalTabNodeAssociated(kTabNode1));
+  EXPECT_FALSE(GetTracker()->IsLocalTabNodeAssociated(kTabNode2));
+  EXPECT_FALSE(GetTracker()->IsTabUnmappedForTesting(kTab1));
+  EXPECT_FALSE(GetTracker()->IsTabUnmappedForTesting(kTab2));
+
+  // Now map the new one.
+  GetTracker()->ResetSessionTracking(kTag);
+  GetTracker()->PutWindowInSession(kTag, kWindow1);
+  GetTracker()->PutTabInWindow(kTag, kWindow1, kTab2);
+  GetTracker()->CleanupLocalTabs(&free_node_ids);
+  ASSERT_TRUE(VerifyTabIntegrity(kTag));
+  EXPECT_FALSE(GetTracker()->IsTabUnmappedForTesting(kTab1));
+  EXPECT_FALSE(GetTracker()->IsTabUnmappedForTesting(kTab2));
+
+  // Now that it's been mapped, it should be accessible both via the
+  // GetSession as well as the GetTab.
+  ASSERT_EQ(GetTracker()->GetTab(kTag, kTab2),
+            session->windows[kWindow1]->wrapped_window.tabs[0].get());
+  ASSERT_EQ(2U, GetTabNodePool()->Capacity());
+  ASSERT_TRUE(VerifyTabIntegrity(kTag));
 }
 
 }  // namespace sync_sessions