[sessions] Properly namespace recently-componentized TabRestore code

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"
@@ skipping 173 matching lines @@
     : 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)),
       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 =
+  sessions::TabRestoreService* service =
       TabRestoreServiceFactory::GetForProfile(browser_->profile());
   if (service) {
     service->LoadTabsFromLastSession();
 
   // TODO(sail): enable this when mac implements the dynamic menu, together with
   // MenuModelDelegate::MenuStructureChanged().
 #if !defined(OS_MACOSX)
     service->AddObserver(this);
 #endif
   }
@@ skipping 19 matching lines @@
   }
 #endif  // defined(USE_ASH)
 
   if (accelerator_provider) {
     accelerator_provider->GetAcceleratorForCommandId(
         IDC_SHOW_HISTORY, &show_history_accelerator_);
   }
 }
 
 RecentTabsSubMenuModel::~RecentTabsSubMenuModel() {
-  TabRestoreService* service =
+  sessions::TabRestoreService* service =
       TabRestoreServiceFactory::GetForProfile(browser_->profile());
   if (service)
     service->RemoveObserver(this);
 }
 
 bool RecentTabsSubMenuModel::IsCommandIdChecked(int command_id) const {
   return false;
 }
 
 bool RecentTabsSubMenuModel::IsCommandIdEnabled(int command_id) const {
@@ skipping 38 matching lines @@
   }
 
   DCHECK_NE(IDC_RECENT_TABS_NO_DEVICE_TABS, command_id);
   DCHECK(!IsDeviceNameCommandId(command_id));
 
   WindowOpenDisposition disposition =
       ui::DispositionFromEventFlags(event_flags);
   if (disposition == CURRENT_TAB)  // Force to open a new foreground tab.
     disposition = NEW_FOREGROUND_TAB;
 
-  TabRestoreService* service =
+  sessions::TabRestoreService* service =
       TabRestoreServiceFactory::GetForProfile(browser_->profile());
-  TabRestoreServiceDelegate* delegate =
+  sessions::TabRestoreServiceDelegate* delegate =
       BrowserTabRestoreServiceDelegate::FindDelegateForWebContents(
           browser_->tab_strip_model()->GetActiveWebContents());
   if (IsTabModelCommandId(command_id)) {
     TabNavigationItems* tab_items = NULL;
     int tab_items_idx = CommandIdToTabVectorIndex(command_id, &tab_items);
     const TabNavigationItem& item = (*tab_items)[tab_items_idx];
     DCHECK(item.tab_id > -1 && item.url.is_valid());
 
     if (item.session_tag.empty()) {  // Restore tab of local session.
       if (service && delegate) {
@@ skipping 101 matching lines @@
   BuildTabsFromOtherDevices();
 }
 
 void RecentTabsSubMenuModel::BuildLocalEntries() {
   last_local_model_index_ = kHistorySeparatorIndex;
 
   // All local items use InsertItem*At() to append or insert a menu item.
   // We're appending if building the entries for the first time i.e. invoked
   // from Constructor(), inserting when local entries change subsequently i.e.
   // invoked from TabRestoreServiceChanged().
-  TabRestoreService* service =
+  sessions::TabRestoreService* service =
       TabRestoreServiceFactory::GetForProfile(browser_->profile());
 
   if (!service || service->entries().size() == 0) {
     // This is to show a disabled restore tab entry with the accelerator to
     // teach users about this command.
     InsertItemWithStringIdAt(++last_local_model_index_,
                              kDisabledRecentlyClosedHeaderCommandId,
                              IDS_RECENTLY_CLOSED);
   } else {
     InsertItemWithStringIdAt(++last_local_model_index_,
                              kRecentlyClosedHeaderCommandId,
                              IDS_RECENTLY_CLOSED);
 #if defined(OS_MACOSX)
     ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
     SetIcon(last_local_model_index_,
             rb.GetNativeImageNamed(IDR_RECENTLY_CLOSED_WINDOW));
 #else
     SetIcon(last_local_model_index_, CreateFavicon(gfx::VectorIconId::TAB));
 #endif
 
     int added_count = 0;
-    TabRestoreService::Entries entries = service->entries();
-    for (TabRestoreService::Entries::const_iterator it = entries.begin();
+    sessions::TabRestoreService::Entries entries = service->entries();
+    for (sessions::TabRestoreService::Entries::const_iterator it =
+             entries.begin();
          it != entries.end() && added_count < kMaxLocalEntries; ++it) {
-      TabRestoreService::Entry* entry = *it;
-      if (entry->type == TabRestoreService::TAB) {
-        TabRestoreService::Tab* tab =
-            static_cast<TabRestoreService::Tab*>(entry);
+      sessions::TabRestoreService::Entry* entry = *it;
+      if (entry->type == sessions::TabRestoreService::TAB) {
+        sessions::TabRestoreService::Tab* tab =
+            static_cast<sessions::TabRestoreService::Tab*>(entry);
         const sessions::SerializedNavigationEntry& current_navigation =
             tab->navigations.at(tab->current_navigation_index);
         BuildLocalTabItem(
             entry->id,
             current_navigation.title(),
             current_navigation.virtual_url(),
             ++last_local_model_index_);
       } else  {
-        DCHECK_EQ(entry->type, TabRestoreService::WINDOW);
+        DCHECK_EQ(entry->type, sessions::TabRestoreService::WINDOW);
         BuildLocalWindowItem(
-            entry->id,
-            static_cast<TabRestoreService::Window*>(entry)->tabs.size(),
+            entry->id, static_cast<sessions::TabRestoreService::Window*>(entry)
+                           ->tabs.size(),
             ++last_local_model_index_);
       }
       ++added_count;
     }
   }
   DCHECK_GE(last_local_model_index_, 0);
 }
 
 void RecentTabsSubMenuModel::BuildTabsFromOtherDevices() {
   // All other devices' items (device headers or tabs) use AddItem*() to append
@@ skipping 237 matching lines @@
     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(
-    TabRestoreService* service) {
+    sessions::TabRestoreService* service) {
   ClearLocalEntries();
 
   BuildLocalEntries();
 
   ui::MenuModelDelegate* menu_model_delegate = GetMenuModelDelegate();
   if (menu_model_delegate)
     menu_model_delegate->OnMenuStructureChanged();
 }
 
 void RecentTabsSubMenuModel::TabRestoreServiceDestroyed(
-    TabRestoreService* service) {
+    sessions::TabRestoreService* service) {
   TabRestoreServiceChanged(service);
 }