Profile shouldn't own Session/TabRestore services.

chrome/browser/ui/browser.cc

 // Copyright (c) 2011 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/browser.h"
 
 #if defined(OS_WIN)
 #include <shellapi.h>
 #include <windows.h>
 #endif  // OS_WIN
@@ skipping 45 matching lines @@
 #include "chrome/browser/metrics/user_metrics.h"
 #include "chrome/browser/net/browser_url_util.h"
 #include "chrome/browser/net/url_fixer_upper.h"
 #include "chrome/browser/notifications/notification_ui_manager.h"
 #include "chrome/browser/platform_util.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/printing/cloud_print/cloud_print_setup_flow.h"
 #include "chrome/browser/printing/print_preview_tab_controller.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/session_service.h"
+#include "chrome/browser/sessions/session_service_factory.h"
 #include "chrome/browser/sessions/session_types.h"
 #include "chrome/browser/sessions/tab_restore_service.h"
+#include "chrome/browser/sessions/tab_restore_service_factory.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/sync_ui_util.h"
 #include "chrome/browser/tab_closeable_state_watcher.h"
 #include "chrome/browser/tab_contents/background_contents.h"
 #include "chrome/browser/tab_contents/simple_alert_infobar_delegate.h"
 #include "chrome/browser/tabs/tab_finder.h"
 #include "chrome/browser/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/blocked_content/blocked_content_tab_helper.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_tab_restore_service_delegate.h"
@@ skipping 179 matching lines @@
                              profile_->GetPrefs(), NULL);
   use_vertical_tabs_.Init(prefs::kUseVerticalTabs, profile_->GetPrefs(), this);
   instant_enabled_.Init(prefs::kInstantEnabled, profile_->GetPrefs(), this);
   if (!TabMenuModel::AreVerticalTabsEnabled()) {
     // If vertical tabs aren't enabled, explicitly turn them off. Otherwise we
     // might show vertical tabs but not show an option to turn them off.
     use_vertical_tabs_.SetValue(false);
   }
   UpdateTabStripModelInsertionPolicy();
 
-  tab_restore_service_ = profile->GetTabRestoreService();
+  tab_restore_service_ = TabRestoreServiceFactory::GetForProfile(profile);
   if (tab_restore_service_) {
     tab_restore_service_->AddObserver(this);
     TabRestoreServiceChanged(tab_restore_service_);
   }
 
   if (profile_->GetProfileSyncService())
     profile_->GetProfileSyncService()->AddObserver(this);
 
   CreateInstantIfNecessary();
 
@@ skipping 16 matching lines @@
   if (!BrowserList::HasBrowserWithProfile(profile_)) {
     // We're the last browser window with this profile. We need to nuke the
     // TabRestoreService, which will start the shutdown of the
     // NavigationControllers and allow for proper shutdown. If we don't do this
     // chrome won't shutdown cleanly, and may end up crashing when some
     // thread tries to use the IO thread (or another thread) that is no longer
     // valid.
     // This isn't a valid assumption for Mac OS, as it stays running after
     // the last browser has closed. The Mac equivalent is in its app
     // controller.
-    profile_->ResetTabRestoreService();
+    TabRestoreServiceFactory::ResetForProfile(profile_);
   }
 #endif
 
-  SessionService* session_service = profile_->GetSessionService();
+  SessionService* session_service =
+      SessionServiceFactory::GetForProfile(profile_);
   if (session_service)
     session_service->WindowClosed(session_id_);
 
-  TabRestoreService* tab_restore_service = profile()->GetTabRestoreService();
+  TabRestoreService* tab_restore_service =
+      TabRestoreServiceFactory::GetForProfile(profile());
   if (tab_restore_service)
     tab_restore_service->BrowserClosed(tab_restore_service_delegate());
 
   encoding_auto_detect_.Destroy();
   printing_enabled_.Destroy();
   dev_tools_disabled_.Destroy();
   incognito_mode_allowed_.Destroy();
   instant_enabled_.Destroy();
   use_vertical_tabs_.Destroy();
   edit_bookmarks_enabled_.Destroy();
