[Sync] Fix namespaces for the sync_sessions component.

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 <stddef.h>
 
 #include "base/bind.h"
 #include "base/metrics/histogram_macros.h"
@@ skipping 67 matching lines @@
 // The maximum number of local recently closed entries (tab or window) to be
 // shown in the menu.
 const int kMaxLocalEntries = 8;
 
 // Index of the separator that follows the history menu item. Used as a
 // reference position for inserting local entries.
 const int kHistorySeparatorIndex = 1;
 
 // Comparator function for use with std::sort that will sort sessions by
 // descending modified_time (i.e., most recent first).
-bool SortSessionsByRecency(const sync_driver::SyncedSession* s1,
-                           const sync_driver::SyncedSession* s2) {
+bool SortSessionsByRecency(const sync_sessions::SyncedSession* s1,
+                           const sync_sessions::SyncedSession* s2) {
   return s1->modified_time > s2->modified_time;
 }
 
 // Returns true if the command id identifies a tab menu item.
 bool IsTabModelCommandId(int command_id) {
   return ((command_id >= kFirstLocalTabCommandId &&
            command_id < kFirstLocalWindowCommandId) ||
           (command_id >= kFirstOtherDevicesTabCommandId &&
            command_id < kMinDeviceNameCommandId));
 }
@@ skipping 73 matching lines @@
   base::string16 title;
   GURL url;
 };
 
 const int RecentTabsSubMenuModel::kRecentlyClosedHeaderCommandId = 1120;
 const int RecentTabsSubMenuModel::kDisabledRecentlyClosedHeaderCommandId = 1121;
 
 RecentTabsSubMenuModel::RecentTabsSubMenuModel(
     ui::AcceleratorProvider* accelerator_provider,
     Browser* browser,
-    sync_driver::OpenTabsUIDelegate* open_tabs_delegate)
+    sync_sessions::OpenTabsUIDelegate* open_tabs_delegate)
     : ui::SimpleMenuModel(this),
       browser_(browser),
       open_tabs_delegate_(open_tabs_delegate),
       last_local_model_index_(kHistorySeparatorIndex),
