Revert of Reland v4 of Session refactor

components/sync_sessions/synced_session_tracker.cc

Index: components/sync_sessions/synced_session_tracker.cc
diff --git a/components/sync_sessions/synced_session_tracker.cc b/components/sync_sessions/synced_session_tracker.cc
index 2653b5371f5f4779a905950d0044e46af44b9882..a74b877c085c11e890af5c51567516596c8d01be 100644
--- a/components/sync_sessions/synced_session_tracker.cc
+++ b/components/sync_sessions/synced_session_tracker.cc
@@ -53,8 +53,6 @@
 
 void SyncedSessionTracker::SetLocalSessionTag(
     const std::string& local_session_tag) {
-  DCHECK(local_session_tag_.empty());
-  DCHECK(!local_session_tag.empty());
   local_session_tag_ = local_session_tag;
 }
 
@@ -92,9 +90,6 @@
     const std::string& tag,
     SessionID::id_type tab_id,
     const sessions::SessionTab** tab) const {
-  if (tab_id == TabNodePool::kInvalidTabID)
-    return false;
-
   DCHECK(tab);
   auto tab_map_iter = synced_tab_map_.find(tag);
   if (tab_map_iter == synced_tab_map_.end()) {
@@ -112,9 +107,8 @@
   return true;
 }
 
-void SyncedSessionTracker::LookupForeignTabNodeIds(
-    const std::string& session_tag,
-    std::set<int>* tab_node_ids) const {
+void SyncedSessionTracker::LookupTabNodeIds(const std::string& session_tag,
+                                            std::set<int>* tab_node_ids) {
   tab_node_ids->clear();
   auto session_iter = synced_session_map_.find(session_tag);
   if (session_iter != synced_session_map_.end()) {
@@ -150,9 +144,7 @@
   return synced_session_map_[session_tag].get();
 }
 
-bool SyncedSessionTracker::DeleteForeignSession(
-    const std::string& session_tag) {
-  DCHECK_NE(local_session_tag_, session_tag);
+bool SyncedSessionTracker::DeleteSession(const std::string& session_tag) {
   unmapped_windows_.erase(session_tag);
   unmapped_tabs_.erase(session_tag);
 
@@ -196,14 +188,13 @@
 
 void SyncedSessionTracker::DeleteForeignTab(const std::string& session_tag,
                                             int tab_node_id) {
-  DCHECK_NE(local_session_tag_, session_tag);
   auto session_iter = synced_session_map_.find(session_tag);
   if (session_iter != synced_session_map_.end()) {
     session_iter->second->tab_node_ids.erase(tab_node_id);
   }
 }
 
-void SyncedSessionTracker::CleanupSessionImpl(const std::string& session_tag) {
+void SyncedSessionTracker::CleanupSession(const std::string& session_tag) {
   for (const auto& window_pair : unmapped_windows_[session_tag])
     synced_window_map_[session_tag].erase(window_pair.first);
   unmapped_windows_[session_tag].clear();
@@ -211,11 +202,6 @@
   for (const auto& tab_pair : unmapped_tabs_[session_tag])
     synced_tab_map_[session_tag].erase(tab_pair.first);
   unmapped_tabs_[session_tag].clear();
-}
-
-bool SyncedSessionTracker::IsTabUnmappedForTesting(SessionID::id_type tab_id) {
-  auto it = unmapped_tabs_[local_session_tag_].find(tab_id);
-  return it != unmapped_tabs_[local_session_tag_].end();
 }
 
 void SyncedSessionTracker::PutWindowInSession(const std::string& session_tag,
@@ -247,19 +233,20 @@
 
 void SyncedSessionTracker::PutTabInWindow(const std::string& session_tag,
                                           SessionID::id_type window_id,
-                                          SessionID::id_type tab_id) {
+                                          SessionID::id_type tab_id,
+                                          size_t tab_index) {
   // We're called here for two reasons. 1) We've received an update to the
-  // SessionWindow information of a SessionHeader node for a session,
+  // SessionWindow information of a SessionHeader node for a foreign session,
   // and 2) The SessionHeader node for our local session changed. In both cases
   // we need to update our tracking state to reflect the change.
   //
   // Because the SessionHeader nodes are separate from the individual tab nodes
   // and we don't store tab_node_ids in the header / SessionWindow specifics,
-  // the tab_node_ids are not always available when processing headers. We know
-  // that we will eventually process (via GetTab) every single tab node in the
-  // system, so we permit ourselves to just call GetTab and ignore the result,
-  // creating a placeholder SessionTab in the process.
-  GetTab(session_tag, tab_id);
+  // the tab_node_ids are not always available when processing headers.
+  // We know that we will eventually process (via GetTab) every single tab node
+  // in the system, so we permit ourselves to use kInvalidTabNodeID here and
+  // rely on the later update to build the mapping (or a restart).
+  GetTabImpl(session_tag, tab_id, TabNodePool::kInvalidTabNodeID);
 
   // The tab should be unmapped.
   std::unique_ptr<sessions::SessionTab> tab;
@@ -268,30 +255,60 @@
     tab = std::move(it->second);
     unmapped_tabs_[session_tag].erase(it);
   }
-  CHECK(tab) << "crbug.com/673618 Attempting to map tab " << tab_id
-             << " multiple times!";
+  DCHECK(tab);
 
   tab->window_id.set_id(window_id);
   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));
-}
-
-void SyncedSessionTracker::OnTabNodeSeen(const std::string& session_tag,
-                                         int tab_node_id) {
-  GetSession(session_tag)->tab_node_ids.insert(tab_node_id);
+  if (window_tabs.size() <= tab_index) {
+    window_tabs.resize(tab_index + 1);
+  }
+  DCHECK(!window_tabs[tab_index]);
+  window_tabs[tab_index] = std::move(tab);
 }
 
 sessions::SessionTab* SyncedSessionTracker::GetTab(
     const std::string& session_tag,
-    SessionID::id_type tab_id) {
-  CHECK_NE(TabNodePool::kInvalidTabNodeID, tab_id) << "crbug.com/673618";
+    SessionID::id_type tab_id,
+    int tab_node_id) {
+  DCHECK_NE(TabNodePool::kInvalidTabNodeID, tab_node_id);
+  return GetTabImpl(session_tag, tab_id, tab_node_id);
+}
+
+sessions::SessionTab* SyncedSessionTracker::GetTabImpl(
+    const std::string& session_tag,
+    SessionID::id_type tab_id,
+    int tab_node_id) {
   sessions::SessionTab* tab_ptr = nullptr;
   auto iter = synced_tab_map_[session_tag].find(tab_id);
   if (iter != synced_tab_map_[session_tag].end()) {
     tab_ptr = iter->second;
+    if (tab_node_id != TabNodePool::kInvalidTabNodeID &&
+        tab_id != TabNodePool::kInvalidTabID) {
+      // TabIDs are not stable across restarts of a client. Consider this
+      // example with two tabs:
+      //
+      // http://a.com  TabID1 --> NodeIDA
+      // http://b.com  TabID2 --> NodeIDB
+      //
+      // After restart, tab ids are reallocated. e.g, one possibility:
+      // http://a.com TabID2 --> NodeIDA
+      // http://b.com TabID1 --> NodeIDB
+      //
+      // If that happend on a remote client, here we will see an update to
+      // TabID1 with tab_node_id changing from NodeIDA to NodeIDB, and TabID2
+      // with tab_node_id changing from NodeIDB to NodeIDA.
+      //
+      // We can also wind up here if we created this tab as an out-of-order
+      // update to the header node for this session before actually associating
+      // the tab itself, so the tab node id wasn't available at the time and
+      // is currently kInvalidTabNodeID.
+      //
+      // In both cases, we can safely throw it into the set of node ids.
+      GetSession(session_tag)->tab_node_ids.insert(tab_node_id);
+    }
 
     if (VLOG_IS_ON(1)) {
       std::string title;
@@ -311,6 +328,7 @@
     tab->tab_id.set_id(tab_id);
     synced_tab_map_[session_tag][tab_id] = tab_ptr;
     unmapped_tabs_[session_tag][tab_id] = std::move(tab);
+    GetSession(session_tag)->tab_node_ids.insert(tab_node_id);
     DVLOG(1) << "Getting "
              << (session_tag == local_session_tag_ ? "local session"
                                                    : session_tag)
@@ -321,99 +339,6 @@
   return tab_ptr;
 }
 
-void SyncedSessionTracker::CleanupForeignSession(
-    const std::string& session_tag) {
-  DCHECK_NE(local_session_tag_, session_tag);
-  CleanupSessionImpl(session_tag);
-}
-
-void SyncedSessionTracker::CleanupLocalTabs(std::set<int>* deleted_node_ids) {
-  DCHECK(!local_session_tag_.empty());
-  for (const auto& tab_pair : unmapped_tabs_[local_session_tag_])
-    local_tab_pool_.FreeTab(tab_pair.first);
-  CleanupSessionImpl(local_session_tag_);
-  local_tab_pool_.CleanupTabNodes(deleted_node_ids);
-  for (int tab_node_id : *deleted_node_ids) {
-    GetSession(local_session_tag_)->tab_node_ids.erase(tab_node_id);
-  }
-}
-
-bool SyncedSessionTracker::GetTabNodeFromLocalTabId(SessionID::id_type tab_id,
-                                                    int* tab_node_id) {
-  DCHECK(!local_session_tag_.empty());
-  // Ensure a placeholder SessionTab is in place, if not already.
-  // Although we don't need a SessionTab to fulfill this request, this forces
-  // the
-  // creation of one if it doesn't already exist. This helps to make sure we're
-  // tracking this |tab_id| if |local_tab_pool_| is, and everyone's data
-  // structures
-  // are kept in sync and as consistent as possible.
-  GetTab(local_session_tag_, tab_id);  // Ignore result.
-
-  bool reused_existing_tab =
-      local_tab_pool_.GetTabNodeForTab(tab_id, tab_node_id);
-  DCHECK_NE(TabNodePool::kInvalidTabNodeID, *tab_node_id);
-  GetSession(local_session_tag_)->tab_node_ids.insert(*tab_node_id);
-  return reused_existing_tab;
-}
-
-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;
-}
-
-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);
-
-  SessionID::id_type old_tab_id =
-      local_tab_pool_.GetTabIdFromTabNodeId(tab_node_id);
-  local_tab_pool_.ReassociateTabNode(tab_node_id, new_tab_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 &&
-      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.
-    synced_tab_map_[local_session_tag_].erase(old_tab_iter);
-  } else {
-    // It's possible a placeholder is already in place for the new tab. If so,
-    // reuse it, otherwise create a new one (which will default to unmapped).
-    tab_ptr = GetTab(local_session_tag_, new_tab_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 &&
-      unmapped_tabs_iter != unmapped_tabs_[local_session_tag_].end()) {
-    std::unique_ptr<sessions::SessionTab> tab =
-        std::move(unmapped_tabs_iter->second);
-    DCHECK_EQ(tab_ptr, tab.get());
-    unmapped_tabs_[local_session_tag_].erase(unmapped_tabs_iter);
-    unmapped_tabs_[local_session_tag_][new_tab_id] = std::move(tab);
-  }
-
-  // Update the tab id.
-  if (old_tab_id != TabNodePool::kInvalidTabID) {
-    DVLOG(1) << "Remapped tab " << old_tab_id << " with node " << tab_node_id
-             << " to tab " << new_tab_id;
-  } else {
-    DVLOG(1) << "Mapped new tab node " << tab_node_id << " to tab "
-             << new_tab_id;
-  }
-  tab_ptr->tab_id.set_id(new_tab_id);
-
-  // Add the tab back into the tab map with the new id.
-  synced_tab_map_[local_session_tag_][new_tab_id] = tab_ptr;
-  GetSession(local_session_tag_)->tab_node_ids.insert(tab_node_id);
-}
-
 void SyncedSessionTracker::Clear() {
   // Cleanup unmapped tabs and windows.
   unmapped_windows_.clear();
@@ -427,7 +352,6 @@
   synced_window_map_.clear();
   synced_tab_map_.clear();
 
-  local_tab_pool_.Clear();
   local_session_tag_.clear();
 }