Revamp TabNavigation class

chrome/browser/sync/glue/synced_session_tracker.h

 // 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.
 
 #ifndef CHROME_BROWSER_SYNC_GLUE_SYNCED_SESSION_TRACKER_H_
 #define CHROME_BROWSER_SYNC_GLUE_SYNCED_SESSION_TRACKER_H_
 
 #include <map>
 #include <set>
 #include <string>
@@ skipping 38 matching lines @@
                             std::vector<const SessionWindow*>* windows) const;
 
   // Attempts to look up the tab associated with the given tag and tab id.
   // Ownership of the SessionTab remains within the SyncedSessionTracker.
   // If lookup succeeds:
   // - Sets tab to point to the SessionTab, and returns true.
   // Else
   // - Returns false, tab is set to NULL.
   bool LookupSessionTab(const std::string& session_tag,
                         SessionID::id_type tab_id,
-                        const SyncedSessionTab** tab) const;
+                        const SessionTab** tab) const;
 
   // Returns a pointer to the SyncedSession object associated with
   // |session_tag|.  If none exists, creates one. Ownership of the
   // SyncedSession remains within the SyncedSessionTracker.
   SyncedSession* GetSession(const std::string& session_tag);
 
   // Deletes the session associated with |session_tag| if it exists.
   // Returns true if the session existed and was deleted, false otherwise.
   bool DeleteSession(const std::string& session_tag);
 
@@ skipping 26 matching lines @@
   // Note: GetSession(..) must have already been called with |session_tag| to
   // ensure we having mapping information for this session.
   void PutTabInWindow(const std::string& session_tag,
                       SessionID::id_type window_id,
                       SessionID::id_type tab_id,
                       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.
-  SyncedSessionTab* GetTab(const std::string& session_tag,
-                           SessionID::id_type tab_id);
+  SessionTab* GetTab(const std::string& session_tag,
+                     SessionID::id_type tab_id);
 
   // Free the memory for all dynamically allocated objects and clear the
   // tracking structures.
   void Clear();
 
   bool Empty() const {
     return synced_tab_map_.empty() && synced_session_map_.empty();
   }
 
   // Includes both foreign sessions and the local session.
@@ skipping 13 matching lines @@
  private:
   // Datatypes for accessing session data. Neither of the *Wrappers actually
   // have ownership of the Windows/Tabs, they just provide id-based access to
   // them. The ownership remains within its containing session (for windows and
   // mapped tabs, unmapped tabs are owned by the unmapped_tabs_ container).
   // Note, we pair pointers with bools so that we can track what is owned and
   // what can be deleted (see ResetSessionTracking(..) and CleanupSession(..)
   // above).
   struct SessionTabWrapper {
     SessionTabWrapper() : tab_ptr(NULL), owned(false) {}
-    SessionTabWrapper(SyncedSessionTab* tab_ptr, bool owned)
+    SessionTabWrapper(SessionTab* tab_ptr, bool owned)
         : tab_ptr(tab_ptr),
           owned(owned) {}
-    SyncedSessionTab* tab_ptr;
+    SessionTab* tab_ptr;
     bool owned;
   };
   typedef std::map<SessionID::id_type, SessionTabWrapper> IDToSessionTabMap;
   typedef std::map<std::string, IDToSessionTabMap> SyncedTabMap;
 
   struct SessionWindowWrapper {
     SessionWindowWrapper() : window_ptr(NULL), owned(false) {}
     SessionWindowWrapper(SessionWindow* window_ptr, bool owned)
         : window_ptr(window_ptr),
           owned(owned) {}
@@ skipping 22 matching lines @@
 
   // Per client mapping synced session objects.
   // Key: session tag.
   // Value: SyncedSession object pointer.
   SyncedSessionMap synced_session_map_;
 
   // The set of tabs that we have seen, and created SessionTab objects for, but
   // have not yet mapped to SyncedSessions. These are temporarily orphaned
   // tabs, and won't be deleted if we delete synced_session_map_, but are still
   // owned by the SyncedSessionTracker itself (and deleted on Clear()).
-  std::set<SyncedSessionTab*> unmapped_tabs_;
+  std::set<SessionTab*> unmapped_tabs_;
 
   // 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 browser_sync
 
 #endif  // CHROME_BROWSER_SYNC_GLUE_SYNCED_SESSION_TRACKER_H_