-      default_favicon_(ui::ResourceBundle::GetSharedInstance().
-                       GetNativeImageNamed(IDR_DEFAULT_FAVICON)),
+      default_favicon_(
+          ui::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.
   sessions::TabRestoreService* service =
       TabRestoreServiceFactory::GetForProfile(browser_->profile());
   if (service) {
     service->LoadTabsFromLastSession();
 
   // TODO(sail): enable this when mac implements the dynamic menu, together with
@@ skipping 110 matching lines @@
 
     if (item.session_tag.empty()) {  // Restore tab of local session.
       if (service && context) {
         content::RecordAction(
             base::UserMetricsAction("WrenchMenu_OpenRecentTabFromLocal"));
         UMA_HISTOGRAM_ENUMERATION("WrenchMenu.RecentTabsSubMenu",
                                   LOCAL_SESSION_TAB, LIMIT_RECENT_TAB_ACTION);
         service->RestoreEntryById(context, item.tab_id, disposition);
       }
     } else {  // Restore tab of session from other devices.
-      sync_driver::OpenTabsUIDelegate* open_tabs = GetOpenTabsUIDelegate();
+      sync_sessions::OpenTabsUIDelegate* open_tabs = GetOpenTabsUIDelegate();
       if (!open_tabs)
         return;
       const sessions::SessionTab* tab;
       if (!open_tabs->GetForeignTab(item.session_tag, item.tab_id, &tab))
         return;
       if (tab->navigations.empty())
         return;
       content::RecordAction(
           base::UserMetricsAction("WrenchMenu_OpenRecentTabFromDevice"));
       UMA_HISTOGRAM_ENUMERATION("WrenchMenu.RecentTabsSubMenu",
@@ skipping 138 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.
 
-  sync_driver::OpenTabsUIDelegate* open_tabs = GetOpenTabsUIDelegate();
-  std::vector<const sync_driver::SyncedSession*> sessions;
+  sync_sessions::OpenTabsUIDelegate* open_tabs = GetOpenTabsUIDelegate();
+  std::vector<const sync_sessions::SyncedSession*> 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 sync_driver::SyncedSession* session = sessions[i];
+    const sync_sessions::SyncedSession* session = sessions[i];
     const std::string& session_tag = session->session_tag;
 
     // Collect tabs from all windows of the session, ordered by recency.
     std::vector<const sessions::SessionTab*> tabs_in_session;
     if (!open_tabs->GetForeignSessionTabs(session_tag, &tabs_in_session) ||
         tabs_in_session.empty())
       continue;
 
     // Add the header for the device session.
     DCHECK(!session->session_name.empty());
@@ skipping 65 matching lines @@
   // There may be no tab title, in which case, use the url as tab title.
   AddItem(command_id,
           current_navigation.title().empty() ?
               base::UTF8ToUTF16(item.url.spec()) : current_navigation.title());
   AddTabFavicon(command_id, item.url);
   other_devices_tab_navigation_items_.push_back(item);
 }
 
 void RecentTabsSubMenuModel::AddDeviceFavicon(
     int index_in_menu,
-    sync_driver::SyncedSession::DeviceType device_type) {
+    sync_sessions::SyncedSession::DeviceType device_type) {
 #if defined(OS_MACOSX)
   int favicon_id = -1;
   switch (device_type) {
-    case sync_driver::SyncedSession::TYPE_PHONE:
+    case sync_sessions::SyncedSession::TYPE_PHONE:
       favicon_id = IDR_PHONE_FAVICON;
       break;
 
-    case sync_driver::SyncedSession::TYPE_TABLET:
+    case sync_sessions::SyncedSession::TYPE_TABLET:
       favicon_id = IDR_TABLET_FAVICON;
       break;
 
-    case sync_driver::SyncedSession::TYPE_CHROMEOS:
-    case sync_driver::SyncedSession::TYPE_WIN:
-    case sync_driver::SyncedSession::TYPE_MACOSX:
-    case sync_driver::SyncedSession::TYPE_LINUX:
-    case sync_driver::SyncedSession::TYPE_OTHER:
-    case sync_driver::SyncedSession::TYPE_UNSET:
+    case sync_sessions::SyncedSession::TYPE_CHROMEOS:
+    case sync_sessions::SyncedSession::TYPE_WIN:
+    case sync_sessions::SyncedSession::TYPE_MACOSX:
+    case sync_sessions::SyncedSession::TYPE_LINUX:
+    case sync_sessions::SyncedSession::TYPE_OTHER:
+    case sync_sessions::SyncedSession::TYPE_UNSET:
       favicon_id = IDR_LAPTOP_FAVICON;
       break;
   }
 
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
   SetIcon(index_in_menu, rb.GetNativeImageNamed(favicon_id));
 #else
   gfx::VectorIconId favicon_id = gfx::VectorIconId::VECTOR_ICON_NONE;
   switch (device_type) {
-    case sync_driver::SyncedSession::TYPE_PHONE:
+    case sync_sessions::SyncedSession::TYPE_PHONE:
       favicon_id = gfx::VectorIconId::SMARTPHONE;
       break;
 
-    case sync_driver::SyncedSession::TYPE_TABLET:
+    case sync_sessions::SyncedSession::TYPE_TABLET:
       favicon_id = gfx::VectorIconId::TABLET;
       break;
 
-    case sync_driver::SyncedSession::TYPE_CHROMEOS:
-    case sync_driver::SyncedSession::TYPE_WIN:
-    case sync_driver::SyncedSession::TYPE_MACOSX:
-    case sync_driver::SyncedSession::TYPE_LINUX:
-    case sync_driver::SyncedSession::TYPE_OTHER:
-    case sync_driver::SyncedSession::TYPE_UNSET:
+    case sync_sessions::SyncedSession::TYPE_CHROMEOS:
+    case sync_sessions::SyncedSession::TYPE_WIN:
+    case sync_sessions::SyncedSession::TYPE_MACOSX:
+    case sync_sessions::SyncedSession::TYPE_LINUX:
+    case sync_sessions::SyncedSession::TYPE_OTHER:
+    case sync_sessions::SyncedSession::TYPE_UNSET:
       favicon_id = gfx::VectorIconId::LAPTOP;
       break;
   }
 
   SetIcon(index_in_menu, CreateFavicon(favicon_id));
 #endif
 }
 
 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.
-    sync_driver::OpenTabsUIDelegate* open_tabs = GetOpenTabsUIDelegate();
+    sync_sessions::OpenTabsUIDelegate* open_tabs = GetOpenTabsUIDelegate();
     scoped_refptr<base::RefCountedMemory> favicon_png;
     if (open_tabs &&
         open_tabs->GetSyncedFaviconForPageURL(url.spec(), &favicon_png)) {
       gfx::Image image = gfx::Image::CreateFrom1xPNGBytes(favicon_png);
       SetIcon(index_in_menu, image);
       return;
     }
   }
 
   // Otherwise, start to fetch the favicon from local history asynchronously.
@@ skipping 49 matching lines @@
   // all 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();
 }
 
-sync_driver::OpenTabsUIDelegate*
+sync_sessions::OpenTabsUIDelegate*
 RecentTabsSubMenuModel::GetOpenTabsUIDelegate() {
   if (!open_tabs_delegate_) {
     ProfileSyncService* service = ProfileSyncServiceFactory::GetInstance()->
         GetForProfile(browser_->profile());
     // Only return the delegate if it exists and it is done syncing sessions.
     if (service && service->IsSyncActive())
       open_tabs_delegate_ = service->GetOpenTabsUIDelegate();
   }
   return open_tabs_delegate_;
 }
 
 void RecentTabsSubMenuModel::TabRestoreServiceChanged(
     sessions::TabRestoreService* service) {
   ClearLocalEntries();
 
   BuildLocalEntries();
 
   ui::MenuModelDelegate* menu_model_delegate = GetMenuModelDelegate();
   if (menu_model_delegate)
     menu_model_delegate->OnMenuStructureChanged();
 }
 
 void RecentTabsSubMenuModel::TabRestoreServiceDestroyed(
     sessions::TabRestoreService* service) {
   TabRestoreServiceChanged(service);
 }