Session restore: Use the same TabLoader for all profiles.

chrome/browser/sessions/session_restore.cc

 // 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/sessions/session_restore.h"
 
 #include <algorithm>
 #include <list>
 #include <set>
 #include <string>
@@ skipping 36 matching lines @@
 #include "chrome/browser/chromeos/boot_times_loader.h"
 #endif
 
 using content::NavigationController;
 using content::RenderWidgetHost;
 using content::WebContents;
 
 namespace {
 
 class SessionRestoreImpl;
+class TabLoader;
+
+TabLoader* shared_tab_loader = NULL;
 
 // Pointers to SessionRestoreImpls which are currently restoring the session.
 std::set<SessionRestoreImpl*>* active_session_restorers = NULL;
 
 // TabLoader ------------------------------------------------------------------
 
 // Initial delay (see class decription for details).
 static const int kInitialDelayTimerMS = 100;
 
 // TabLoader is responsible for loading tabs after session restore creates
 // tabs. New tabs are loaded after the current tab finishes loading, or a delay
 // is reached (initially kInitialDelayTimerMS). If the delay is reached before
 // a tab finishes loading a new tab is loaded and the time of the delay
-// doubled. When all tabs are loading TabLoader deletes itself.
+// doubled.
+//
+// TabLoader keeps a reference to itself when it's loading. When it has finished
+// loading, it drops the reference. If another profile is restored while the
+// TabLoader is loading, it will schedule its tabs to get loaded by the same
+// TabLoader. When doing the scheduling, it holds a reference to the TabLoader.
 //
 // This is not part of SessionRestoreImpl so that synchronous destruction
 // of SessionRestoreImpl doesn't have timing problems.
 class TabLoader : public content::NotificationObserver,
-                  public net::NetworkChangeNotifier::OnlineStateObserver {
+                  public net::NetworkChangeNotifier::OnlineStateObserver,
+                  public base::RefCounted<TabLoader> {
  public:
-  explicit TabLoader(base::TimeTicks restore_started);
-  virtual ~TabLoader();
+  // Retrieves a pointer to the TabLoader instance shared between profiles, or
+  // creates a new TabLoader if it doesn't exist. If a TabLoader is created, its
+  // starting timestamp is set to |restore_started|.
+  static TabLoader* GetTabLoader(base::TimeTicks restore_started);
 
   // Schedules a tab for loading.
   void ScheduleLoad(NavigationController* controller);
 
   // Notifies the loader that a tab has been scheduled for loading through
   // some other mechanism.
   void TabIsLoading(NavigationController* controller);
 
   // Invokes |LoadNextTab| to load a tab.
   //
   // This must be invoked once to start loading.
   void StartLoading();
 
  private:
+  friend class base::RefCounted<TabLoader>;
+
   typedef std::set<NavigationController*> TabsLoading;
   typedef std::list<NavigationController*> TabsToLoad;
   typedef std::set<RenderWidgetHost*> RenderWidgetHostSet;
 
+  explicit TabLoader(base::TimeTicks restore_started);
+  virtual ~TabLoader();
+
   // Loads the next tab. If there are no more tabs to load this deletes itself,
   // otherwise |force_load_timer_| is restarted.
   void LoadNextTab();
 
   // NotificationObserver method. Removes the specified tab and loads the next
   // tab.
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
@@ skipping 48 matching lines @@
   int tab_count_;
 
   base::OneShotTimer<TabLoader> force_load_timer_;
 
   // The time the restore process started.
   base::TimeTicks restore_started_;
 
   // Max number of tabs that were loaded in parallel (for metrics).
   size_t max_parallel_tab_loads_;
 
+  // For keeping TabLoader alive while it's loading even if no
+  // SessionRestoreImpls reference it.
+  scoped_refptr<TabLoader> this_retainer_;
+
   DISALLOW_COPY_AND_ASSIGN(TabLoader);
 };
 
-TabLoader::TabLoader(base::TimeTicks restore_started)
-    : force_load_delay_(kInitialDelayTimerMS),
-      loading_(false),
-      got_first_paint_(false),
-      tab_count_(0),
-      restore_started_(restore_started),
-      max_parallel_tab_loads_(0) {
-}
-
-TabLoader::~TabLoader() {
-  DCHECK((got_first_paint_ || render_widget_hosts_to_paint_.empty()) &&
-          tabs_loading_.empty() && tabs_to_load_.empty());
-  net::NetworkChangeNotifier::RemoveOnlineStateObserver(this);
+// static
+TabLoader* TabLoader::GetTabLoader(base::TimeTicks restore_started) {
+  if (!shared_tab_loader)
+    shared_tab_loader = new TabLoader(restore_started);
+  return shared_tab_loader;
 }
 
 void TabLoader::ScheduleLoad(NavigationController* controller) {
   DCHECK(controller);
   DCHECK(find(tabs_to_load_.begin(), tabs_to_load_.end(), controller) ==
          tabs_to_load_.end());
   tabs_to_load_.push_back(controller);
   RegisterForNotifications(controller);
 }
 
 void TabLoader::TabIsLoading(NavigationController* controller) {
   DCHECK(controller);
   DCHECK(find(tabs_loading_.begin(), tabs_loading_.end(), controller) ==
          tabs_loading_.end());
   tabs_loading_.insert(controller);
   RenderWidgetHost* render_widget_host = GetRenderWidgetHost(controller);
   DCHECK(render_widget_host);
   render_widget_hosts_loading_.insert(render_widget_host);
   RegisterForNotifications(controller);
 }
 
 void TabLoader::StartLoading() {
+  // When multiple profiles are using the same TabLoader, another profile might
+  // already have started loading. In that case, the tabs scheduled for loading
+  // by this profile are already in the loading queue, and they will get loaded
+  // eventually.
+  if (loading_)
+    return;
   registrar_.Add(this, content::NOTIFICATION_RENDER_WIDGET_HOST_DID_PAINT,
                  content::NotificationService::AllSources());
+  this_retainer_ = this;
 #if defined(OS_CHROMEOS)
   if (!net::NetworkChangeNotifier::IsOffline()) {
     loading_ = true;
     LoadNextTab();
   } else {
     net::NetworkChangeNotifier::AddOnlineStateObserver(this);
   }
 #else
   loading_ = true;
   LoadNextTab();
 #endif
 }
 
+TabLoader::TabLoader(base::TimeTicks restore_started)
+    : force_load_delay_(kInitialDelayTimerMS),
+      loading_(false),
+      got_first_paint_(false),
+      tab_count_(0),
+      restore_started_(restore_started),
+      max_parallel_tab_loads_(0) {
+}
+
+TabLoader::~TabLoader() {
+  DCHECK((got_first_paint_ || render_widget_hosts_to_paint_.empty()) &&
+          tabs_loading_.empty() && tabs_to_load_.empty());
+  net::NetworkChangeNotifier::RemoveOnlineStateObserver(this);
+  shared_tab_loader = NULL;
+}
+
 void TabLoader::LoadNextTab() {
   if (!tabs_to_load_.empty()) {
     NavigationController* tab = tabs_to_load_.front();
     DCHECK(tab);
     tabs_loading_.insert(tab);
     if (tabs_loading_.size() > max_parallel_tab_loads_)
       max_parallel_tab_loads_ = tabs_loading_.size();
     tabs_to_load_.pop_front();
     tab->LoadIfNecessary();
     if (tab->GetWebContents()) {
@@ skipping 90 matching lines @@
           // happen because the user opened a different tab or restored tabs
           // to an already existing browser and an existing tab painted.
           got_first_paint_ = true;
         }
       }
       break;
     }
     default:
       NOTREACHED() << "Unknown notification received:" << type;
   }
-  // Delete ourselves when we're not waiting for any more notifications.
+  // Delete ourselves when we're not waiting for any more notifications. If this
+  // was not the last reference, a SessionRestoreImpl holding a reference will
+  // eventually call StartLoading (which assigns this_retainer_), or drop the
+  // reference without initiating a load.
   if ((got_first_paint_ || render_widget_hosts_to_paint_.empty()) &&
       tabs_loading_.empty() && tabs_to_load_.empty())
-    delete this;
+    this_retainer_ = NULL;
 }
 
 void TabLoader::OnOnlineStateChanged(bool online) {
   if (online) {
     if (!loading_) {
       loading_ = true;
       LoadNextTab();
     }
   } else {
     loading_ = false;
@@ skipping 247 matching lines @@
         NOTREACHED();
         break;
     }
   }
 
   Profile* profile() { return profile_; }
 
  private:
   // Invoked when beginning to create new tabs. Resets the tab_loader_.
   void StartTabCreation() {
-    tab_loader_.reset(new TabLoader(restore_started_));
+    tab_loader_ = TabLoader::GetTabLoader(restore_started_);
   }
 
   // Invoked when done with creating all the tabs/browsers.
   //
   // |created_tabbed_browser| indicates whether a tabbed browser was created,
   // or we used an existing tabbed browser.
   //
   // If successful, this begins loading tabs and deletes itself when all tabs
   // have been loaded.
   //
   // Returns the Browser that was created, if any.
   Browser* FinishedTabCreation(bool succeeded, bool created_tabbed_browser) {
     Browser* browser = NULL;
     if (!created_tabbed_browser && always_create_tabbed_browser_) {
       browser = Browser::Create(profile_);
       if (urls_to_open_.empty()) {
         // No tab browsers were created and no URLs were supplied on the command
         // line. Add an empty URL, which is treated as opening the users home
         // page.
         urls_to_open_.push_back(GURL());
       }
       AppendURLsToBrowser(browser, urls_to_open_);
       browser->window()->Show();
     }
 
     if (succeeded) {
       DCHECK(tab_loader_.get());
       // TabLoader deletes itself when done loading.
-      tab_loader_.release()->StartLoading();
+      tab_loader_->StartLoading();
+      tab_loader_ = NULL;
     }
 
     if (!synchronous_) {
       // If we're not synchronous we need to delete ourself.
       // NOTE: we must use DeleteLater here as most likely we're in a callback
       // from the history service which doesn't deal well with deleting the
       // object it is notifying.
       MessageLoop::current()->DeleteSoon(FROM_HERE, this);
     }
 
@@ skipping 297 matching lines @@
   // at least one window is created.
   const bool always_create_tabbed_browser_;
 
   // Set of URLs to open in addition to those restored from the session.
   std::vector<GURL> urls_to_open_;
 
   // Used to get the session.
   CancelableRequestConsumer request_consumer_;
 
   // Responsible for loading the tabs.
-  scoped_ptr<TabLoader> tab_loader_;
+  scoped_refptr<TabLoader> tab_loader_;
 
   // When synchronous we run a nested message loop. To avoid creating windows
   // from the nested message loop (which can make exiting the nested message
   // loop take a while) we cache the SessionWindows here and create the actual
   // windows when the nested message loop exits.
   std::vector<SessionWindow*> windows_;
 
   content::NotificationRegistrar registrar_;
 
   // The time we started the restore.
@@ skipping 63 matching lines @@
   if (active_session_restorers == NULL)
     return false;
   for (std::set<SessionRestoreImpl*>::const_iterator it =
            active_session_restorers->begin();
        it != active_session_restorers->end(); ++it) {
     if ((*it)->profile() == profile)
       return true;
   }
   return false;
 }