[sessions] Properly namespace recently-componentized TabRestore code

chrome/browser/ui/cocoa/history_menu_bridge.mm

 // 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/cocoa/history_menu_bridge.h"
 
 #include "base/bind.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/sys_string_conversions.h"
@@ skipping 104 matching lines @@
 
   // Since the map owns the HistoryItems, delete anything that still exists.
   std::map<NSMenuItem*, HistoryItem*>::iterator it = menu_item_map_.begin();
   while (it != menu_item_map_.end()) {
     HistoryItem* item  = it->second;
     menu_item_map_.erase(it++);
     delete item;
   }
 }
 
-void HistoryMenuBridge::TabRestoreServiceChanged(TabRestoreService* service) {
-  const TabRestoreService::Entries& entries = service->entries();
+void HistoryMenuBridge::TabRestoreServiceChanged(
+    sessions::TabRestoreService* service) {
+  const sessions::TabRestoreService::Entries& entries = service->entries();
 
   // Clear the history menu before rebuilding.
   NSMenu* menu = HistoryMenu();
   ClearMenuSection(menu, kRecentlyClosed);
 
   // Index for the next menu item.
   NSInteger index = [menu indexOfItemWithTag:kRecentlyClosedTitle] + 1;
   NSUInteger added_count = 0;
 
-  for (TabRestoreService::Entries::const_iterator it = entries.begin();
+  for (sessions::TabRestoreService::Entries::const_iterator it =
+           entries.begin();
        it != entries.end() && added_count < kRecentlyClosedCount; ++it) {
-    TabRestoreService::Entry* entry = *it;
+    sessions::TabRestoreService::Entry* entry = *it;
 
     // If this is a window, create a submenu for all of its tabs.
-    if (entry->type == TabRestoreService::WINDOW) {
-      TabRestoreService::Window* entry_win = (TabRestoreService::Window*)entry;
-      std::vector<TabRestoreService::Tab>& tabs = entry_win->tabs;
+    if (entry->type == sessions::TabRestoreService::WINDOW) {
+      sessions::TabRestoreService::Window* entry_win =
+          (sessions::TabRestoreService::Window*)entry;
+      std::vector<sessions::TabRestoreService::Tab>& tabs = entry_win->tabs;
       if (!tabs.size())
         continue;
 
       // Create the item for the parent/window. Do not set the title yet because
       // the actual number of items that are in the menu will not be known until
       // things like the NTP are filtered out, which is done when the tab items
       // are actually created.
       HistoryItem* item = new HistoryItem();
       item->session_id = entry_win->id;
 
@@ skipping 11 matching lines @@
       // Duplicate the HistoryItem otherwise the different NSMenuItems will
       // point to the same HistoryItem, which would then be double-freed when
       // removing the items from the map or in the dtor.
       HistoryItem* dup_item = new HistoryItem(*item);
       menu_item_map_.insert(std::make_pair(restore_item.get(), dup_item));
       [submenu addItem:restore_item.get()];
       [submenu addItem:[NSMenuItem separatorItem]];
 
       // Loop over the window's tabs and add them to the submenu.
       NSInteger subindex = [[submenu itemArray] count];
-      std::vector<TabRestoreService::Tab>::const_iterator it;
+      std::vector<sessions::TabRestoreService::Tab>::const_iterator it;
       for (it = tabs.begin(); it != tabs.end(); ++it) {
-        TabRestoreService::Tab tab = *it;
+        sessions::TabRestoreService::Tab tab = *it;
         HistoryItem* tab_item = HistoryItemForTab(tab);
         if (tab_item) {
           item->tabs.push_back(tab_item);
           AddItemToMenu(tab_item, submenu.get(), kRecentlyClosed + 1,
                         subindex++);
         }
       }
 
       // Now that the number of tabs that has been added is known, set the title
       // of the parent menu item.
       item->title = l10n_util::GetPluralStringFUTF16(
           IDS_RECENTLY_CLOSED_WINDOW, item->tabs.size());
 
       // Sometimes it is possible for there to not be any subitems for a given
       // window; if that is the case, do not add the entry to the main menu.
       if ([[submenu itemArray] count] > 2) {
         // Create the menu item parent.
         NSMenuItem* parent_item =
             AddItemToMenu(item, menu, kRecentlyClosed, index++);
         [parent_item setSubmenu:submenu.get()];
         ++added_count;
       }
-    } else if (entry->type == TabRestoreService::TAB) {
-      TabRestoreService::Tab* tab =
-          static_cast<TabRestoreService::Tab*>(entry);
+    } else if (entry->type == sessions::TabRestoreService::TAB) {
+      sessions::TabRestoreService::Tab* tab =
+          static_cast<sessions::TabRestoreService::Tab*>(entry);
       HistoryItem* item = HistoryItemForTab(*tab);
       if (item) {
         AddItemToMenu(item, menu, kRecentlyClosed, index++);
         ++added_count;
       }
     }
   }
 }
 
 void HistoryMenuBridge::TabRestoreServiceDestroyed(
-    TabRestoreService* service) {
+    sessions::TabRestoreService* service) {
   // Intentionally left blank. We hold a weak reference to the service.
 }
 
 void HistoryMenuBridge::ResetMenu() {
   NSMenu* menu = HistoryMenu();
   ClearMenuSection(menu, kVisited);
   ClearMenuSection(menu, kRecentlyClosed);
 }
 
 void HistoryMenuBridge::BuildMenu() {
@@ skipping 141 matching lines @@
   }
 
   // We are already invalid by the time we finished, darn.
   if (need_recreate_)
     CreateMenu();
 
   create_in_progress_ = false;
 }
 
 HistoryMenuBridge::HistoryItem* HistoryMenuBridge::HistoryItemForTab(
-    const TabRestoreService::Tab& entry) {
+    const sessions::TabRestoreService::Tab& entry) {
   DCHECK(!entry.navigations.empty());
 
   const sessions::SerializedNavigationEntry& current_navigation =
       entry.navigations.at(entry.current_navigation_index);
   HistoryItem* item = new HistoryItem();
   item->title = current_navigation.title();
   item->url = current_navigation.virtual_url();
   item->session_id = entry.id;
 
   // Tab navigations don't come with icons, so we always have to request them.
@@ skipping 60 matching lines @@
                                       const history::URLRows& deleted_rows,
                                       const std::set<GURL>& favicon_urls) {
   OnHistoryChanged();
 }
 
 void HistoryMenuBridge::OnHistoryServiceLoaded(
     history::HistoryService* history_service) {
   history_service_ = history_service;
   Init();
 }