[sessions] Properly namespace recently-componentized TabRestore code

chrome/browser/extensions/api/sessions/sessions_api.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/extensions/api/sessions/sessions_api.h"
 
 #include <vector>
 
 #include "base/i18n/rtl.h"
 #include "base/lazy_instance.h"
@@ skipping 122 matching lines @@
   session_struct->last_modified = last_modified;
   if (tab)
     session_struct->tab = tab.Pass();
   else if (window)
     session_struct->window = window.Pass();
   else
     NOTREACHED();
   return session_struct.Pass();
 }
 
-bool is_tab_entry(const TabRestoreService::Entry* entry) {
-  return entry->type == TabRestoreService::TAB;
+bool is_tab_entry(const sessions::TabRestoreService::Entry* entry) {
+  return entry->type == sessions::TabRestoreService::TAB;
 }
 
-bool is_window_entry(const TabRestoreService::Entry* entry) {
-  return entry->type == TabRestoreService::WINDOW;
+bool is_window_entry(const sessions::TabRestoreService::Entry* entry) {
+  return entry->type == sessions::TabRestoreService::WINDOW;
 }
 
 scoped_ptr<tabs::Tab> SessionsGetRecentlyClosedFunction::CreateTabModel(
-    const TabRestoreService::Tab& tab, int session_id, int selected_index) {
+    const sessions::TabRestoreService::Tab& tab,
+    int session_id,
+    int selected_index) {
   return CreateTabModelHelper(GetProfile(),
                               tab.navigations[tab.current_navigation_index],
                               base::IntToString(session_id),
                               tab.tabstrip_index,
                               tab.pinned,
                               selected_index,
                               extension());
 }
 
 scoped_ptr<windows::Window>
-    SessionsGetRecentlyClosedFunction::CreateWindowModel(
-        const TabRestoreService::Window& window,
-        int session_id) {
+SessionsGetRecentlyClosedFunction::CreateWindowModel(
+    const sessions::TabRestoreService::Window& window,
+    int session_id) {
   DCHECK(!window.tabs.empty());
 
   scoped_ptr<std::vector<linked_ptr<tabs::Tab> > > tabs(
       new std::vector<linked_ptr<tabs::Tab> >);
   for (size_t i = 0; i < window.tabs.size(); ++i) {
     tabs->push_back(make_linked_ptr(
         CreateTabModel(window.tabs[i], window.tabs[i].id,
                        window.selected_tab_index).release()));
   }
 
   return CreateWindowModelHelper(tabs.Pass(), base::IntToString(session_id),
                                  windows::WINDOW_TYPE_NORMAL,
                                  windows::WINDOW_STATE_NORMAL);
 }
 
 scoped_ptr<api::sessions::Session>
-    SessionsGetRecentlyClosedFunction::CreateSessionModel(
-        const TabRestoreService::Entry* entry) {
+SessionsGetRecentlyClosedFunction::CreateSessionModel(
+    const sessions::TabRestoreService::Entry* entry) {
   scoped_ptr<tabs::Tab> tab;
   scoped_ptr<windows::Window> window;
   switch (entry->type) {
-    case TabRestoreService::TAB:
+    case sessions::TabRestoreService::TAB:
       tab = CreateTabModel(
-          *static_cast<const TabRestoreService::Tab*>(entry), entry->id, -1);
+          *static_cast<const sessions::TabRestoreService::Tab*>(entry),
+          entry->id, -1);
       break;
-    case TabRestoreService::WINDOW:
+    case sessions::TabRestoreService::WINDOW:
       window = CreateWindowModel(
-        *static_cast<const TabRestoreService::Window*>(entry), entry->id);
+          *static_cast<const sessions::TabRestoreService::Window*>(entry),
+          entry->id);
       break;
     default:
       NOTREACHED();
   }
   return CreateSessionModelHelper(entry->timestamp.ToTimeT(),
                                   tab.Pass(),
                                   window.Pass());
 }
 
 bool SessionsGetRecentlyClosedFunction::RunSync() {
   scoped_ptr<GetRecentlyClosed::Params> params(
       GetRecentlyClosed::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
   int max_results = api::sessions::MAX_SESSION_RESULTS;
   if (params->filter && params->filter->max_results)
     max_results = *params->filter->max_results;
   EXTENSION_FUNCTION_VALIDATE(max_results >= 0 &&
       max_results <= api::sessions::MAX_SESSION_RESULTS);
 
   std::vector<linked_ptr<api::sessions::Session> > result;
-  TabRestoreService* tab_restore_service =
+  sessions::TabRestoreService* tab_restore_service =
       TabRestoreServiceFactory::GetForProfile(GetProfile());
 
   // TabRestoreServiceFactory::GetForProfile() can return NULL (i.e., when in
   // incognito mode)
   if (!tab_restore_service) {
     DCHECK_NE(GetProfile(), GetProfile()->GetOriginalProfile())
-        << "TabRestoreService expected for normal profiles";
+        << "sessions::TabRestoreService expected for normal profiles";
     results_ = GetRecentlyClosed::Results::Create(
         std::vector<linked_ptr<api::sessions::Session> >());
     return true;
   }
 
   // List of entries. They are ordered from most to least recent.
   // We prune the list to contain max 25 entries at any time and removes
   // uninteresting entries.
-  TabRestoreService::Entries entries = tab_restore_service->entries();
-  for (TabRestoreService::Entries::const_iterator it = entries.begin();
+  sessions::TabRestoreService::Entries entries = tab_restore_service->entries();
+  for (sessions::TabRestoreService::Entries::const_iterator it =
+           entries.begin();
        it != entries.end() && static_cast<int>(result.size()) < max_results;
        ++it) {
-    TabRestoreService::Entry* entry = *it;
+    sessions::TabRestoreService::Entry* entry = *it;
     result.push_back(make_linked_ptr(CreateSessionModel(entry).release()));
   }
 
   results_ = GetRecentlyClosed::Results::Create(result);
   return true;
 }
 
 scoped_ptr<tabs::Tab> SessionsGetDevicesFunction::CreateTabModel(
     const std::string& session_tag,
     const sessions::SessionTab& tab,
@@ skipping 189 matching lines @@
   scoped_ptr<windows::Window> window(windows::Window::FromValue(
       *window_value));
   results_ = Restore::Results::Create(*CreateSessionModelHelper(
       base::Time::Now().ToTimeT(),
       scoped_ptr<tabs::Tab>(),
       window.Pass()));
   return true;
 }
 
 bool SessionsRestoreFunction::RestoreMostRecentlyClosed(Browser* browser) {
-  TabRestoreService* tab_restore_service =
+  sessions::TabRestoreService* tab_restore_service =
       TabRestoreServiceFactory::GetForProfile(GetProfile());
   chrome::HostDesktopType host_desktop_type = browser->host_desktop_type();
-  TabRestoreService::Entries entries = tab_restore_service->entries();
+  sessions::TabRestoreService::Entries entries = tab_restore_service->entries();
 
   if (entries.empty()) {
     SetError(kNoRecentlyClosedSessionsError);
     return false;
   }
 
   bool is_window = is_window_entry(entries.front());
-  TabRestoreServiceDelegate* delegate =
+  sessions::TabRestoreServiceDelegate* delegate =
       BrowserTabRestoreServiceDelegate::FindDelegateForWebContents(
           browser->tab_strip_model()->GetActiveWebContents());
   std::vector<sessions::LiveTab*> restored_tabs =
       tab_restore_service->RestoreMostRecentEntry(delegate, host_desktop_type);
   DCHECK(restored_tabs.size());
 
   sessions::ContentLiveTab* first_tab =
       static_cast<sessions::ContentLiveTab*>(restored_tabs[0]);
   if (is_window) {
     return SetResultRestoredWindow(
         ExtensionTabUtil::GetWindowIdOfTab(first_tab->web_contents()));
   }
 
   SetResultRestoredTab(first_tab->web_contents());
   return true;
 }
 
 bool SessionsRestoreFunction::RestoreLocalSession(const SessionId& session_id,
                                                   Browser* browser) {
-  TabRestoreService* tab_restore_service =
+  sessions::TabRestoreService* tab_restore_service =
       TabRestoreServiceFactory::GetForProfile(GetProfile());
   chrome::HostDesktopType host_desktop_type = browser->host_desktop_type();
-  TabRestoreService::Entries entries = tab_restore_service->entries();
+  sessions::TabRestoreService::Entries entries = tab_restore_service->entries();
 
   if (entries.empty()) {
     SetInvalidIdError(session_id.ToString());
     return false;
   }
 
   // Check if the recently closed list contains an entry with the provided id.
   bool is_window = false;
-  for (TabRestoreService::Entries::iterator it = entries.begin();
+  for (sessions::TabRestoreService::Entries::iterator it = entries.begin();
        it != entries.end(); ++it) {
     if ((*it)->id == session_id.id()) {
       // The only time a full window is being restored is if the entry ID
       // matches the provided ID and the entry type is Window.
       is_window = is_window_entry(*it);
       break;
     }
   }
 
-  TabRestoreServiceDelegate* delegate =
+  sessions::TabRestoreServiceDelegate* delegate =
       BrowserTabRestoreServiceDelegate::FindDelegateForWebContents(
           browser->tab_strip_model()->GetActiveWebContents());
   std::vector<sessions::LiveTab*> restored_tabs =
       tab_restore_service->RestoreEntryById(delegate, session_id.id(),
                                             host_desktop_type, UNKNOWN);
   // If the ID is invalid, restored_tabs will be empty.
   if (!restored_tabs.size()) {
     SetInvalidIdError(session_id.ToString());
     return false;
   }
@@ skipping 106 matching lines @@
     tab_restore_service_->AddObserver(this);
   }
 }
 
 SessionsEventRouter::~SessionsEventRouter() {
   if (tab_restore_service_)
     tab_restore_service_->RemoveObserver(this);
 }
 
 void SessionsEventRouter::TabRestoreServiceChanged(
-    TabRestoreService* service) {
+    sessions::TabRestoreService* service) {
   scoped_ptr<base::ListValue> args(new base::ListValue());
   EventRouter::Get(profile_)->BroadcastEvent(make_scoped_ptr(
       new Event(events::SESSIONS_ON_CHANGED,
                 api::sessions::OnChanged::kEventName, args.Pass())));
 }
 
 void SessionsEventRouter::TabRestoreServiceDestroyed(
-    TabRestoreService* service) {
+    sessions::TabRestoreService* service) {
   tab_restore_service_ = NULL;
 }
 
 SessionsAPI::SessionsAPI(content::BrowserContext* context)
     : browser_context_(context) {
   EventRouter::Get(browser_context_)->RegisterObserver(this,
       api::sessions::OnChanged::kEventName);
 }
 
 SessionsAPI::~SessionsAPI() {
@@ skipping 11 matching lines @@
   return g_factory.Pointer();
 }
 
 void SessionsAPI::OnListenerAdded(const EventListenerInfo& details) {
   sessions_event_router_.reset(
       new SessionsEventRouter(Profile::FromBrowserContext(browser_context_)));
   EventRouter::Get(browser_context_)->UnregisterObserver(this);
 }
 
 }  // namespace extensions