@@ skipping 169 matching lines @@
 
 // static
 void Browser::OpenEmptyWindow(Profile* profile) {
   Browser* browser = Browser::Create(profile);
   browser->AddBlankTab(true);
   browser->window()->Show();
 }
 
 // static
 void Browser::OpenWindowWithRestoredTabs(Profile* profile) {
-  TabRestoreService* service = profile->GetTabRestoreService();
+  TabRestoreService* service = TabRestoreServiceFactory::GetForProfile(profile);
   if (service)
     service->RestoreMostRecentEntry(NULL);
 }
 
 // static
 void Browser::OpenURLOffTheRecord(Profile* profile, const GURL& url) {
   Browser* browser = GetOrCreateTabbedBrowser(
       profile->GetOffTheRecordProfile());
   browser->AddSelectedTabWithURL(url, PageTransition::LINK);
   browser->window()->Show();
@@ skipping 255 matching lines @@
 bool Browser::ShouldSaveWindowPlacement() const {
   // Only save the window placement of popups if they are restored.
   return (type() & TYPE_POPUP) == 0 || browser_defaults::kRestorePopups;
 }
 
 void Browser::SaveWindowPlacement(const gfx::Rect& bounds, bool maximized) {
   // Save to the session storage service, used when reloading a past session.
   // Note that we don't want to be the ones who cause lazy initialization of
   // the session service. This function gets called during initial window
   // showing, and we don't want to bring in the session service this early.
-  if (profile()->HasSessionService()) {
-    SessionService* session_service = profile()->GetSessionService();
-    if (session_service)
-      session_service->SetWindowBounds(session_id_, bounds, maximized);
-  }
+  SessionService* session_service =
+      SessionServiceFactory::GetForProfileIfExisting(profile());
+  if (session_service)
+    session_service->SetWindowBounds(session_id_, bounds, maximized);
 }
 
 gfx::Rect Browser::GetSavedWindowBounds() const {
   const CommandLine& parsed_command_line = *CommandLine::ForCurrentProcess();
   bool record_mode = parsed_command_line.HasSwitch(switches::kRecordMode);
   bool playback_mode = parsed_command_line.HasSwitch(switches::kPlaybackMode);
   if (record_mode || playback_mode) {
     // In playback/record mode we always fix the size of the browser and
     // move it to (0,0).  The reason for this is two reasons:  First we want
     // resize/moves in the playback to still work, and Second we want
@@ skipping 112 matching lines @@
   // AppController on the Mac, or BackgroundContentsService for background
   // pages).
   bool should_quit_if_last_browser =
       browser_shutdown::IsTryingToQuit() || !BrowserList::WillKeepAlive();
 
   if (should_quit_if_last_browser && BrowserList::size() == 1) {
     browser_shutdown::OnShutdownStarting(browser_shutdown::WINDOW_CLOSE);
     exiting = true;
   }
 
-  // Don't use HasSessionService here, we want to force creation of the
+  // Don't use GetForProfileIfExisting here, we want to force creation of the
   // session service so that user can restore what was open.
-  SessionService* session_service = profile()->GetSessionService();
+  SessionService* session_service =
+      SessionServiceFactory::GetForProfile(profile());
   if (session_service)
     session_service->WindowClosing(session_id());
 
-  TabRestoreService* tab_restore_service = profile()->GetTabRestoreService();
+  TabRestoreService* tab_restore_service =
+      TabRestoreServiceFactory::GetForProfile(profile());
   if (tab_restore_service && type() == TYPE_NORMAL && tab_count())
     tab_restore_service->BrowserClosing(tab_restore_service_delegate());
 
   // TODO(sky): convert session/tab restore to use notification.
   NotificationService::current()->Notify(
       NotificationType::BROWSER_CLOSING,
       Source<Browser>(this),
       Details<bool>(&exiting));
 
   CloseAllTabs();
@@ skipping 149 matching lines @@
   } else {
     // We set the size of the view here, before WebKit does its initial
     // layout.  If we don't, the initial layout of background tabs will be
     // performed with a view width of 0, which may cause script outputs and
     // anchor link location calculations to be incorrect even after a new
     // layout with proper view dimensions. TabStripModel::AddTabContents()
     // contains similar logic.
     new_tab->view()->SizeContents(window_->GetRestoredBounds().size());
     new_tab->HideContents();
   }
-  if (profile_->HasSessionService()) {
-    SessionService* session_service = profile_->GetSessionService();
-    if (session_service)
-      session_service->TabRestored(&new_tab->controller(), pin);
-  }
+  SessionService* session_service =
+      SessionServiceFactory::GetForProfileIfExisting(profile_);
+  if (session_service)
+    session_service->TabRestored(&new_tab->controller(), pin);
   return new_tab;
 }
 
 void Browser::ReplaceRestoredTab(
     const std::vector<TabNavigation>& navigations,
     int selected_navigation,
     bool from_last_session,
     const std::string& extension_app_id,
     SessionStorageNamespace* session_storage_namespace) {
   TabContentsWrapper* wrapper = TabContentsFactory(profile(), NULL,
@@ skipping 273 matching lines @@
 
 void Browser::NewWindow() {
   if (browser_defaults::kAlwaysOpenIncognitoWindow &&
       CommandLine::ForCurrentProcess()->HasSwitch(switches::kIncognito) &&
       incognito_mode_allowed_.GetValue()) {
     NewIncognitoWindow();
     return;
   }
   UserMetrics::RecordAction(UserMetricsAction("NewWindow"), profile_);
   SessionService* session_service =
-      profile_->GetOriginalProfile()->GetSessionService();
+      SessionServiceFactory::GetForProfile(profile_->GetOriginalProfile());
   if (!session_service ||
       !session_service->RestoreIfNecessary(std::vector<GURL>())) {
     Browser::OpenEmptyWindow(profile_->GetOriginalProfile());
   }
 }
 
 void Browser::NewIncognitoWindow() {
   if (!incognito_mode_allowed_.GetValue()) {
     NewWindow();
     return;
@@ skipping 79 matching lines @@
   tab_handler_->GetTabStripModel()->SelectLastTab();
 }
 
 void Browser::DuplicateTab() {
   UserMetrics::RecordAction(UserMetricsAction("Duplicate"), profile_);
   DuplicateContentsAt(active_index());
 }
 
 void Browser::RestoreTab() {
   UserMetrics::RecordAction(UserMetricsAction("RestoreTab"), profile_);
-  TabRestoreService* service = profile_->GetTabRestoreService();
+  TabRestoreService* service =
+      TabRestoreServiceFactory::GetForProfile(profile_);
   if (!service)
     return;
 
   service->RestoreMostRecentEntry(tab_restore_service_delegate());
 }
 
 void Browser::WriteCurrentURLToClipboard() {
   // TODO(ericu): There isn't currently a metric for this.  Should there be?
   // We don't appear to track the action when it comes from the
   // RenderContextViewMenu.
@@ skipping 1086 matching lines @@
                           window()->GetRestoredBounds().size()));
 
     // We need to show the browser now.  Otherwise ContainerWin assumes the
     // TabContents is invisible and won't size it.
     browser->window()->Show();
 
     // The page transition below is only for the purpose of inserting the tab.
     browser->AddTab(contents_dupe, PageTransition::LINK);
   }
 
-  if (profile_->HasSessionService()) {
-    SessionService* session_service = profile_->GetSessionService();
-    if (session_service)
-      session_service->TabRestored(&new_contents->controller(), pinned);
-  }
+  SessionService* session_service =
+      SessionServiceFactory::GetForProfileIfExisting(profile_);
+  if (session_service)
+    session_service->TabRestored(&new_contents->controller(), pinned);
 }
 
 void Browser::CloseFrameAfterDragSession() {
 #if defined(OS_WIN) || defined(OS_LINUX)
   // This is scheduled to run after we return to the message loop because
   // otherwise the frame will think the drag session is still active and ignore
   // the request.
   // TODO(port): figure out what is required here in a cross-platform world
   MessageLoop::current()->PostTask(
       FROM_HERE, method_factory_.NewRunnableMethod(&Browser::CloseFrame));
 #endif
 }
 
 void Browser::CreateHistoricalTab(TabContentsWrapper* contents) {
   // We don't create historical tabs for incognito windows or windows without
   // profiles.
-  if (!profile() || profile()->IsOffTheRecord() ||
-      !profile()->GetTabRestoreService()) {
+  if (!profile() || profile()->IsOffTheRecord())
     return;
-  }
+
+  TabRestoreService* service =
+      TabRestoreServiceFactory::GetForProfile(profile());
 
   // We only create historical tab entries for tabbed browser windows.
-  if (CanSupportWindowFeature(FEATURE_TABSTRIP)) {
-    profile()->GetTabRestoreService()->CreateHistoricalTab(
-        &contents->controller(),
+  if (service && CanSupportWindowFeature(FEATURE_TABSTRIP)) {
+    service->CreateHistoricalTab(&contents->controller(),
         tab_handler_->GetTabStripModel()->GetIndexOfTabContents(contents));
   }
 }
 
 bool Browser::RunUnloadListenerBeforeClosing(TabContentsWrapper* contents) {
   return Browser::RunUnloadEventsHelper(contents->tab_contents());
 }
 
 bool Browser::CanReloadContents(TabContents* source) const {
   return type() != TYPE_DEVTOOLS;
@@ skipping 141 matching lines @@
     status_bubble->SetStatus(GetSelectedTabContentsWrapper()->GetStatusText());
   }
 
   if (HasFindBarController()) {
     find_bar_controller_->ChangeTabContents(new_contents);
     find_bar_controller_->find_bar()->MoveWindowIfNecessary(gfx::Rect(), true);
   }
 
   // Update sessions. Don't force creation of sessions. If sessions doesn't
   // exist, the change will be picked up by sessions when created.
-  if (profile_->HasSessionService()) {
-    SessionService* session_service = profile_->GetSessionService();
-    if (session_service && !tab_handler_->GetTabStripModel()->closing_all()) {
-      session_service->SetSelectedTabInWindow(
-          session_id(), tab_handler_->GetTabStripModel()->active_index());
-    }
+  SessionService* session_service =
+      SessionServiceFactory::GetForProfileIfExisting(profile_);
+  if (session_service && !tab_handler_->GetTabStripModel()->closing_all()) {
+    session_service->SetSelectedTabInWindow(
+        session_id(), tab_handler_->GetTabStripModel()->active_index());
   }
 }
 
 void Browser::TabMoved(TabContentsWrapper* contents,
                        int from_index,
                        int to_index) {
   DCHECK(from_index >= 0 && to_index >= 0);
   // Notify the history service.
   SyncHistoryWithTabs(std::min(from_index, to_index));
 }
 
 void Browser::TabReplacedAt(TabStripModel* tab_strip_model,
                             TabContentsWrapper* old_contents,
                             TabContentsWrapper* new_contents,
                             int index) {
   TabDetachedAtImpl(old_contents, index, DETACH_TYPE_REPLACE);
   TabInsertedAt(new_contents, index,
                 (index == tab_handler_->GetTabStripModel()->active_index()));
 
   int entry_count = new_contents->controller().entry_count();
   if (entry_count > 0) {
     // Send out notification so that observers are updated appropriately.
     new_contents->controller().NotifyEntryChanged(
         new_contents->controller().GetEntryAtIndex(entry_count - 1),
         entry_count - 1);
   }
 
-  SessionService* session_service = profile()->GetSessionService();
+  SessionService* session_service =
+      SessionServiceFactory::GetForProfile(profile());
   if (session_service) {
     // The new_contents may end up with a different navigation stack. Force
     // the session service to update itself.
     session_service->TabRestored(
         &new_contents->controller(),
         tab_handler_->GetTabStripModel()->IsTabPinned(index));
   }
 
   DevToolsManager* devtools_manager = DevToolsManager::GetInstance();
   if (devtools_manager)  // NULL in unit tests.
     devtools_manager->TabReplaced(old_contents, new_contents);
 }
 
 void Browser::TabPinnedStateChanged(TabContentsWrapper* contents, int index) {
-  if (!profile()->HasSessionService())
-    return;
-  SessionService* session_service = profile()->GetSessionService();
+  SessionService* session_service =
+      SessionServiceFactory::GetForProfileIfExisting(profile());
   if (session_service) {
     session_service->SetPinnedState(
         session_id(),
         GetTabContentsAt(index)->controller().session_id(),
         tab_handler_->GetTabStripModel()->IsTabPinned(index));
   }
 }
 
 void Browser::TabStripEmpty() {
   // Close the frame after we return to the message loop (not immediately,
@@ skipping 1145 matching lines @@
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kKioskMode))
     return NULL;
 #endif
   return window_ ? window_->GetStatusBubble() : NULL;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, Session restore functions (private):
 
 void Browser::SyncHistoryWithTabs(int index) {
-  if (!profile()->HasSessionService())
-    return;
-  SessionService* session_service = profile()->GetSessionService();
+  SessionService* session_service =
+      SessionServiceFactory::GetForProfileIfExisting(profile());
   if (session_service) {
     for (int i = index; i < tab_count(); ++i) {
       TabContents* contents = GetTabContentsAt(i);
       if (contents) {
         session_service->SetTabIndexInWindow(
             session_id(), contents->controller().session_id(), i);
         session_service->SetPinnedState(
             session_id(),
             contents->controller().session_id(),
             tab_handler_->GetTabStripModel()->IsTabPinned(i));
@@ skipping 433 matching lines @@
                           window()->GetRestoredBounds().size()));
 
     // We need to show the browser now. Otherwise ContainerWin assumes the
     // TabContents is invisible and won't size it.
     browser->window()->Show();
 
     // The page transition below is only for the purpose of inserting the tab.
     browser->AddTab(view_source_contents, PageTransition::LINK);
   }
 
-  if (profile_->HasSessionService()) {
-    SessionService* session_service = profile_->GetSessionService();
-    if (session_service)
-      session_service->TabRestored(&view_source_contents->controller(), false);
-  }
+  SessionService* session_service =
+      SessionServiceFactory::GetForProfileIfExisting(profile_);
+  if (session_service)
+    session_service->TabRestored(&view_source_contents->controller(), false);
 }
 
 int Browser::GetContentRestrictionsForSelectedTab() {
   int content_restrictions = 0;
   TabContents* current_tab = GetSelectedTabContents();
   if (current_tab) {
     content_restrictions = current_tab->content_restrictions();
     NavigationEntry* active_entry = current_tab->controller().GetActiveEntry();
     // See comment in UpdateCommandsForTabState about why we call url().
     if (!SavePackage::IsSavableURL(active_entry ? active_entry->url() : GURL()))
       content_restrictions |= CONTENT_RESTRICTION_SAVE;
   }
   return content_restrictions;
 }