[Sync] Fix namespaces for the sync_sessions component.

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>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/macros.h"
 #include "components/sessions/core/session_id.h"
 #include "components/sessions/core/session_types.h"
 #include "components/sync_sessions/synced_session.h"
 #include "components/sync_sessions/tab_node_pool.h"
 
 namespace sync_sessions {
+
 class SyncSessionsClient;
-}
-
-namespace browser_sync {
 
 // Class to manage synced sessions. The tracker will own all SyncedSession
 // and SyncedSessionTab objects it creates, and deletes them appropriately on
 // destruction.
 // Note: SyncedSession objects are created for all synced sessions, including
 // the local session (whose tag we maintain separately).
 class SyncedSessionTracker {
  public:
   // Different ways to lookup/filter tabs.
   enum SessionLookup {
     RAW,         // Return all foreign sessions.
     PRESENTABLE  // Have one window with at least one tab with syncable content.
   };
 
-  explicit SyncedSessionTracker(
-      sync_sessions::SyncSessionsClient* sessions_client);
+  explicit SyncedSessionTracker(SyncSessionsClient* sessions_client);
   ~SyncedSessionTracker();
 
   // We track and distinguish the local session from foreign sessions.
   void SetLocalSessionTag(const std::string& local_session_tag);
 
   // Fill a preallocated vector with all foreign sessions we're tracking (skips
   // the local session object). SyncedSession ownership remains within the
   // SyncedSessionTracker. Lookup parameter is used to decide which foreign tabs
   // should be include.
   // Returns true if we had foreign sessions to fill it with, false otherwise.
-  bool LookupAllForeignSessions(
-      std::vector<const sync_driver::SyncedSession*>* sessions,
-      SessionLookup lookup) const;
+  bool LookupAllForeignSessions(std::vector<const SyncedSession*>* sessions,
+                                SessionLookup lookup) const;
 
   // Attempts to look up the session windows associatd with the session given
   // by |session_tag|. Ownership Of SessionWindows stays within the
   // SyncedSessionTracker.
   // If lookup succeeds:
   // - Fills windows with the SessionWindow pointers, returns true.
   // Else
   // - Returns false.
   bool LookupSessionWindows(
       const std::string& session_tag,
       std::vector<const sessions::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 sessions::SessionTab** tab) const;
 
   // Allows retrieval of existing data for the local session. Unlike GetSession
   // this won't create-if-not-present.
-  bool LookupLocalSession(const sync_driver::SyncedSession** output) const;
+  bool LookupLocalSession(const SyncedSession** output) 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.
-  sync_driver::SyncedSession* GetSession(const std::string& session_tag);
+  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);
 
   // Resets the tracking information for the session specified by |session_tag|.
   // This involves clearing all the windows and tabs from the session, while
   // keeping pointers saved in the synced_window_map_ and synced_tab_map_.
   // Once reset, all calls to PutWindowInSession and PutTabInWindow will denote
   // that the requested windows and tabs are owned (by setting the boolean
@@ skipping 112 matching lines @@
     SessionWindowWrapper() : window_ptr(NULL), owned(false) {}
     SessionWindowWrapper(sessions::SessionWindow* window_ptr, OwnedState owned)
         : window_ptr(window_ptr), owned(owned == IS_OWNED) {}
     sessions::SessionWindow* window_ptr;
     bool owned;
   };
   typedef std::map<SessionID::id_type, SessionWindowWrapper>
       IDToSessionWindowMap;
   typedef std::map<std::string, IDToSessionWindowMap> SyncedWindowMap;
 
-  typedef std::map<std::string, sync_driver::SyncedSession*> SyncedSessionMap;
+  typedef std::map<std::string, SyncedSession*> SyncedSessionMap;
 
   // Helper methods for deleting SessionWindows and SessionTabs without owners.
   bool DeleteOldSessionWindowIfNecessary(
       const SessionWindowWrapper& window_wrapper);
   bool DeleteOldSessionTabIfNecessary(const SessionTabWrapper& tab_wrapper);
 
   // 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.
-  sync_sessions::SyncSessionsClient* const sessions_client_;
+  SyncSessionsClient* const sessions_client_;
 
   // Per client mapping of tab id's to their SessionTab objects.
   // Key: session tag.
   // Value: Tab id to SessionTabWrapper map.
   SyncedTabMap synced_tab_map_;
 
   // Per client mapping of the window id's to their SessionWindow objects.
   // Key: session_tag
   // Value: Window id to SessionWindowWrapper map.
   SyncedWindowMap synced_window_map_;
 
   // 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<sessions::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
+}  // namespace sync_sessions
 
 #endif  // COMPONENTS_SYNC_SESSIONS_SYNCED_SESSION_TRACKER_H_