[Sync] Fix namespaces for the sync_sessions component.

components/sync_sessions/synced_session_tracker.cc

 // 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.
 
 #include "components/sync_sessions/synced_session_tracker.h"
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/sync_sessions/sync_sessions_client.h"
 
-namespace browser_sync {
+namespace sync_sessions {
 
 namespace {
 
 // Helper for iterating through all tabs within a window, and all navigations
 // within a tab, to find if there's a valid syncable url.
-bool ShouldSyncSessionWindow(sync_sessions::SyncSessionsClient* sessions_client,
+bool ShouldSyncSessionWindow(SyncSessionsClient* sessions_client,
                              const sessions::SessionWindow& window) {
   for (sessions::SessionTab* const tab : window.tabs) {
     for (const sessions::SerializedNavigationEntry& navigation :
          tab->navigations) {
       if (sessions_client->ShouldSyncURL(navigation.virtual_url())) {
         return true;
       }
     }
   }
   return false;
 }
 
 // Presentable means |foreign_session| must have syncable content.
-bool IsPresentable(sync_sessions::SyncSessionsClient* sessions_client,
-                   sync_driver::SyncedSession* foreign_session) {
-  for (sync_driver::SyncedSession::SyncedWindowMap::const_iterator iter =
+bool IsPresentable(SyncSessionsClient* sessions_client,
+                   SyncedSession* foreign_session) {
+  for (SyncedSession::SyncedWindowMap::const_iterator iter =
            foreign_session->windows.begin();
        iter != foreign_session->windows.end(); ++iter) {
     if (ShouldSyncSessionWindow(sessions_client, *(iter->second))) {
       return true;
     }
   }
   return false;
 }
 
 }  // namespace
 
-SyncedSessionTracker::SyncedSessionTracker(
-    sync_sessions::SyncSessionsClient* sessions_client)
+SyncedSessionTracker::SyncedSessionTracker(SyncSessionsClient* sessions_client)
     : sessions_client_(sessions_client) {}
 
 SyncedSessionTracker::~SyncedSessionTracker() {
   Clear();
 }
 
 void SyncedSessionTracker::SetLocalSessionTag(
     const std::string& local_session_tag) {
   local_session_tag_ = local_session_tag;
 }
 
 bool SyncedSessionTracker::LookupAllForeignSessions(
-    std::vector<const sync_driver::SyncedSession*>* sessions,
+    std::vector<const SyncedSession*>* sessions,
     SessionLookup lookup) const {
   DCHECK(sessions);
   sessions->clear();
   for (SyncedSessionMap::const_iterator i = synced_session_map_.begin();
        i != synced_session_map_.end(); ++i) {
-    sync_driver::SyncedSession* foreign_session = i->second;
+    SyncedSession* foreign_session = i->second;
     if (i->first != local_session_tag_ &&
         (lookup == RAW || IsPresentable(sessions_client_, foreign_session))) {
       sessions->push_back(foreign_session);
     }
   }
   return !sessions->empty();
 }
 
 bool SyncedSessionTracker::LookupSessionWindows(
     const std::string& session_tag,
     std::vector<const sessions::SessionWindow*>* windows) const {
   DCHECK(windows);
   windows->clear();
   SyncedSessionMap::const_iterator iter = synced_session_map_.find(session_tag);
   if (iter == synced_session_map_.end())
     return false;
   windows->clear();
-  for (sync_driver::SyncedSession::SyncedWindowMap::const_iterator window_iter =
+  for (SyncedSession::SyncedWindowMap::const_iterator window_iter =
            iter->second->windows.begin();
        window_iter != iter->second->windows.end(); ++window_iter) {
     windows->push_back(window_iter->second);
   }
   return true;
 }
 
 bool SyncedSessionTracker::LookupSessionTab(
     const std::string& tag,
     SessionID::id_type tab_id,
@@ skipping 23 matching lines @@
       synced_session_map_.find(session_tag);
   if (session_iter != synced_session_map_.end()) {
     tab_node_ids->insert(session_iter->second->tab_node_ids.begin(),
                          session_iter->second->tab_node_ids.end());
   }
   // Incase an invalid node id was included, remove it.
   tab_node_ids->erase(TabNodePool::kInvalidTabNodeID);
 }
 
 bool SyncedSessionTracker::LookupLocalSession(
-    const sync_driver::SyncedSession** output) const {
+    const SyncedSession** output) const {
   SyncedSessionMap::const_iterator it =
       synced_session_map_.find(local_session_tag_);
   if (it != synced_session_map_.end()) {
     *output = it->second;
     return true;
   }
   return false;
 }
 
-sync_driver::SyncedSession* SyncedSessionTracker::GetSession(
+SyncedSession* SyncedSessionTracker::GetSession(
     const std::string& session_tag) {
-  sync_driver::SyncedSession* synced_session = NULL;
+  SyncedSession* synced_session = NULL;
   if (synced_session_map_.find(session_tag) != synced_session_map_.end()) {
     synced_session = synced_session_map_[session_tag];
   } else {
-    synced_session = new sync_driver::SyncedSession;
+    synced_session = new SyncedSession;
     DVLOG(1) << "Creating new session with tag " << session_tag << " at "
              << synced_session;
     synced_session->session_tag = session_tag;
     synced_session_map_[session_tag] = synced_session;
   }
   DCHECK(synced_session);
   return synced_session;
 }
 
 bool SyncedSessionTracker::DeleteSession(const std::string& session_tag) {
   // Cleanup first, which will take care of orphaned SessionTab and
   // SessionWindow objects. The SyncedSession destructor will only delete things
   // that it is currently the parent of.
   CleanupSession(session_tag);
 
   bool header_existed = false;
   SyncedSessionMap::iterator iter = synced_session_map_.find(session_tag);
   if (iter != synced_session_map_.end()) {
-    sync_driver::SyncedSession* session = iter->second;
+    SyncedSession* session = iter->second;
     // An implicitly created session that has children tabs but no header node
     // will have never had the device_type changed from unset.
-    header_existed =
-        session->device_type != sync_driver::SyncedSession::TYPE_UNSET;
+    header_existed = session->device_type != SyncedSession::TYPE_UNSET;
     synced_session_map_.erase(iter);
     // SyncedSession's destructor will trigger deletion of windows which will in
     // turn trigger the deletion of tabs. This doesn't affect wrappers.
     delete session;
   }
 
   // These two erase(...) calls only affect the wrappers.
   synced_window_map_.erase(session_tag);
   synced_tab_map_.erase(session_tag);
 
@@ skipping 258 matching lines @@
   // a SyncedSession object.
   base::STLDeleteElements(&unmapped_tabs_);
 
   // Get rid of our Window/Tab maps (does not delete the actual Window/Tabs
   // themselves; they should have all been deleted above).
   synced_window_map_.clear();
   synced_tab_map_.clear();
   local_session_tag_.clear();
 }
 
-}  // namespace browser_sync
+}  // namespace sync_sessions