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

chrome/browser/ui/toolbar/recent_tabs_sub_menu_model.cc

 // Copyright 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/toolbar/recent_tabs_sub_menu_model.h"
 
 #include "base/bind.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/favicon/favicon_service_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/search/search.h"
 #include "chrome/browser/sessions/session_restore.h"
 #include "chrome/browser/sessions/tab_restore_service.h"
 #include "chrome/browser/sessions/tab_restore_service_delegate.h"
 #include "chrome/browser/sessions/tab_restore_service_factory.h"
-#include "chrome/browser/sync/glue/session_model_associator.h"
 #include "chrome/browser/sync/glue/synced_session.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/browser.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/toolbar/wrench_menu_model.h"
 #include "chrome/common/favicon/favicon_types.h"
 #include "chrome/common/pref_names.h"
 #include "grit/browser_resources.h"
 #include "grit/generated_resources.h"
@@ skipping 128 matching lines @@
   string16 title;
   GURL url;
 };
 
 const int RecentTabsSubMenuModel::kRecentlyClosedHeaderCommandId = 1120;
 const int RecentTabsSubMenuModel::kDisabledRecentlyClosedHeaderCommandId = 1121;
 
 RecentTabsSubMenuModel::RecentTabsSubMenuModel(
     ui::AcceleratorProvider* accelerator_provider,
     Browser* browser,
-    browser_sync::SessionModelAssociator* associator)
+    browser_sync::OpenTabsUIDelegate* delegate)
     : ui::SimpleMenuModel(this),
       browser_(browser),
