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

components/sync_sessions/synced_session_tracker.h

 // 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.
 
 #ifndef COMPONENTS_SYNC_SESSIONS_SYNCED_SESSION_TRACKER_H_
 #define COMPONENTS_SYNC_SESSIONS_SYNCED_SESSION_TRACKER_H_
 
 #include <stddef.h>
 
 #include <map>
@@ skipping 115 matching lines @@
                       size_t tab_index);
 
   // Returns a pointer to the SessionTab object associated with |tab_id| for
   // the session specified with |session_tag|. If none exists, creates one.
   // Ownership of the SessionTab remains within the SyncedSessionTracker.
   // |tab_node_id| must be a valid node id for the node backing this tab.
   sessions::SessionTab* GetTab(const std::string& session_tag,
                                SessionID::id_type tab_id,
                                int tab_node_id);
 
+  // Reassociated the tab denoted by |old_tab_id| with a new tab id.
+  // This is useful on restart when sync needs to reassociate tabs from a
+  // previous session with newly restored tabs (and can be used in conjunction
+  // with PutTabInWindow).
+  // Returns whether the reassociation succeeded.
+  bool ReassociateTab(const std::string& session_tag,
+                      SessionID::id_type old_tab_id,
+                      SessionID::id_type new_tab_id);
+
   // Fills |tab_node_ids| with the tab node ids (see GetTab) for all the tabs*
   // associated with the session having tag |session_tag|.
   void LookupTabNodeIds(const std::string& session_tag,
                         std::set<int>* tab_node_ids);
 
   // Free the memory for all dynamically allocated objects and clear the
   // tracking structures.
   void Clear();
 
   bool Empty() const {
@@ skipping 15 matching lines @@
 
  private:
   // Implementation for GetTab(...) above, permits invalid tab_node_id.
   sessions::SessionTab* GetTabImpl(const std::string& session_tag,
                                    SessionID::id_type tab_id,
                                    int tab_node_id);
 
   // The client of the sync sessions datatype.
   SyncSessionsClient* const sessions_client_;
 
-  // The mapping of tab/window ids to their SessionTab/SessionWindow objects.
+  // The mapping of tab/window to their SessionTab/SessionWindow objects.
   // The SessionTab/SessionWindow objects referred to may be owned either by the
   // session in the |synced_session_map_| or be temporarily unmapped and live in
   // the |unmapped_tabs_|/|unmapped_windows_| collections.
   //
-  // Map: session tag -> (tab/window id -> SessionTab*/SessionWindow*)
+  // Map: session tag -> (tab/window -> SessionTab*/SessionWindow*)
   std::map<std::string, std::map<SessionID::id_type, sessions::SessionTab*>>
       synced_tab_map_;
   std::map<std::string, std::map<SessionID::id_type, sessions::SessionWindow*>>
       synced_window_map_;
 
   // The collection that owns the SyncedSessions, and transitively, all of the
   // windows and tabs they contain.
   //
   // Map: session tag -> owned SyncedSession
   std::map<std::string, std::unique_ptr<SyncedSession>> synced_session_map_;
@@ skipping 15 matching lines @@
   // The tag for this machine's local session, so we can distinguish the foreign
   // sessions.
   std::string local_session_tag_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncedSessionTracker);
 };
 
 }  // namespace sync_sessions
 
 #endif  // COMPONENTS_SYNC_SESSIONS_SYNCED_SESSION_TRACKER_H_