[Sync] Fix namespaces for the sync_sessions component.

components/sync_sessions/sessions_sync_manager.cc

 // 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.
 
 #include "components/sync_sessions/sessions_sync_manager.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/metrics/field_trial.h"
@@ skipping 10 matching lines @@
 #include "components/sync_sessions/synced_window_delegate.h"
 #include "components/sync_sessions/synced_window_delegates_getter.h"
 #include "components/variations/variations_associated_data.h"
 
 using sessions::SerializedNavigationEntry;
 using sync_driver::DeviceInfo;
 using sync_driver::LocalDeviceInfoProvider;
 using syncer::SyncChange;
 using syncer::SyncData;
 
-namespace browser_sync {
+namespace sync_sessions {
 
 namespace {
 
 // Maximum number of favicons to sync.
 // TODO(zea): pull this from the server.
 const int kMaxSyncFavicons = 200;
 
 // The maximum number of navigations in each direction we care to sync.
 const int kMaxSyncNavigationCount = 6;
 
 // The URL at which the set of synced tabs is displayed. We treat it differently
 // from all other URL's as accessing it triggers a sync refresh of Sessions.
 const char kNTPOpenTabSyncURL[] = "chrome://newtab/#open_tabs";
 
 // Default number of days without activity after which a session is considered
 // stale and becomes a candidate for garbage collection.
 const int kDefaultStaleSessionThresholdDays = 14;  // 2 weeks.
 
 // Comparator function for use with std::sort that will sort tabs by
 // descending timestamp (i.e., most recent first).
 bool TabsRecencyComparator(const sessions::SessionTab* t1,
                            const sessions::SessionTab* t2) {
   return t1->timestamp > t2->timestamp;
 }
 
 // Comparator function for use with std::sort that will sort sessions by
 // descending modified_time (i.e., most recent first).
-bool SessionsRecencyComparator(const sync_driver::SyncedSession* s1,
-                               const sync_driver::SyncedSession* s2) {
+bool SessionsRecencyComparator(const SyncedSession* s1,
+                               const SyncedSession* s2) {
   return s1->modified_time > s2->modified_time;
 }
 
 std::string TagFromSpecifics(const sync_pb::SessionSpecifics& specifics) {
   if (specifics.has_header()) {
     return specifics.session_tag();
   } else if (specifics.has_tab()) {
     return TabNodePool::TabIdToTag(specifics.session_tag(),
                                    specifics.tab_node_id());
   } else {
     return std::string();
   }
 }
 
 }  // namespace
 
 // |local_device| is owned by ProfileSyncService, its lifetime exceeds
 // lifetime of SessionSyncManager.
 SessionsSyncManager::SessionsSyncManager(
-    sync_sessions::SyncSessionsClient* sessions_client,
+    SyncSessionsClient* sessions_client,
     sync_driver::SyncPrefs* sync_prefs,
     LocalDeviceInfoProvider* local_device,
     std::unique_ptr<LocalSessionEventRouter> router,
     const base::Closure& sessions_updated_callback,
     const base::Closure& datatype_refresh_callback)
     : sessions_client_(sessions_client),
       session_tracker_(sessions_client),
       favicon_cache_(sessions_client->GetFaviconService(),
                      sessions_client->GetHistoryService(),
                      kMaxSyncFavicons),
@@ skipping 89 matching lines @@
 }
 
 void SessionsSyncManager::AssociateWindows(
     ReloadTabsOption option,
     const syncer::SyncDataList& restored_tabs,
     syncer::SyncChangeList* change_output) {
   const std::string local_tag = current_machine_tag();
   sync_pb::SessionSpecifics specifics;
   specifics.set_session_tag(local_tag);
   sync_pb::SessionHeader* header_s = specifics.mutable_header();
-  sync_driver::SyncedSession* current_session =
-      session_tracker_.GetSession(local_tag);
+  SyncedSession* current_session = session_tracker_.GetSession(local_tag);
   current_session->modified_time = base::Time::Now();
   header_s->set_client_name(current_session_name_);
   // SessionDataTypeController ensures that the local device info
   // is available before activating this datatype.
   DCHECK(local_device_);
   const DeviceInfo* local_device_info = local_device_->GetLocalDeviceInfo();
   header_s->set_device_type(local_device_info->device_type());
 
   session_tracker_.ResetSessionTracking(local_tag);
   std::set<const SyncedWindowDelegate*> windows =
@@ skipping 241 matching lines @@
   local_tab_map_.clear();
   local_tab_pool_.Clear();
   current_machine_tag_.clear();
   current_session_name_.clear();
   local_session_header_node_id_ = TabNodePool::kInvalidTabNodeID;
 }
 
 syncer::SyncDataList SessionsSyncManager::GetAllSyncData(
     syncer::ModelType type) const {
   syncer::SyncDataList list;
-  const sync_driver::SyncedSession* session = NULL;
+  const SyncedSession* session = NULL;
   if (!session_tracker_.LookupLocalSession(&session))
     return syncer::SyncDataList();
 
   // First construct the header node.
   sync_pb::EntitySpecifics header_entity;
   header_entity.mutable_session()->set_session_tag(current_machine_tag());
   sync_pb::SessionHeader* header_specifics =
       header_entity.mutable_session()->mutable_header();
   header_specifics->MergeFrom(session->ToSessionHeader());
   syncer::SyncData data = syncer::SyncData::CreateLocalData(
       current_machine_tag(), current_session_name_, header_entity);
   list.push_back(data);
 
-  sync_driver::SyncedSession::SyncedWindowMap::const_iterator win_iter;
+  SyncedSession::SyncedWindowMap::const_iterator win_iter;
   for (win_iter = session->windows.begin(); win_iter != session->windows.end();
        ++win_iter) {
     std::vector<sessions::SessionTab*>::const_iterator tabs_iter;
     for (tabs_iter = win_iter->second->tabs.begin();
          tabs_iter != win_iter->second->tabs.end(); ++tabs_iter) {
       sync_pb::EntitySpecifics entity;
       sync_pb::SessionSpecifics* specifics = entity.mutable_session();
       specifics->mutable_tab()->MergeFrom((*tabs_iter)->ToSyncData());
       specifics->set_session_tag(current_machine_tag_);
 
       TabLinksMap::const_iterator tab_map_iter =
           local_tab_map_.find((*tabs_iter)->tab_id.id());
       DCHECK(tab_map_iter != local_tab_map_.end());
       specifics->set_tab_node_id(tab_map_iter->second->tab_node_id());
       syncer::SyncData data = syncer::SyncData::CreateLocalData(
           TabNodePool::TabIdToTag(current_machine_tag_,
                                   specifics->tab_node_id()),
           current_session_name_, entity);
       list.push_back(data);
     }
   }
   return list;
 }
 
-bool SessionsSyncManager::GetLocalSession(
-    const sync_driver::SyncedSession** local_session) {
+bool SessionsSyncManager::GetLocalSession(const SyncedSession** local_session) {
   if (current_machine_tag_.empty())
     return false;
   *local_session = session_tracker_.GetSession(current_machine_tag());
   return true;
 }
 
 syncer::SyncError SessionsSyncManager::ProcessSyncChanges(
     const tracked_objects::Location& from_here,
     const syncer::SyncChangeList& change_list) {
   if (!sync_processor_.get()) {
@@ skipping 68 matching lines @@
   } else {
     return syncer::SyncChange(
         FROM_HERE, SyncChange::ACTION_DELETE,
         SyncData::CreateLocalDelete(
             TabNodePool::TabIdToTag(current_machine_tag(), tab.tab_node_id()),
             syncer::SESSIONS));
   }
 }
 
 bool SessionsSyncManager::GetAllForeignSessions(
-    std::vector<const sync_driver::SyncedSession*>* sessions) {
+    std::vector<const SyncedSession*>* sessions) {
   if (!session_tracker_.LookupAllForeignSessions(
           sessions, SyncedSessionTracker::PRESENTABLE))
     return false;
   std::sort(sessions->begin(), sessions->end(), SessionsRecencyComparator);
   return true;
 }
 
 bool SessionsSyncManager::InitFromSyncModel(
     const syncer::SyncDataList& sync_data,
     syncer::SyncDataList* restored_tabs,
@@ skipping 45 matching lines @@
           // reused for reassociation.
           local_tab_pool_.AddTabNode(specifics.tab_node_id());
           restored_tabs->push_back(*it);
         }
       }
     }
   }
 
   // Cleanup all foreign sessions, since orphaned tabs may have been added after
   // the header.
