[Sync] Fix namespaces for the sync_sessions component.

chrome/browser/extensions/api/sessions/sessions_api.cc

 // Copyright 2013 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 "chrome/browser/extensions/api/sessions/sessions_api.h"
 
 #include <stddef.h>
 
 #include <utility>
 #include <vector>
@@ skipping 45 matching lines @@
     "There are no recently closed sessions.";
 const char kInvalidSessionIdError[] = "Invalid session id: \"*\".";
 const char kNoBrowserToRestoreSession[] =
     "There are no browser windows to restore the session.";
 const char kSessionSyncError[] = "Synced sessions are not available.";
 const char kRestoreInIncognitoError[] =
     "Can not restore sessions in incognito mode.";
 
 // Comparator function for use with std::sort that will sort sessions by
 // descending modified_time (i.e., most recent first).
-bool SortSessionsByRecency(const sync_driver::SyncedSession* s1,
-                           const sync_driver::SyncedSession* s2) {
+bool SortSessionsByRecency(const sync_sessions::SyncedSession* s1,
+                           const sync_sessions::SyncedSession* s2) {
   return s1->modified_time > s2->modified_time;
 }
 
 // Comparator function for use with std::sort that will sort tabs in a window
 // by descending timestamp (i.e., most recent first).
 bool SortTabsByRecency(const sessions::SessionTab* t1,
                        const sessions::SessionTab* t2) {
   return t1->timestamp > t2->timestamp;
 }
 
@@ skipping 238 matching lines @@
       CreateWindowModel(window, session_tag));
   // There is a chance that after pruning uninteresting tabs the window will be
   // empty.
   return !window_model ? std::unique_ptr<api::sessions::Session>()
                        : CreateSessionModelHelper(window.timestamp.ToTimeT(),
                                                   std::unique_ptr<tabs::Tab>(),
                                                   std::move(window_model));
 }
 
 api::sessions::Device SessionsGetDevicesFunction::CreateDeviceModel(
-    const sync_driver::SyncedSession* session) {
+    const sync_sessions::SyncedSession* session) {
   int max_results = api::sessions::MAX_SESSION_RESULTS;
   // Already validated in RunAsync().
   std::unique_ptr<GetDevices::Params> params(
       GetDevices::Params::Create(*args_));
   if (params->filter && params->filter->max_results)
     max_results = *params->filter->max_results;
 
   api::sessions::Device device_struct;
   device_struct.info = session->session_name;
   device_struct.device_name = session->session_name;
 
-  for (sync_driver::SyncedSession::SyncedWindowMap::const_iterator it =
+  for (sync_sessions::SyncedSession::SyncedWindowMap::const_iterator it =
            session->windows.begin();
        it != session->windows.end() &&
        static_cast<int>(device_struct.sessions.size()) < max_results;
        ++it) {
     std::unique_ptr<api::sessions::Session> session_model(
         CreateSessionModel(*it->second, session->session_tag));
     if (session_model)
       device_struct.sessions.push_back(std::move(*session_model));
   }
   return device_struct;
 }
 
 bool SessionsGetDevicesFunction::RunSync() {
   ProfileSyncService* service =
       ProfileSyncServiceFactory::GetInstance()->GetForProfile(GetProfile());
   if (!(service && service->GetPreferredDataTypes().Has(syncer::SESSIONS))) {
     // Sync not enabled.
     results_ =
         GetDevices::Results::Create(std::vector<api::sessions::Device>());
     return true;
   }
 
-  sync_driver::OpenTabsUIDelegate* open_tabs = service->GetOpenTabsUIDelegate();
-  std::vector<const sync_driver::SyncedSession*> sessions;
+  sync_sessions::OpenTabsUIDelegate* open_tabs =
+      service->GetOpenTabsUIDelegate();
+  std::vector<const sync_sessions::SyncedSession*> sessions;
   if (!(open_tabs && open_tabs->GetAllForeignSessions(&sessions))) {
     results_ =
         GetDevices::Results::Create(std::vector<api::sessions::Device>());
     return true;
   }
 
   std::unique_ptr<GetDevices::Params> params(
       GetDevices::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
   if (params->filter && params->filter->max_results) {
@@ skipping 121 matching lines @@
 }
 
 bool SessionsRestoreFunction::RestoreForeignSession(const SessionId& session_id,
                                                     Browser* browser) {
   ProfileSyncService* service =
       ProfileSyncServiceFactory::GetInstance()->GetForProfile(GetProfile());
   if (!(service && service->GetPreferredDataTypes().Has(syncer::SESSIONS))) {
     SetError(kSessionSyncError);
     return false;
   }
-  sync_driver::OpenTabsUIDelegate* open_tabs = service->GetOpenTabsUIDelegate();
+  sync_sessions::OpenTabsUIDelegate* open_tabs =
+      service->GetOpenTabsUIDelegate();
   if (!open_tabs) {
     SetError(kSessionSyncError);
     return false;
   }
 
   const sessions::SessionTab* tab = NULL;
   if (open_tabs->GetForeignTab(session_id.session_tag(),
                                session_id.id(),
                                &tab)) {
     TabStripModel* tab_strip = browser->tab_strip_model();
@@ skipping 111 matching lines @@
   return g_factory.Pointer();
 }
 
 void SessionsAPI::OnListenerAdded(const EventListenerInfo& details) {
   sessions_event_router_.reset(
       new SessionsEventRouter(Profile::FromBrowserContext(browser_context_)));
   EventRouter::Get(browser_context_)->UnregisterObserver(this);
 }
 
 }  // namespace extensions