[sessions] Properly namespace recently-componentized TabRestore code

chrome/browser/ui/views/frame/global_menu_bar_x11.cc

 // Copyright 2013 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/views/frame/global_menu_bar_x11.h"
 
 #include <dlfcn.h>
 #include <glib-object.h>
 
 #include "base/debug/leak_annotations.h"
@@ skipping 516 matching lines @@
 
   GVariant* inside_array = g_variant_builder_end(&builder);
   g_variant_builder_init(&builder, G_VARIANT_TYPE_ARRAY);
   g_variant_builder_add_value(&builder, inside_array);
   GVariant* outside_array = g_variant_builder_end(&builder);
 
   menuitem_property_set_variant(item, kPropertyShortcut, outside_array);
 }
 
 GlobalMenuBarX11::HistoryItem* GlobalMenuBarX11::HistoryItemForTab(
-    const TabRestoreService::Tab& entry) {
+    const sessions::TabRestoreService::Tab& entry) {
   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;
 
   return item;
 }
 
@@ skipping 181 matching lines @@
 }
 
 void GlobalMenuBarX11::TopSitesLoaded(history::TopSites* top_sites) {
 }
 
 void GlobalMenuBarX11::TopSitesChanged(history::TopSites* top_sites,
                                        ChangeReason change_reason) {
     GetTopSitesData();
 }
 
-void GlobalMenuBarX11::TabRestoreServiceChanged(TabRestoreService* service) {
-  const TabRestoreService::Entries& entries = service->entries();
+void GlobalMenuBarX11::TabRestoreServiceChanged(
+    sessions::TabRestoreService* service) {
+  const sessions::TabRestoreService::Entries& entries = service->entries();
 
   ClearMenuSection(history_menu_, TAG_RECENTLY_CLOSED);
 
   // We'll get the index the "Recently Closed" header. (This can vary depending
   // on the number of "Most Visited" items.
   int index = GetIndexOfMenuItemWithTag(history_menu_,
                                         TAG_RECENTLY_CLOSED_HEADER) + 1;
 
   unsigned int 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 (entry->type == TabRestoreService::WINDOW) {
-      TabRestoreService::Window* entry_win =
-          static_cast<TabRestoreService::Window*>(entry);
-      std::vector<TabRestoreService::Tab>& tabs = entry_win->tabs;
+    if (entry->type == sessions::TabRestoreService::WINDOW) {
+      sessions::TabRestoreService::Window* entry_win =
+          static_cast<sessions::TabRestoreService::Window*>(entry);
+      std::vector<sessions::TabRestoreService::Tab>& tabs = entry_win->tabs;
       if (tabs.empty())
         continue;
 
       // Create the item for the parent/window.
       HistoryItem* item = new HistoryItem();
       item->session_id = entry_win->id;
 
       std::string title = l10n_util::GetPluralStringFUTF8(
           IDS_RECENTLY_CLOSED_WINDOW, tabs.size());
       DbusmenuMenuitem* parent_item = BuildMenuItem(
@@ skipping 15 matching lines @@
                              DeleteHistoryItem);
       menuitem_child_append(parent_item, restore_item);
       g_object_unref(restore_item);
 
       DbusmenuMenuitem* separator = BuildSeparator();
       menuitem_child_append(parent_item, separator);
       g_object_unref(separator);
 
       // Loop over the window's tabs and add them to the submenu.
       int subindex = 2;
-      std::vector<TabRestoreService::Tab>::const_iterator iter;
+      std::vector<sessions::TabRestoreService::Tab>::const_iterator iter;
       for (iter = tabs.begin(); iter != tabs.end(); ++iter) {
-        TabRestoreService::Tab tab = *iter;
+        sessions::TabRestoreService::Tab tab = *iter;
         HistoryItem* tab_item = HistoryItemForTab(tab);
         item->tabs.push_back(tab_item);
         AddHistoryItemToMenu(tab_item,
                              parent_item,
                              TAG_RECENTLY_CLOSED,
                              subindex++);
       }
 
       ++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);
       AddHistoryItemToMenu(item,
                            history_menu_,
                            TAG_RECENTLY_CLOSED,
                            index++);
       ++added_count;
     }
   }
 }
 
 void GlobalMenuBarX11::TabRestoreServiceDestroyed(
-    TabRestoreService* service) {
+    sessions::TabRestoreService* service) {
   tab_restore_service_ = nullptr;
 }
 
 void GlobalMenuBarX11::OnWindowMapped(unsigned long xid) {
   if (!server_)
     InitServer(xid);
 
   GlobalMenuBarRegistrarX11::GetInstance()->OnWindowMapped(xid);
 }
 
 void GlobalMenuBarX11::OnWindowUnmapped(unsigned long xid) {
   GlobalMenuBarRegistrarX11::GetInstance()->OnWindowUnmapped(xid);
 }
 
 void GlobalMenuBarX11::OnItemActivated(DbusmenuMenuitem* item,
                                        unsigned int timestamp) {
   int id = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(item), "command-id"));
   chrome::ExecuteCommand(browser_, id);
 }
 
 void GlobalMenuBarX11::OnHistoryItemActivated(DbusmenuMenuitem* sender,
                                               unsigned int timestamp) {
   // Note: We don't have access to the event modifiers used to click the menu
   // item since that happens in a different process.
   HistoryItem* item = reinterpret_cast<HistoryItem*>(
       g_object_get_data(G_OBJECT(sender), kHistoryItem));
 
   // If this item can be restored using TabRestoreService, do so. Otherwise,
   // just load the URL.
-  TabRestoreService* service =
+  sessions::TabRestoreService* service =
       TabRestoreServiceFactory::GetForProfile(profile_);
   if (item->session_id && service) {
     service->RestoreEntryById(browser_->tab_restore_service_delegate(),
                               item->session_id, browser_->host_desktop_type(),
                               UNKNOWN);
   } else {
     DCHECK(item->url.is_valid());
     browser_->OpenURL(content::OpenURLParams(
         item->url,
         content::Referrer(),
@@ skipping 29 matching lines @@
   int id = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(sender), kProfileId));
   avatar_menu_->EditProfile(id);
 }
 
 void GlobalMenuBarX11::OnCreateProfileItemActivated(DbusmenuMenuitem* sender,
                                                     unsigned int timestamp) {
   profiles::CreateAndSwitchToNewProfile(chrome::HOST_DESKTOP_TYPE_NATIVE,
                                         ProfileManager::CreateCallback(),
                                         ProfileMetrics::ADD_NEW_USER_MENU);
 }