[Sync] Fix namespaces for the sync_sessions component.

chrome/browser/sync/test/integration/sessions_helper.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 "chrome/browser/sync/test/integration/sessions_helper.h"
 
 #include <stddef.h>
 
 #include <algorithm>
+#include <set>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/memory/weak_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
@@ skipping 34 matching lines @@
 const SessionWindowMap* ScopedWindowMap::Get() const {
   return &windows_;
 }
 
 void ScopedWindowMap::Reset(SessionWindowMap* windows) {
   base::STLDeleteContainerPairSecondPointers(windows_.begin(), windows_.end());
   windows_.clear();
   std::swap(*windows, windows_);
 }
 
-bool GetLocalSession(int index, const sync_driver::SyncedSession** session) {
+bool GetLocalSession(int index, const sync_sessions::SyncedSession** session) {
   return ProfileSyncServiceFactory::GetInstance()->GetForProfile(
       test()->GetProfile(index))->GetOpenTabsUIDelegate()->
           GetLocalSession(session);
 }
 
 bool ModelAssociatorHasTabWithUrl(int index, const GURL& url) {
   content::RunAllPendingInMessageLoop();
-  const sync_driver::SyncedSession* local_session;
+  const sync_sessions::SyncedSession* local_session;
   if (!GetLocalSession(index, &local_session)) {
     return false;
   }
 
   if (local_session->windows.size() == 0) {
     DVLOG(1) << "Empty windows vector";
     return false;
   }
 
   int nav_index;
@@ skipping 42 matching lines @@
        it != urls.end(); ++it) {
     DVLOG(1) << "Opening tab: " << it->spec() << " using profile " << index
              << ".";
     chrome::ShowSingletonTab(browser, *it);
   }
   return WaitForTabsToLoad(index, urls);
 }
 
 namespace {
 
-class TabEventHandler : public browser_sync::LocalSessionEventHandler {
+class TabEventHandler : public sync_sessions::LocalSessionEventHandler {
  public:
   TabEventHandler() : weak_factory_(this) {
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&TabEventHandler::QuitLoop, weak_factory_.GetWeakPtr()),
         TestTimeouts::action_max_timeout());
   }
 
   void OnLocalTabModified(
-      browser_sync::SyncedTabDelegate* modified_tab) override {
+      sync_sessions::SyncedTabDelegate* modified_tab) override {
     // Unwind to ensure SessionsSyncManager has processed the event.
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(&TabEventHandler::QuitLoop, weak_factory_.GetWeakPtr()));
   }
 
   void OnFaviconsChanged(const std::set<GURL>& /* page_urls */,
                          const GURL& /* icon_url */) override {
     // Unwind to ensure SessionsSyncManager has processed the event.
     base::ThreadTaskRunnerHandle::Get()->PostTask(
@@ skipping 20 matching lines @@
     while (!found) {
       found = ModelAssociatorHasTabWithUrl(index, *it);
       if (base::TimeTicks::Now() >= end_time) {
         LOG(ERROR) << "Failed to find all tabs after "
                    << TestTimeouts::action_max_timeout().InSecondsF()
                    << " seconds.";
         return false;
       }
       if (!found) {
         TabEventHandler handler;
-        browser_sync::NotificationServiceSessionsRouter router(
+        sync_sessions::NotificationServiceSessionsRouter router(
             test()->GetProfile(index),
             ProfileSyncServiceFactory::GetInstance()
                 ->GetForProfile(test()->GetProfile(index))
                 ->GetSyncClient()
                 ->GetSyncSessionsClient(),
             syncer::SyncableService::StartSyncFlare());
         router.StartRoutingTo(&handler);
         content::RunMessageLoop();
       }
     }
   }
   return true;
 }
 
 bool GetLocalWindows(int index, SessionWindowMap* local_windows) {
   // The local session provided by GetLocalSession is owned, and has lifetime
   // controlled, by the model associator, so we must make our own copy.
-  const sync_driver::SyncedSession* local_session;
+  const sync_sessions::SyncedSession* local_session;
   if (!GetLocalSession(index, &local_session)) {
     return false;
   }
   for (SessionWindowMap::const_iterator w = local_session->windows.begin();
        w != local_session->windows.end(); ++w) {
     const sessions::SessionWindow& window = *(w->second);
     sessions::SessionWindow* new_window = new sessions::SessionWindow();
     new_window->window_id.set_id(window.window_id.id());
     for (size_t t = 0; t < window.tabs.size(); ++t) {
       const sessions::SessionTab& tab = *window.tabs.at(t);
@@ skipping 20 matching lines @@
 
 bool CheckInitialState(int index) {
   if (0 != GetNumWindows(index))
     return false;
   if (0 != GetNumForeignSessions(index))
     return false;
   return true;
 }
 
 int GetNumWindows(int index) {
-  const sync_driver::SyncedSession* local_session;
+  const sync_sessions::SyncedSession* local_session;
   if (!GetLocalSession(index, &local_session)) {
     return 0;
   }
   return local_session->windows.size();
 }
 
 int GetNumForeignSessions(int index) {
   SyncedSessionVector sessions;
   if (!ProfileSyncServiceFactory::GetInstance()->GetForProfile(
           test()->GetProfile(index))->
           GetOpenTabsUIDelegate()->GetAllForeignSessions(
               &sessions)) {
     return 0;
   }
   return sessions.size();
 }
 
 bool GetSessionData(int index, SyncedSessionVector* sessions) {
   if (!ProfileSyncServiceFactory::GetInstance()->GetForProfile(
           test()->GetProfile(index))->
           GetOpenTabsUIDelegate()->GetAllForeignSessions(
               sessions)) {
     return false;
   }
   SortSyncedSessions(sessions);
   return true;
 }
 
-bool CompareSyncedSessions(const sync_driver::SyncedSession* lhs,
-                           const sync_driver::SyncedSession* rhs) {
+bool CompareSyncedSessions(const sync_sessions::SyncedSession* lhs,
+                           const sync_sessions::SyncedSession* rhs) {
   if (!lhs ||
       !rhs ||
       lhs->windows.size() < 1 ||
       rhs->windows.size() < 1) {
     // Catchall for uncomparable data.
     return false;
   }
 
   return lhs->windows < rhs->windows;
 }
@@ skipping 147 matching lines @@
   return !checker.TimedOut();
 }
 
 void DeleteForeignSession(int index, std::string session_tag) {
   ProfileSyncServiceFactory::GetInstance()->GetForProfile(
       test()->GetProfile(index))->
           GetOpenTabsUIDelegate()->DeleteForeignSession(session_tag);
 }
 
 }  // namespace sessions_helper