-  std::vector<const sync_driver::SyncedSession*> sessions;
+  std::vector<const SyncedSession*> sessions;
   session_tracker_.LookupAllForeignSessions(&sessions,
                                             SyncedSessionTracker::RAW);
   for (const auto* session : sessions) {
     session_tracker_.CleanupSession(session->session_tag);
   }
 
   UMA_HISTOGRAM_COUNTS_100("Sync.SessionsBadForeignHashOnMergeCount",
                            bad_foreign_hash_count);
 
   return found_current_header;
 }
 
 void SessionsSyncManager::UpdateTrackerWithForeignSession(
     const sync_pb::SessionSpecifics& specifics,
     const base::Time& modification_time) {
   std::string foreign_session_tag = specifics.session_tag();
   DCHECK_NE(foreign_session_tag, current_machine_tag());
 
-  sync_driver::SyncedSession* foreign_session =
+  SyncedSession* foreign_session =
       session_tracker_.GetSession(foreign_session_tag);
   if (specifics.has_header()) {
     // Read in the header data for this foreign session. Header data is
     // essentially a collection of windows, each of which has an ordered id list
     // for their tabs.
 
     if (!IsValidSessionHeader(specifics.header())) {
       LOG(WARNING) << "Ignoring foreign session node with invalid header "
                    << "and tag " << foreign_session_tag << ".";
       return;
@@ skipping 76 matching lines @@
     sync_prefs_->SetSyncSessionsGUID(current_machine_tag_);
   }
 
   local_tab_pool_.SetMachineTag(current_machine_tag_);
 }
 
 // static
 void SessionsSyncManager::PopulateSessionHeaderFromSpecifics(
     const sync_pb::SessionHeader& header_specifics,
     base::Time mtime,
-    sync_driver::SyncedSession* session_header) {
+    SyncedSession* session_header) {
   if (header_specifics.has_client_name())
     session_header->session_name = header_specifics.client_name();
   if (header_specifics.has_device_type()) {
     switch (header_specifics.device_type()) {
       case sync_pb::SyncEnums_DeviceType_TYPE_WIN:
-        session_header->device_type = sync_driver::SyncedSession::TYPE_WIN;
+        session_header->device_type = SyncedSession::TYPE_WIN;
         break;
       case sync_pb::SyncEnums_DeviceType_TYPE_MAC:
-        session_header->device_type = sync_driver::SyncedSession::TYPE_MACOSX;
+        session_header->device_type = SyncedSession::TYPE_MACOSX;
         break;
       case sync_pb::SyncEnums_DeviceType_TYPE_LINUX:
-        session_header->device_type = sync_driver::SyncedSession::TYPE_LINUX;
+        session_header->device_type = SyncedSession::TYPE_LINUX;
         break;
       case sync_pb::SyncEnums_DeviceType_TYPE_CROS:
-        session_header->device_type = sync_driver::SyncedSession::TYPE_CHROMEOS;
+        session_header->device_type = SyncedSession::TYPE_CHROMEOS;
         break;
       case sync_pb::SyncEnums_DeviceType_TYPE_PHONE:
-        session_header->device_type = sync_driver::SyncedSession::TYPE_PHONE;
+        session_header->device_type = SyncedSession::TYPE_PHONE;
         break;
       case sync_pb::SyncEnums_DeviceType_TYPE_TABLET:
-        session_header->device_type = sync_driver::SyncedSession::TYPE_TABLET;
+        session_header->device_type = SyncedSession::TYPE_TABLET;
         break;
       case sync_pb::SyncEnums_DeviceType_TYPE_OTHER:
       // Intentionally fall-through
       default:
-        session_header->device_type = sync_driver::SyncedSession::TYPE_OTHER;
+        session_header->device_type = SyncedSession::TYPE_OTHER;
         break;
     }
   }
   session_header->modified_time =
       std::max(mtime, session_header->modified_time);
 }
 
 // static
 void SessionsSyncManager::BuildSyncedSessionFromSpecifics(
     const std::string& session_tag,
@@ skipping 269 matching lines @@
 FaviconCache* SessionsSyncManager::GetFaviconCache() {
   return &favicon_cache_;
 }
 
 SyncedWindowDelegatesGetter*
 SessionsSyncManager::synced_window_delegates_getter() const {
   return sessions_client_->GetSyncedWindowDelegatesGetter();
 }
 
 void SessionsSyncManager::DoGarbageCollection() {
-  std::vector<const sync_driver::SyncedSession*> sessions;
+  std::vector<const SyncedSession*> sessions;
   if (!session_tracker_.LookupAllForeignSessions(&sessions,
                                                  SyncedSessionTracker::RAW))
     return;  // No foreign sessions.
 
   // Iterate through all the sessions and delete any with age older than
   // |stale_session_threshold_days_|.
   syncer::SyncChangeList changes;
   for (const auto* session : sessions) {
     int session_age_in_days =
         (base::Time::Now() - session->modified_time).InDays();
     if (session_age_in_days > stale_session_threshold_days_) {
       std::string session_tag = session->session_tag;
       DVLOG(1) << "Found stale session " << session_tag << " with age "
                << session_age_in_days << ", deleting.";
       DeleteForeignSessionInternal(session_tag, &changes);
     }
   }
 
   if (!changes.empty())
     sync_processor_->ProcessSyncChanges(FROM_HERE, changes);
 }
 
 // static
 std::string SessionsSyncManager::TagHashFromSpecifics(
     const sync_pb::SessionSpecifics& specifics) {
   return syncer::syncable::GenerateSyncableHash(syncer::SESSIONS,
                                                 TagFromSpecifics(specifics));
 }
 
-};  // namespace browser_sync
+};  // namespace sync_sessions