-      associator_(associator),
+      open_tabs_(delegate),
       last_local_model_index_(-1),
       default_favicon_(ResourceBundle::GetSharedInstance().
           GetNativeImageNamed(IDR_DEFAULT_FAVICON)),
       weak_ptr_factory_(this) {
   // Invoke asynchronous call to load tabs from local last session, which does
   // nothing if the tabs have already been loaded or they shouldn't be loaded.
   // TabRestoreServiceChanged() will be called after the tabs are loaded.
   TabRestoreService* service =
       TabRestoreServiceFactory::GetForProfile(browser_->profile());
   if (service) {
@@ skipping 94 matching lines @@
     DCHECK(item.tab_id > -1 && item.url.is_valid());
 
     if (item.session_tag.empty()) {  // Restore tab of local session.
       if (service && delegate) {
         UMA_HISTOGRAM_ENUMERATION("WrenchMenu.RecentTabsSubMenu",
                                   LOCAL_SESSION_TAB, LIMIT_RECENT_TAB_ACTION);
         service->RestoreEntryById(delegate, item.tab_id,
                                   browser_->host_desktop_type(), disposition);
       }
     } else {  // Restore tab of session from other devices.
-      browser_sync::SessionModelAssociator* associator = GetModelAssociator();
-      if (!associator)
+      browser_sync::OpenTabsUIDelegate* open_tabs = GetOpenTabsUIDelegate();
+      if (!open_tabs)
         return;
       const SessionTab* tab;
-      if (!associator->GetForeignTab(item.session_tag, item.tab_id, &tab))
+      if (!open_tabs->GetForeignTab(item.session_tag, item.tab_id, &tab))
         return;
       if (tab->navigations.empty())
         return;
       UMA_HISTOGRAM_ENUMERATION("WrenchMenu.RecentTabsSubMenu",
                                 OTHER_DEVICE_TAB, LIMIT_RECENT_TAB_ACTION);
       SessionRestore::RestoreForeignSessionTab(
           browser_->tab_strip_model()->GetActiveWebContents(),
           *tab, disposition);
     }
   } else {
@@ skipping 112 matching lines @@
   }
 
   DCHECK_GE(last_local_model_index_, 0);
 }
 
 void RecentTabsSubMenuModel::BuildTabsFromOtherDevices() {
   // All other devices' items (device headers or tabs) use AddItem*() to append
   // a menu item, because they are always only built once (i.e. invoked from
   // Constructor()) and don't change after that.
 
-  browser_sync::SessionModelAssociator* associator = GetModelAssociator();
+  browser_sync::OpenTabsUIDelegate* open_tabs = GetOpenTabsUIDelegate();
   std::vector<const browser_sync::SyncedSession*> sessions;
-  if (!associator || !associator->GetAllForeignSessions(&sessions)) {
+  if (!open_tabs || !open_tabs->GetAllForeignSessions(&sessions)) {
     AddSeparator(ui::NORMAL_SEPARATOR);
     AddItemWithStringId(IDC_RECENT_TABS_NO_DEVICE_TABS,
                         IDS_RECENT_TABS_NO_DEVICE_TABS);
     return;
   }
 
   // Sort sessions from most recent to least recent.
   std::sort(sessions.begin(), sessions.end(), SortSessionsByRecency);
 
   const size_t kMaxSessionsToShow = 3;
   size_t num_sessions_added = 0;
   for (size_t i = 0;
        i < sessions.size() && num_sessions_added < kMaxSessionsToShow; ++i) {
     const browser_sync::SyncedSession* session = sessions[i];
     const std::string& session_tag = session->session_tag;
 
     // Get windows of session.
     std::vector<const SessionWindow*> windows;
-    if (!associator->GetForeignSession(session_tag, &windows) ||
+    if (!open_tabs->GetForeignSession(session_tag, &windows) ||
         windows.empty()) {
       continue;
     }
 
     // Collect tabs from all windows of session, pruning those that are not
     // syncable or are NewTabPage, then sort them from most recent to least
     // recent, independent of which window the tabs were from.
     std::vector<const SessionTab*> tabs_in_session;
     for (size_t j = 0; j < windows.size(); ++j) {
       const SessionWindow* window = windows[j];
@@ skipping 124 matching lines @@
 void RecentTabsSubMenuModel::AddTabFavicon(int command_id, const GURL& url) {
   bool is_local_tab = command_id < kFirstOtherDevicesTabCommandId;
   int index_in_menu = GetIndexOfCommandId(command_id);
 
   if (!is_local_tab) {
     // If tab has synced favicon, use it.
     // Note that currently, other devices' tabs only have favicons if
     // --sync-tab-favicons switch is on; according to zea@, this flag is now
     // automatically enabled for iOS and android, and they're looking into
     // enabling it for other platforms.
-    browser_sync::SessionModelAssociator* associator = GetModelAssociator();
+    browser_sync::OpenTabsUIDelegate* open_tabs = GetOpenTabsUIDelegate();
     scoped_refptr<base::RefCountedMemory> favicon_png;
-    if (associator &&
-        associator->GetSyncedFaviconForPageURL(url.spec(), &favicon_png)) {
+    if (open_tabs &&
+        open_tabs->GetSyncedFaviconForPageURL(url.spec(), &favicon_png)) {
       gfx::Image image = gfx::Image::CreateFrom1xPNGBytes(favicon_png->front(),
                                                           favicon_png->size());
       SetIcon(index_in_menu, image);
       return;
     }
   }
 
   // Otherwise, start to fetch the favicon from local history asynchronously.
   // Set default icon first.
   SetIcon(index_in_menu, default_favicon_);
@@ skipping 48 matching lines @@
   // local tabs.
   local_tab_cancelable_task_tracker_.TryCancelAll();
 
   // Remove all local tab navigation items.
   local_tab_navigation_items_.clear();
 
   // Remove all local window items.
   local_window_items_.clear();
 }
 
-browser_sync::SessionModelAssociator*
-    RecentTabsSubMenuModel::GetModelAssociator() {
-  if (!associator_) {
+browser_sync::OpenTabsUIDelegate*
+    RecentTabsSubMenuModel::GetOpenTabsUIDelegate() {
+  if (!open_tabs_) {
     ProfileSyncService* service = ProfileSyncServiceFactory::GetInstance()->
         GetForProfile(browser_->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())
-      associator_ = service->GetSessionModelAssociator();
+      open_tabs_ = service->GetOpenTabsUIDelegate();
   }
-  return associator_;
+  return open_tabs_;
 }
 
 void RecentTabsSubMenuModel::TabRestoreServiceChanged(
     TabRestoreService* service) {
   ClearLocalEntries();
 
   BuildLocalEntries();
 
   ui::MenuModelDelegate* menu_model_delegate = GetMenuModelDelegate();
   if (menu_model_delegate)
     menu_model_delegate->OnMenuStructureChanged();
 }
 
 void RecentTabsSubMenuModel::TabRestoreServiceDestroyed(
     TabRestoreService* service) {
   TabRestoreServiceChanged(service);
 }