[Sync] Fix namespaces for the sync_sessions component.

chrome/browser/android/foreign_session_helper.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/android/foreign_session_helper.h"
 
 #include <jni.h>
 #include <stddef.h>
 
 #include "base/android/jni_string.h"
@@ skipping 16 matching lines @@
 #include "content/public/browser/web_contents.h"
 #include "jni/ForeignSessionHelper_jni.h"
 
 using base::android::JavaParamRef;
 using base::android::ScopedJavaGlobalRef;
 using base::android::ScopedJavaLocalRef;
 using base::android::AttachCurrentThread;
 using base::android::ConvertUTF16ToJavaString;
 using base::android::ConvertUTF8ToJavaString;
 using base::android::ConvertJavaStringToUTF8;
-using sync_driver::OpenTabsUIDelegate;
-using sync_driver::SyncedSession;
+using sync_sessions::OpenTabsUIDelegate;
+using sync_sessions::SyncedSession;
 
 namespace {
 
 OpenTabsUIDelegate* GetOpenTabsUIDelegate(Profile* profile) {
   ProfileSyncService* service = ProfileSyncServiceFactory::GetInstance()->
       GetForProfile(profile);
 
   // Only return the delegate if it exists and it is done syncing sessions.
   if (!service || !service->IsSyncActive())
     return NULL;
@@ skipping 18 matching lines @@
 bool ShouldSkipWindow(const sessions::SessionWindow& window) {
   for (std::vector<sessions::SessionTab*>::const_iterator tab_it =
            window.tabs.begin(); tab_it != window.tabs.end(); ++tab_it) {
     const sessions::SessionTab &session_tab = **tab_it;
     if (!ShouldSkipTab(session_tab))
       return false;
   }
   return true;
 }
 
-bool ShouldSkipSession(const sync_driver::SyncedSession& session) {
+bool ShouldSkipSession(const SyncedSession& session) {
   for (SyncedSession::SyncedWindowMap::const_iterator it =
       session.windows.begin(); it != session.windows.end(); ++it) {
     const sessions::SessionWindow  &window = *(it->second);
     if (!ShouldSkipWindow(window))
       return false;
   }
   return true;
 }
 
 void CopyTabToJava(
@@ skipping 121 matching lines @@
 }
 
 jboolean ForeignSessionHelper::GetForeignSessions(
     JNIEnv* env,
     const JavaParamRef<jobject>& obj,
     const JavaParamRef<jobject>& result) {
   OpenTabsUIDelegate* open_tabs = GetOpenTabsUIDelegate(profile_);
   if (!open_tabs)
     return false;
 
-  std::vector<const sync_driver::SyncedSession*> sessions;
+  std::vector<const SyncedSession*> sessions;
   if (!open_tabs->GetAllForeignSessions(&sessions))
     return false;
 
   // Use a pref to keep track of sessions that were collapsed by the user.
   // To prevent the pref from accumulating stale sessions, clear it each time
   // and only add back sessions that are still current.
   DictionaryPrefUpdate pref_update(profile_->GetPrefs(),
                                    prefs::kNtpCollapsedForeignSessions);
   base::DictionaryValue* pref_collapsed_sessions = pref_update.Get();
   std::unique_ptr<base::DictionaryValue> collapsed_sessions(
       pref_collapsed_sessions->DeepCopy());
   pref_collapsed_sessions->Clear();
 
   ScopedJavaLocalRef<jobject> last_pushed_session;
 
   // Note: we don't own the SyncedSessions themselves.
   for (size_t i = 0; i < sessions.size(); ++i) {
-    const sync_driver::SyncedSession& session = *(sessions[i]);
+    const SyncedSession& session = *(sessions[i]);
     if (ShouldSkipSession(session))
       continue;
 
     const bool is_collapsed = collapsed_sessions->HasKey(session.session_tag);
 
     if (is_collapsed)
       pref_collapsed_sessions->SetBoolean(session.session_tag, true);
 
     last_pushed_session.Reset(Java_ForeignSessionHelper_pushSession(
         env, result, ConvertUTF8ToJavaString(env, session.session_tag),
@@ skipping 73 matching lines @@
     const JavaParamRef<jstring>& session_tag) {
   OpenTabsUIDelegate* open_tabs = GetOpenTabsUIDelegate(profile_);
   if (open_tabs)
     open_tabs->DeleteForeignSession(ConvertJavaStringToUTF8(env, session_tag));
 }
 
 // static
 bool ForeignSessionHelper::RegisterForeignSessionHelper(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }