sync: Add --enable-sync-sessions-v2 and necessary plumbing to use SessionsSyncManager.

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 "base/android/jni_string.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "chrome/browser/android/tab_android.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/profiles/profile_android.h"
 #include "chrome/browser/sessions/session_restore.h"
-#include "chrome/browser/sync/glue/session_model_associator.h"
+#include "chrome/browser/sync/open_tabs_ui_delegate.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/browser/ui/android/tab_model/tab_model.h"
 #include "chrome/browser/ui/android/tab_model/tab_model_list.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/web_contents.h"
 #include "jni/ForeignSessionHelper_jni.h"
 
 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 browser_sync::SessionModelAssociator;
+using browser_sync::OpenTabsUIDelegate;
 using browser_sync::SyncedSession;
 
 namespace {
 
-SessionModelAssociator* GetSessionModelAssociator(Profile* profile) {
+OpenTabsUIDelegate* GetOpenTabsUIDelegate(Profile* profile) {
   ProfileSyncService* service = ProfileSyncServiceFactory::GetInstance()->
       GetForProfile(profile);
 
-  // Only return the associator if it exists and it is done syncing sessions.
+  // Only return the delegate if it exists and it is done syncing sessions.
   if (!service || !service->ShouldPushChanges())
     return NULL;
 
-  return service->GetSessionModelAssociator();
+  return service->GetOpenTabsUIDelegate();
 }
 
 bool ShouldSkipTab(const SessionTab& session_tab) {
     if (session_tab.navigations.empty())
       return true;
 
     int selected_index = session_tab.current_navigation_index;
     if (selected_index < 0 ||
         selected_index >= static_cast<int>(session_tab.navigations.size()))
       return true;
@@ skipping 136 matching lines @@
       Java_ForeignSessionCallback_onUpdated(env, callback_.obj());
       break;
     default:
       NOTREACHED();
   }
 }
 
 jboolean ForeignSessionHelper::GetForeignSessions(JNIEnv* env,
                                                   jobject obj,
                                                   jobject result) {
-  SessionModelAssociator* associator = GetSessionModelAssociator(profile_);
-  if (!associator)
+  OpenTabsUIDelegate* open_tabs = GetOpenTabsUIDelegate(profile_);
+  if (!open_tabs)
     return false;
 
   std::vector<const browser_sync::SyncedSession*> sessions;
-  if (!associator->GetAllForeignSessions(&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);
   DictionaryValue* pref_collapsed_sessions = pref_update.Get();
   scoped_ptr<DictionaryValue> collapsed_sessions(
       pref_collapsed_sessions->DeepCopy());
@@ skipping 27 matching lines @@
 
   return true;
 }
 
 jboolean ForeignSessionHelper::OpenForeignSessionTab(JNIEnv* env,
                                                      jobject obj,
                                                      jobject j_tab,
                                                      jstring session_tag,
                                                      jint session_tab_id,
                                                      jint j_disposition) {
-  SessionModelAssociator* associator = GetSessionModelAssociator(profile_);
-  if (!associator) {
-    LOG(ERROR) << "Null SessionModelAssociator returned.";
+  OpenTabsUIDelegate* open_tabs = GetOpenTabsUIDelegate(profile_);
+  if (!open_tabs) {
+    LOG(ERROR) << "Null OpenTabsUIDelegate returned.";
     return false;
   }
 
   const SessionTab* session_tab;
 
-  if (!associator->GetForeignTab(ConvertJavaStringToUTF8(env, session_tag),
-                                 session_tab_id,
-                                 &session_tab)) {
+  if (!open_tabs->GetForeignTab(ConvertJavaStringToUTF8(env, session_tag),
+                                session_tab_id,
+                                &session_tab)) {
     LOG(ERROR) << "Failed to load foreign tab.";
     return false;
   }
 
   if (session_tab->navigations.empty()) {
     LOG(ERROR) << "Foreign tab no longer has valid navigations.";
     return false;
   }
 
   TabAndroid* tab_android = TabAndroid::GetNativeTab(env, j_tab);
   if (!tab_android)
     return false;
   content::WebContents* web_contents = tab_android->web_contents();
   if (!web_contents)
     return false;
 
   WindowOpenDisposition disposition =
       static_cast<WindowOpenDisposition>(j_disposition);
   SessionRestore::RestoreForeignSessionTab(web_contents,
                                            *session_tab,
                                            disposition);
 
   return true;
 }
 
 void ForeignSessionHelper::DeleteForeignSession(JNIEnv* env, jobject obj,
                                                 jstring session_tag) {
-  SessionModelAssociator* associator = GetSessionModelAssociator(profile_);
-  if (associator)
-    associator->DeleteForeignSession(ConvertJavaStringToUTF8(env, 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);
 }