Remove Profile and HostDesktopType dependencies from core TabRestore code

chrome/browser/sessions/tab_restore_service_helper.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/sessions/tab_restore_service_helper.h"
 
 #include <algorithm>
 #include <iterator>
 
 #include "base/logging.h"
@@ skipping 28 matching lines @@
     Entries::const_iterator entry_iterator) {
 }
 
 void TabRestoreServiceHelper::Observer::OnAddEntry() {}
 
 // TabRestoreServiceHelper -----------------------------------------------------
 
 TabRestoreServiceHelper::TabRestoreServiceHelper(
     TabRestoreService* tab_restore_service,
     Observer* observer,
-    Profile* profile,
     sessions::TabRestoreServiceClient* client,
     TabRestoreService::TimeFactory* time_factory)
     : tab_restore_service_(tab_restore_service),
       observer_(observer),
-      profile_(profile),
       client_(client),
       restoring_(false),
       time_factory_(time_factory) {
   DCHECK(tab_restore_service_);
 }
 
 TabRestoreServiceHelper::~TabRestoreServiceHelper() {
   FOR_EACH_OBSERVER(TabRestoreServiceObserver, observer_list_,
                     TabRestoreServiceDestroyed(tab_restore_service_));
   STLDeleteElements(&entries_);
 }
 
 void TabRestoreServiceHelper::AddObserver(
     TabRestoreServiceObserver* observer) {
   observer_list_.AddObserver(observer);
 }
 
 void TabRestoreServiceHelper::RemoveObserver(
     TabRestoreServiceObserver* observer) {
   observer_list_.RemoveObserver(observer);
 }
 
 void TabRestoreServiceHelper::CreateHistoricalTab(
     content::WebContents* contents,
     int index) {
   if (restoring_)
     return;
 
   TabRestoreServiceDelegate* delegate =
-      TabRestoreServiceDelegate::FindDelegateForWebContents(contents);
+      client_->FindTabRestoreServiceDelegateForWebContents(contents);
   if (closing_delegates_.find(delegate) != closing_delegates_.end())
     return;
 
   scoped_ptr<Tab> local_tab(new Tab());
   PopulateTab(local_tab.get(), index, delegate, &contents->GetController());
   if (local_tab->navigations.empty())
     return;
 
   AddEntry(local_tab.release(), true, true);
 }
