Revert "Reland of [Sync] Put session tracker in charge of maintaining local state."

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 67c075c8b3ca6edc5672728894340826e1e1586b..a74b877c085c11e890af5c51567516596c8d01be 100644
--- a/components/sync_sessions/synced_session_tracker.cc
+++ b/components/sync_sessions/synced_session_tracker.cc
@@ -53,8 +53,6 @@ SyncedSessionTracker::~SyncedSessionTracker() {
 
 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;
 }
 
@@ -109,9 +107,8 @@ bool SyncedSessionTracker::LookupSessionTab(
   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()) {
@@ -147,9 +144,7 @@ SyncedSession* SyncedSessionTracker::GetSession(
   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);
 
@@ -193,14 +188,13 @@ void SyncedSessionTracker::ResetSessionTracking(
 
 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();
@@ -242,7 +236,7 @@ void SyncedSessionTracker::PutTabInWindow(const std::string& session_tag,
                                           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.
   //
@@ -252,7 +246,7 @@ void SyncedSessionTracker::PutTabInWindow(const std::string& session_tag,
   // 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).
-  GetTab(session_tag, tab_id);
+  GetTabImpl(session_tag, tab_id, TabNodePool::kInvalidTabNodeID);
 
   // The tab should be unmapped.
   std::unique_ptr<sessions::SessionTab> tab;
@@ -261,11 +255,7 @@ void SyncedSessionTracker::PutTabInWindow(const std::string& session_tag,
     tab = std::move(it->second);
     unmapped_tabs_[session_tag].erase(it);
   }
-  if (!tab) {
-    LOG(ERROR) << "crbug.com/665196 Attempting to map tab " << tab_id
-               << " multiple times!";
-    return;
-  }
+  DCHECK(tab);
 
   tab->window_id.set_id(window_id);
   DVLOG(1) << "  - tab " << tab_id << " added to window " << window_id;
@@ -279,18 +269,46 @@ void SyncedSessionTracker::PutTabInWindow(const std::string& session_tag,
   window_tabs[tab_index] = 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);
+sessions::SessionTab* SyncedSessionTracker::GetTab(
+    const std::string& session_tag,
+    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::GetTab(
+sessions::SessionTab* SyncedSessionTracker::GetTabImpl(
     const std::string& session_tag,
-    SessionID::id_type tab_id) {
+    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;
@@ -310,6 +328,7 @@ sessions::SessionTab* SyncedSessionTracker::GetTab(
     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)
@@ -320,90 +339,6 @@ sessions::SessionTab* SyncedSessionTracker::GetTab(
   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::GetTabNodeForLocalTab(int 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;
-}
-
-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_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();
@@ -417,7 +352,6 @@ void SyncedSessionTracker::Clear() {
   synced_window_map_.clear();
   synced_tab_map_.clear();
 
-  local_tab_pool_.Clear();
   local_session_tag_.clear();
 }