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

components/sync_sessions/synced_session_tracker.cc

 // Copyright (c) 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 <utility>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
@@ skipping 321 matching lines @@
     DVLOG(1) << "Getting "
              << (session_tag == local_session_tag_ ? "local session"
                                                    : session_tag)
              << "'s new tab " << tab_id << " at " << tab_ptr;
   }
   DCHECK(tab_ptr);
   DCHECK_EQ(tab_ptr->tab_id.id(), tab_id);
   return tab_ptr;
 }
 
+bool SyncedSessionTracker::ReassociateTab(const std::string& session_tag,

[maxbogue, 2016/11/10 06:43:26]

So was this entire operation just never done previously? I'm slightly confused
by that.

[Nicolas Zea, 2016/11/10 18:25:36]

Yeah, previously at startup we would put the tab entities in the tab node pool,
but not add their data into the tracker. We'd only add a tab into the tracker
when it was created locally. And at that point the tab id would never change.

Now that we're loading tabs from old sessions into the tracker, we need this
functionality.

[maxbogue, 2016/11/10 22:27:14]

So this CL is changing functionality? Could you update the description in that
case?

+                                          SessionID::id_type old_tab_id,
+                                          SessionID::id_type new_tab_id) {
+  DCHECK_NE(TabNodePool::kInvalidTabID, old_tab_id);
+  DCHECK_NE(TabNodePool::kInvalidTabID, new_tab_id);
+
+  sessions::SessionTab* tab_ptr = nullptr;
+  auto old_tab_iter = synced_tab_map_[session_tag].find(old_tab_id);
+  if (old_tab_iter == synced_tab_map_[session_tag].end())
+    return false;
+
+  // It's possible a placeholder is already in place for the new tab. If that's
+  // the case, reuse the placeholder SessionTab. Otherwise, reuse the old
+  // SessionTab.
+  auto new_tab_iter = synced_tab_map_[session_tag].find(new_tab_id);
+  if (new_tab_iter != synced_tab_map_[session_tag].end()) {
+    tab_ptr = new_tab_iter->second;
+  } else {
+    tab_ptr = old_tab_iter->second;
+  }
+
+  // If the old tab is unmapped, update the tab id under which it is indexed.
+  auto unmapped_tabs_iter = unmapped_tabs_[session_tag].find(old_tab_id);
+  if (unmapped_tabs_iter != unmapped_tabs_[session_tag].end()) {
+    std::unique_ptr<sessions::SessionTab> tab =
+        std::move(unmapped_tabs_iter->second);
+    unmapped_tabs_[session_tag].erase(unmapped_tabs_iter);
+    unmapped_tabs_[session_tag][new_tab_id] = std::move(tab);
+  }
+
+  // Update the tab id.
+  DVLOG(1) << "Remapped tab " << old_tab_id << " to tab " << new_tab_id;
+  tab_ptr->tab_id.set_id(new_tab_id);
+
+  // Remove the tab from the synced tab map under the old id.
+  synced_tab_map_[session_tag].erase(old_tab_iter);
+
+  // Add the tab back into the tab map with the new id.
+  synced_tab_map_[session_tag][new_tab_id] = tab_ptr;
+  return true;
+}
+
 void SyncedSessionTracker::Clear() {
   // Cleanup unmapped tabs and windows.
   unmapped_windows_.clear();
   unmapped_tabs_.clear();
 
   // Delete SyncedSession objects (which also deletes all their windows/tabs).
   synced_session_map_.clear();
 
   // Get rid of our convenience maps (does not delete the actual Window/Tabs
   // themselves; they should have all been deleted above).
   synced_window_map_.clear();
   synced_tab_map_.clear();
 
   local_session_tag_.clear();
 }
 
 }  // namespace sync_sessions