@@ skipping 50 matching lines @@
   NotifyTabsChanged();
 }
 
 const TabRestoreService::Entries& TabRestoreServiceHelper::entries() const {
   return entries_;
 }
 
 std::vector<content::WebContents*>
 TabRestoreServiceHelper::RestoreMostRecentEntry(
     TabRestoreServiceDelegate* delegate,
-    chrome::HostDesktopType host_desktop_type) {
+    int host_desktop_type) {
   if (entries_.empty())
     return std::vector<WebContents*>();
 
   return RestoreEntryById(delegate, entries_.front()->id, host_desktop_type,
       UNKNOWN);
 }
 
 TabRestoreService::Tab* TabRestoreServiceHelper::RemoveTabEntryById(
     SessionID::id_type id) {
   Entries::iterator i = GetEntryIteratorById(id);
   if (i == entries_.end())
     return NULL;
 
   Entry* entry = *i;
   if (entry->type != TabRestoreService::TAB)
     return NULL;
 
   Tab* tab = static_cast<Tab*>(entry);
   entries_.erase(i);
   return tab;
 }
 
 std::vector<content::WebContents*> TabRestoreServiceHelper::RestoreEntryById(
     TabRestoreServiceDelegate* delegate,
     SessionID::id_type id,
-    chrome::HostDesktopType host_desktop_type,
+    int host_desktop_type,
     WindowOpenDisposition disposition) {
   Entries::iterator entry_iterator = GetEntryIteratorById(id);
   if (entry_iterator == entries_.end())
     // Don't hoark here, we allow an invalid id.
     return std::vector<WebContents*>();
 
   if (observer_)
     observer_->OnRestoreEntryById(id, entry_iterator);
   restoring_ = true;
   Entry* entry = *entry_iterator;
@@ skipping 19 matching lines @@
     web_contents.push_back(restored_tab);
     delegate->ShowBrowserWindow();
   } else if (entry->type == TabRestoreService::WINDOW) {
     TabRestoreServiceDelegate* current_delegate = delegate;
     Window* window = static_cast<Window*>(entry);
 
     // When restoring a window, either the entire window can be restored, or a
     // single tab within it. If the entry's ID matches the one to restore, then
     // the entire window will be restored.
     if (!restoring_tab_in_window) {
-      delegate = TabRestoreServiceDelegate::Create(profile_, host_desktop_type,
-                                                   window->app_name);
+      delegate = client_->CreateTabRestoreServiceDelegate(host_desktop_type,
+                                                          window->app_name);
       for (size_t tab_i = 0; tab_i < window->tabs.size(); ++tab_i) {
         const Tab& tab = window->tabs[tab_i];
         WebContents* restored_tab = delegate->AddRestoredTab(
             tab.navigations,
             delegate->GetTabCount(),
             tab.current_navigation_index,
             tab.extension_app_id,
             static_cast<int>(tab_i) == window->selected_tab_index,
             tab.pinned,
             tab.from_last_session,
@@ skipping 190 matching lines @@
   // Delegate may be NULL during unit tests.
   if (delegate) {
     tab->browser_id = delegate->GetSessionID().id();
     tab->pinned = delegate->IsTabPinned(tab->tabstrip_index);
   }
 }
 
 TabRestoreServiceDelegate* TabRestoreServiceHelper::RestoreTab(
     const Tab& tab,
     TabRestoreServiceDelegate* delegate,
-    chrome::HostDesktopType host_desktop_type,
+    int host_desktop_type,
     WindowOpenDisposition disposition,
     WebContents** contents) {
   WebContents* web_contents;
   if (disposition == CURRENT_TAB && delegate) {
     web_contents = delegate->ReplaceRestoredTab(
         tab.navigations,
         tab.current_navigation_index,
         tab.from_last_session,
         tab.extension_app_id,
         tab.session_storage_namespace.get(),
         tab.user_agent_override);
   } else {
     // We only respsect the tab's original browser if there's no disposition.
     if (disposition == UNKNOWN && tab.has_browser()) {
-      delegate = TabRestoreServiceDelegate::FindDelegateWithID(
-                     tab.browser_id, host_desktop_type);
+      delegate = client_->FindTabRestoreServiceDelegateWithID(
+          tab.browser_id, host_desktop_type);
     }
 
     int tab_index = -1;
 
     // |delegate| will be NULL in cases where one isn't already available (eg,
     // when invoked on Mac OS X with no windows open). In this case, create a
     // new browser into which we restore the tabs.
     if (delegate && disposition != NEW_WINDOW) {
       tab_index = tab.tabstrip_index;
     } else {
-      delegate = TabRestoreServiceDelegate::Create(profile_, host_desktop_type,
-                                                   std::string());
+      delegate = client_->CreateTabRestoreServiceDelegate(host_desktop_type,
+                                                          std::string());
       if (tab.has_browser())
         UpdateTabBrowserIDs(tab.browser_id, delegate->GetSessionID().id());
     }
 
     // Place the tab at the end if the tab index is no longer valid or
     // we were passed a specific disposition.
     if (tab_index < 0 || tab_index > delegate->GetTabCount() ||
         disposition != UNKNOWN) {
       tab_index = delegate->GetTabCount();
     }
@@ skipping 97 matching lines @@
       Tab* tab = static_cast<Tab*>(entry);
       if (tab->browser_id == old_id)
         tab->browser_id = new_id;
     }
   }
 }
 
 base::Time TabRestoreServiceHelper::TimeNow() const {
   return time_factory_ ? time_factory_->TimeNow() : base::Time::Now();
 }