Reland of [Sync] Put session tracker in charge of maintaining local state.
Previously, the session tracker was only updated when local tabs were
available in the TabModel. It was not updated with sync data from a previous
session (and as a result, we had to pass around the restored_data list
at association time in order to handle restoring placeholder tabs).
The session tracker now gets updated at startup of previous local state,
which is then used when reassociating restored tabs. This is a purely
refactoring change that should not introduce user visible changes
(although internally the data is managed in a different way).
To make this happen, InitFromSyncModel now treats local tabs and remote
tabs the same. In addition, the SyncedSessionTracker now has a
ReassociateTab method that can be called to update the tab id of a
SessionTab. To make this work, the TabNodePool has been moved into
the SyncedSessionTracker, and in general data ownership has been
simplified (with quite a few new tests added).
This is all necessary in order to enable preserving tabs from a previous
session when they're not present in the TabModel (which can happen on
Android when a custom tab is opened, but the main tabbed activity is not
loaded).
BUG=639009
Review-Url: https://codereview.chromium.org/2499083004
Cr-Commit-Position: refs/heads/master@{#436786}
diff --git a/components/sync_sessions/synced_session_tracker.cc b/components/sync_sessions/synced_session_tracker.cc
index a74b877c..e797295b 100644
--- a/components/sync_sessions/synced_session_tracker.cc
+++ b/components/sync_sessions/synced_session_tracker.cc
@@ -53,6 +53,8 @@
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;
}
@@ -107,8 +109,9 @@
return true;
}
-void SyncedSessionTracker::LookupTabNodeIds(const std::string& session_tag,
- std::set<int>* tab_node_ids) {
+void SyncedSessionTracker::LookupForeignTabNodeIds(
+ const std::string& session_tag,
+ std::set<int>* tab_node_ids) const {
tab_node_ids->clear();
auto session_iter = synced_session_map_.find(session_tag);
if (session_iter != synced_session_map_.end()) {
@@ -144,7 +147,9 @@
return synced_session_map_[session_tag].get();
}
-bool SyncedSessionTracker::DeleteSession(const std::string& session_tag) {
+bool SyncedSessionTracker::DeleteForeignSession(
+ const std::string& session_tag) {
+ DCHECK_NE(local_session_tag_, session_tag);
unmapped_windows_.erase(session_tag);
unmapped_tabs_.erase(session_tag);
@@ -188,13 +193,14 @@
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::CleanupSession(const std::string& session_tag) {
+void SyncedSessionTracker::CleanupSessionImpl(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();
@@ -236,7 +242,7 @@
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 foreign session,
+ // SessionWindow information of a SessionHeader node for a 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.
//
@@ -246,7 +252,7 @@
// 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);
+ GetTab(session_tag, tab_id);
// The tab should be unmapped.
std::unique_ptr<sessions::SessionTab> tab;
@@ -269,46 +275,18 @@
window_tabs[tab_index] = std::move(tab);
}
-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);
+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::GetTabImpl(
+sessions::SessionTab* SyncedSessionTracker::GetTab(
const std::string& session_tag,
- SessionID::id_type tab_id,
- int tab_node_id) {
+ SessionID::id_type tab_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;
@@ -328,7 +306,6 @@
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)
@@ -339,6 +316,90 @@
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();
@@ -352,6 +413,7 @@
synced_window_map_.clear();
synced_tab_map_.clear();
+ local_tab_pool_.Clear();
local_session_tag_.clear();
}
