[Sync] Fix namespaces for the sync_sessions component.

components/sync_sessions/sessions_sync_manager.h

 // Copyright 2014 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_SESSIONS_SYNC_MANAGER_H_
 #define COMPONENTS_SYNC_SESSIONS_SESSIONS_SYNC_MANAGER_H_
 
 #include <stddef.h>
 
 #include <map>
@@ skipping 34 matching lines @@
 class SessionSpecifics;
 class SessionTab;
 class SessionWindow;
 class TabNavigation;
 }  // namespace sync_pb
 
 namespace extensions {
 class ExtensionSessionsTest;
 }  // namespace extensions
 
-namespace browser_sync {
+namespace sync_sessions {
 
 class SyncedTabDelegate;
 class SyncedWindowDelegatesGetter;
 
 // Contains all logic for associating the Chrome sessions model and
 // the sync sessions model.
 class SessionsSyncManager : public syncer::SyncableService,
-                            public sync_driver::OpenTabsUIDelegate,
+                            public OpenTabsUIDelegate,
                             public LocalSessionEventHandler {
  public:
-  SessionsSyncManager(sync_sessions::SyncSessionsClient* sessions_client,
+  SessionsSyncManager(SyncSessionsClient* sessions_client,
                       sync_driver::SyncPrefs* sync_prefs,
                       sync_driver::LocalDeviceInfoProvider* local_device,
                       std::unique_ptr<LocalSessionEventRouter> router,
                       const base::Closure& sessions_updated_callback,
                       const base::Closure& datatype_refresh_callback);
   ~SessionsSyncManager() override;
 
   // syncer::SyncableService implementation.
   syncer::SyncMergeResult MergeDataAndStartSyncing(
       syncer::ModelType type,
       const syncer::SyncDataList& initial_sync_data,
       std::unique_ptr<syncer::SyncChangeProcessor> sync_processor,
       std::unique_ptr<syncer::SyncErrorFactory> error_handler) override;
   void StopSyncing(syncer::ModelType type) override;
   syncer::SyncDataList GetAllSyncData(syncer::ModelType type) const override;
   syncer::SyncError ProcessSyncChanges(
       const tracked_objects::Location& from_here,
       const syncer::SyncChangeList& change_list) override;
 
   // OpenTabsUIDelegate implementation.
   bool GetSyncedFaviconForPageURL(
       const std::string& pageurl,
       scoped_refptr<base::RefCountedMemory>* favicon_png) const override;
   bool GetAllForeignSessions(
-      std::vector<const sync_driver::SyncedSession*>* sessions) override;
+      std::vector<const SyncedSession*>* sessions) override;
   bool GetForeignSession(
       const std::string& tag,
       std::vector<const sessions::SessionWindow*>* windows) override;
   bool GetForeignTab(const std::string& tag,
                      const SessionID::id_type tab_id,
                      const sessions::SessionTab** tab) override;
   bool GetForeignSessionTabs(
       const std::string& tag,
       std::vector<const sessions::SessionTab*>* tabs) override;
   void DeleteForeignSession(const std::string& tag) override;
-  bool GetLocalSession(
-      const sync_driver::SyncedSession** local_session) override;
+  bool GetLocalSession(const SyncedSession** local_session) override;
 
   // LocalSessionEventHandler implementation.
   void OnLocalTabModified(SyncedTabDelegate* modified_tab) override;
   void OnFaviconsChanged(const std::set<GURL>& page_urls,
                          const GURL& icon_url) override;
 
   // Returns the tag used to uniquely identify this machine's session in the
   // sync model.
   const std::string& current_machine_tag() const {
     DCHECK(!current_machine_tag_.empty());
@@ skipping 110 matching lines @@
   // that exists in the caller's context. This function will append necessary
   // changes for processing later.
   void DeleteForeignSessionInternal(const std::string& tag,
                                     syncer::SyncChangeList* change_output);
 
   // Used to populate a session header from the session specifics header
   // provided.
   static void PopulateSessionHeaderFromSpecifics(
       const sync_pb::SessionHeader& header_specifics,
       base::Time mtime,
-      sync_driver::SyncedSession* session_header);
+      SyncedSession* session_header);
 
   // Builds |session_window| from the session specifics window
   // provided and updates the SessionTracker with foreign session data created.
   void BuildSyncedSessionFromSpecifics(const std::string& session_tag,
                                        const sync_pb::SessionWindow& specifics,
                                        base::Time mtime,
                                        sessions::SessionWindow* session_window);
 
   // Resync local window information. Updates the local sessions header node
   // with the status of open windows and the order of tabs they contain. Should
@@ skipping 72 matching lines @@
   // specifics is the model type, ie us. We need to generate the tag because it
   // is not passed over the wire for remote data. The use case this function was
   // created for is detecting bad tag hashes from remote data, see
   // crbug.com/604657.
   static std::string TagHashFromSpecifics(
       const sync_pb::SessionSpecifics& specifics);
 
   SyncedWindowDelegatesGetter* synced_window_delegates_getter() const;
 
   // The client of this sync sessions datatype.
-  sync_sessions::SyncSessionsClient* const sessions_client_;
+  SyncSessionsClient* const sessions_client_;
 
   // Mapping of current open (local) tabs to their sync identifiers.
   TabLinksMap local_tab_map_;
 
   SyncedSessionTracker session_tracker_;
   FaviconCache favicon_cache_;
 
   // Pool of used/available sync nodes associated with local tabs.
   TabNodePool local_tab_pool_;
 
@@ skipping 35 matching lines @@
 
   // Callback to inform interested observer that new sessions data has arrived.
   base::Closure sessions_updated_callback_;
 
   // Callback to inform sync that a sync data refresh is requested.
   base::Closure datatype_refresh_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(SessionsSyncManager);
 };
 
-}  // namespace browser_sync
+}  // namespace sync_sessions
 
 #endif  // COMPONENTS_SYNC_SESSIONS_SESSIONS_SYNC_MANAGER_H_