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

chrome/browser/ui/webui/ntp/foreign_session_handler.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/ui/webui/ntp/foreign_session_handler.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 53 matching lines @@
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 }
 
 // static
 void ForeignSessionHandler::OpenForeignSessionTab(
     content::WebUI* web_ui,
     const std::string& session_string_value,
     SessionID::id_type window_num,
     SessionID::id_type tab_id,
     const WindowOpenDisposition& disposition) {
-  SessionModelAssociator* associator = GetModelAssociator(web_ui);
-  if (!associator)
+  OpenTabsUIDelegate* open_tabs = GetOpenTabsUIDelegate(web_ui);
+  if (!open_tabs)
     return;
 
   // We don't actually care about |window_num|, this is just a sanity check.
   DCHECK_LT(kInvalidId, window_num);
   const SessionTab* tab;
-  if (!associator->GetForeignTab(session_string_value, tab_id, &tab)) {
+  if (!open_tabs->GetForeignTab(session_string_value, tab_id, &tab)) {
     LOG(ERROR) << "Failed to load foreign tab.";
     return;
   }
   if (tab->navigations.empty()) {
     LOG(ERROR) << "Foreign tab no longer has valid navigations.";
     return;
   }
   SessionRestore::RestoreForeignSessionTab(
       web_ui->GetWebContents(), *tab, disposition);
 }
 
 // static
 void ForeignSessionHandler::OpenForeignSessionWindows(
     content::WebUI* web_ui,
     const std::string& session_string_value,
     SessionID::id_type window_num) {
-  SessionModelAssociator* associator = GetModelAssociator(web_ui);
-  if (!associator)
+  OpenTabsUIDelegate* open_tabs = GetOpenTabsUIDelegate(web_ui);
+  if (!open_tabs)
     return;
 
   std::vector<const SessionWindow*> windows;
   // Note: we don't own the ForeignSessions themselves.
-  if (!associator->GetForeignSession(session_string_value, &windows)) {
+  if (!open_tabs->GetForeignSession(session_string_value, &windows)) {
     LOG(ERROR) << "ForeignSessionHandler failed to get session data from"
-        "SessionModelAssociator.";
+        "OpenTabsUIDelegate.";
     return;
   }
   std::vector<const SessionWindow*>::const_iterator iter_begin =
       windows.begin() + (window_num == kInvalidId ? 0 : window_num);
   std::vector<const SessionWindow*>::const_iterator iter_end =
       window_num == kInvalidId ?
       std::vector<const SessionWindow*>::const_iterator(windows.end()) :
       iter_begin + 1;
   chrome::HostDesktopType host_desktop_type =
       chrome::GetHostDesktopTypeForNativeView(
@@ skipping 23 matching lines @@
   dictionary->SetDouble("timestamp",
                         static_cast<double>(tab.timestamp.ToInternalValue()));
   // TODO(jeremycho): This should probably be renamed to tabId to avoid
   // confusion with the ID corresponding to a session.  Investigate all the
   // places (C++ and JS) where this is being used.  (http://crbug.com/154865).
   dictionary->SetInteger("sessionId", tab.tab_id.id());
   return true;
 }
 
 // static
-SessionModelAssociator* ForeignSessionHandler::GetModelAssociator(
+OpenTabsUIDelegate* ForeignSessionHandler::GetOpenTabsUIDelegate(
     content::WebUI* web_ui) {
   Profile* profile = Profile::FromWebUI(web_ui);
   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 service->GetSessionModelAssociator();
+    return service->GetOpenTabsUIDelegate();
 
   return NULL;
 }
 
 void ForeignSessionHandler::RegisterMessages() {
   Init();
   web_ui()->RegisterMessageCallback("deleteForeignSession",
       base::Bind(&ForeignSessionHandler::HandleDeleteForeignSession,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("getForeignSessions",
@@ skipping 50 matching lines @@
 
 string16 ForeignSessionHandler::FormatSessionTime(const base::Time& time) {
   // Return a time like "1 hour ago", "2 days ago", etc.
   base::Time now = base::Time::Now();
   // TimeElapsed does not support negative TimeDelta values, so then we use 0.
   return ui::TimeFormat::TimeElapsed(
       now < time ? base::TimeDelta() : now - time);
 }
 
 void ForeignSessionHandler::HandleGetForeignSessions(const ListValue* args) {
-  SessionModelAssociator* associator = GetModelAssociator(web_ui());
+  OpenTabsUIDelegate* open_tabs = GetOpenTabsUIDelegate(web_ui());
   std::vector<const SyncedSession*> sessions;
 
   ListValue session_list;
-  if (associator && associator->GetAllForeignSessions(&sessions)) {
+  if (open_tabs && open_tabs->GetAllForeignSessions(&sessions)) {
     // Sort sessions from most recent to least recent.
     std::sort(sessions.begin(), sessions.end(), SortSessionsByRecency);
 
     // 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::FromWebUI(web_ui())->GetPrefs(),
                                      prefs::kNtpCollapsedForeignSessions);
     DictionaryValue* current_collapsed_sessions = pref_update.Get();
     scoped_ptr<DictionaryValue> collapsed_sessions(
@@ skipping 88 matching lines @@
     return;
   }
 
   // Get the session tag argument (required).
   std::string session_tag;
   if (!args->GetString(0, &session_tag)) {
     LOG(ERROR) << "Unable to extract session tag";
     return;
   }
 
-  SessionModelAssociator* associator = GetModelAssociator(web_ui());
-  if (associator)
-    associator->DeleteForeignSession(session_tag);
+  OpenTabsUIDelegate* open_tabs = GetOpenTabsUIDelegate(web_ui());
+  if (open_tabs)
+    open_tabs->DeleteForeignSession(session_tag);
 }
 
 void ForeignSessionHandler::HandleSetForeignSessionCollapsed(
     const ListValue* args) {
   if (args->GetSize() != 2U) {
     LOG(ERROR) << "Wrong number of args to setForeignSessionCollapsed";
     return;
   }
 
   // Get the session tag argument (required).
@@ skipping 47 matching lines @@
   dictionary->SetString("userVisibleTimestamp",
       last_synced < base::TimeDelta::FromMinutes(1) ?
           l10n_util::GetStringUTF16(IDS_SYNC_TIME_JUST_NOW) :
           ui::TimeFormat::TimeElapsed(last_synced));
   dictionary->SetInteger("sessionId", window.window_id.id());
   dictionary->Set("tabs", tab_values.release());
   return true;
 }
 
 }  // namespace browser_sync