Decouple TabLoader from SessionRestore.

chrome/browser/sessions/session_restore.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/session_restore.h"
 
 #include <algorithm>
 #include <list>
 #include <set>
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/debug/alias.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/metrics/histogram.h"
 #include "base/run_loop.h"
 #include "base/stl_util.h"
 #include "base/task/cancelable_task_tracker.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/search/search.h"
+#include "chrome/browser/sessions/session_restore_delegate.h"
 #include "chrome/browser/sessions/session_service.h"
 #include "chrome/browser/sessions/session_service_factory.h"
 #include "chrome/browser/sessions/session_service_utils.h"
 #include "chrome/browser/sessions/tab_loader.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_navigator.h"
 #include "chrome/browser/ui/browser_tabrestore.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/browser/ui/browser_window.h"
@@ skipping 16 matching lines @@
 #include "extensions/browser/extension_registry.h"
 #include "extensions/common/extension_set.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/boot_times_recorder.h"
 #endif
 
 using content::NavigationController;
 using content::RenderWidgetHost;
 using content::WebContents;
+using RestoredTab = SessionRestoreDelegate::RestoredTab;
 
 namespace {
 
 class SessionRestoreImpl;
 
 // Pointers to SessionRestoreImpls which are currently restoring the session.
 std::set<SessionRestoreImpl*>* active_session_restorers = nullptr;
 
 // SessionRestoreImpl ---------------------------------------------------------
 
@@ skipping 76 matching lines @@
                      content::Source<Browser>(browser_));
     }
 
     return browser_;
   }
 
   // Restore window(s) from a foreign session. Returns newly created Browsers.
   std::vector<Browser*> RestoreForeignSession(
       std::vector<const sessions::SessionWindow*>::const_iterator begin,
       std::vector<const sessions::SessionWindow*>::const_iterator end) {
-    StartTabCreation();
     std::vector<Browser*> browsers;
-    std::vector<WebContents*> created_contents;
+    std::vector<RestoredTab> created_contents;
     // Create a browser instance to put the restored tabs in.
     for (std::vector<const sessions::SessionWindow*>::const_iterator i = begin;
          i != end; ++i) {
       Browser* browser =
           CreateRestoredBrowser(BrowserTypeForWindowType((*i)->type),
                                 (*i)->bounds, (*i)->show_state, (*i)->app_name);
       browsers.push_back(browser);
 
       // Restore and show the browser.
       const int initial_tab_count = 0;
       int selected_tab_index =
           std::max(0, std::min((*i)->selected_tab_index,
                                static_cast<int>((*i)->tabs.size()) - 1));
       RestoreTabsToBrowser(*(*i), browser, initial_tab_count,
                            selected_tab_index, &created_contents);
       NotifySessionServiceOfRestoredTabs(browser, initial_tab_count);
     }
 
     // Always create in a new window.
-    FinishedTabCreation(true, true);
+    FinishedTabCreation(true, true, created_contents);
 
     on_session_restored_callbacks_->Notify(
         static_cast<int>(created_contents.size()));
 
     return browsers;
   }
 
   // Restore a single tab from a foreign session.
   // Opens in the tab in the last active browser, unless disposition is
   // NEW_WINDOW, in which case the tab will be opened in a new browser. Returns
@@ skipping 71 matching lines @@
 
       default:
         NOTREACHED();
         break;
     }
   }
 
   Profile* profile() { return profile_; }
 
  private:
-  // Invoked when beginning to create new tabs. Resets the |tab_loader_|.
-  void StartTabCreation() {
-    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* FinishedTabCreation(
+      bool succeeded,
+      bool created_tabbed_browser,
+      const std::vector<RestoredTab>& contents_created) {
     Browser* browser = nullptr;
     if (!created_tabbed_browser && always_create_tabbed_browser_) {
       browser =
           new Browser(Browser::CreateParams(profile_, host_desktop_type_));
       if (urls_to_open_.empty()) {
         // No tab browsers were created and no URLs were supplied on the command
         // line. Open the new tab page.
         urls_to_open_.push_back(GURL(chrome::kChromeUINewTabURL));
       }
       AppendURLsToBrowser(browser, urls_to_open_);
       browser->window()->Show();
     }
 
     if (succeeded) {
-      DCHECK(tab_loader_.get());
-      // TabLoader deletes itself when done loading.
-      tab_loader_->StartLoading();
-      tab_loader_ = nullptr;
+      // Start Loading tabs.
+      SessionRestoreDelegate::RestoreTabs(contents_created, restore_started_);
     }
 
     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.
       base::MessageLoop::current()->DeleteSoon(FROM_HERE, this);
 
       // The delete may take a while and at this point we no longer care about
@@ skipping 30 matching lines @@
       quit_closure_for_sync_restore_.Run();
       return;
     }
 
     ProcessSessionWindowsAndNotify(&windows.get(), active_window_id);
   }
 
   Browser* ProcessSessionWindowsAndNotify(
       std::vector<sessions::SessionWindow*>* windows,
       SessionID::id_type active_window_id) {
-    std::vector<WebContents*> contents;
+    std::vector<RestoredTab> contents;
     Browser* result =
         ProcessSessionWindows(windows, active_window_id, &contents);
     on_session_restored_callbacks_->Notify(static_cast<int>(contents.size()));
     return result;
   }
 
   Browser* ProcessSessionWindows(std::vector<sessions::SessionWindow*>* windows,
                                  SessionID::id_type active_window_id,
-                                 std::vector<WebContents*>* created_contents) {
+                                 std::vector<RestoredTab>* created_contents) {
     DVLOG(1) << "ProcessSessionWindows " << windows->size();
     base::TimeDelta time_to_process_sessions =
         base::TimeTicks::Now() - restore_started_;
     UMA_HISTOGRAM_CUSTOM_TIMES("SessionRestore.TimeToProcessSessions",
                                time_to_process_sessions,
                                base::TimeDelta::FromMilliseconds(10),
                                base::TimeDelta::FromSeconds(1000), 100);
 
     if (windows->empty()) {
       // Restore was unsuccessful. The DOM storage system can also delete its
       // data, since no session restore will happen at a later point in time.
       content::BrowserContext::GetDefaultStoragePartition(profile_)
           ->GetDOMStorageContext()
           ->StartScavengingUnusedSessionStorage();
-      return FinishedTabCreation(false, false);
+      return FinishedTabCreation(false, false, *created_contents);
     }
 
 #if defined(OS_CHROMEOS)
     chromeos::BootTimesRecorder::Get()->AddLoginTimeMarker(
         "SessionRestore-CreatingTabs-Start", false);
 #endif
-    StartTabCreation();
 
     // After the for loop this contains the last TABBED_BROWSER. Is null if no
     // tabbed browsers exist.
     Browser* last_browser = nullptr;
     bool has_tabbed_browser = false;
 
     // After the for loop, this contains the browser to activate, if one of the
     // windows has the same id as specified in active_window_id.
     Browser* browser_to_activate = nullptr;
 
@@ skipping 72 matching lines @@
 #if defined(OS_CHROMEOS)
     chromeos::BootTimesRecorder::Get()->AddLoginTimeMarker(
         "SessionRestore-CreatingTabs-End", false);
 #endif
     if (browser_to_activate)
       browser_to_activate->window()->Activate();
 
     // If last_browser is NULL and urls_to_open_ is non-empty,
     // FinishedTabCreation will create a new TabbedBrowser and add the urls to
     // it.
-    Browser* finished_browser = FinishedTabCreation(true, has_tabbed_browser);
+    Browser* finished_browser =
+        FinishedTabCreation(true, has_tabbed_browser, *created_contents);
     if (finished_browser)
       last_browser = finished_browser;
 
     // sessionStorages needed for the session restore have now been recreated
     // by RestoreTab. Now it's safe for the DOM storage system to start
     // deleting leftover data.
     content::BrowserContext::GetDefaultStoragePartition(profile_)
         ->GetDOMStorageContext()
         ->StartScavengingUnusedSessionStorage();
     return last_browser;
@@ skipping 19 matching lines @@
   }
 
   // Adds the tabs from |window| to |browser|. Normal tabs go after the existing
   // tabs but pinned tabs will be pushed in front.
   // If there are no existing tabs, the tab at |selected_tab_index| will be
   // selected. Otherwise, the tab selection will remain untouched.
   void RestoreTabsToBrowser(const sessions::SessionWindow& window,
                             Browser* browser,
                             int initial_tab_count,
                             int selected_tab_index,
-                            std::vector<WebContents*>* created_contents) {
+                            std::vector<RestoredTab>* created_contents) {
     DVLOG(1) << "RestoreTabsToBrowser " << window.tabs.size();
     DCHECK(!window.tabs.empty());
     if (initial_tab_count == 0) {
       for (int i = 0; i < static_cast<int>(window.tabs.size()); ++i) {
         const sessions::SessionTab& tab = *(window.tabs[i]);
 
         // Loads are scheduled for each restored tab unless the tab is going to
         // be selected as ShowBrowser() will load the selected tab.
         bool is_selected_tab = (i == selected_tab_index);
-        WebContents* restored_tab =
-            RestoreTab(tab, i, browser, is_selected_tab);
+        WebContents* contents = RestoreTab(tab, i, browser, is_selected_tab);
 
         // RestoreTab can return nullptr if |tab| doesn't have valid data.
-        if (!restored_tab)
+        if (!contents)
           continue;
 
+        RestoredTab restored_tab;
+        restored_tab.contents = contents;
+        restored_tab.is_active = is_selected_tab;
         created_contents->push_back(restored_tab);
 
         // If this isn't the selected tab, there's nothing else to do.
         if (!is_selected_tab)
           continue;
 
         ShowBrowser(browser, browser->tab_strip_model()->GetIndexOfWebContents(
-                                 restored_tab));
+                                 contents));
         // TODO(sky): remove. For debugging 368236.
-        CHECK_EQ(browser->tab_strip_model()->GetActiveWebContents(),
-                 restored_tab);
-        tab_loader_->TabIsLoading(&browser->tab_strip_model()
-                                       ->GetActiveWebContents()
-                                       ->GetController());
+        CHECK_EQ(browser->tab_strip_model()->GetActiveWebContents(), contents);
       }
     } else {
       // If the browser already has tabs, we want to restore the new ones after
       // the existing ones. E.g. this happens in Win8 Metro where we merge
       // windows or when launching a hosted app from the app launcher.
       int tab_index_offset = initial_tab_count;
       for (int i = 0; i < static_cast<int>(window.tabs.size()); ++i) {
         const sessions::SessionTab& tab = *(window.tabs[i]);
         // Always schedule loads as we will not be calling ShowBrowser().
         WebContents* contents =
             RestoreTab(tab, tab_index_offset + i, browser, false);
-        if (contents)
-          created_contents->push_back(contents);
+        if (contents) {
+          RestoredTab restored_tab;
+          restored_tab.contents = contents;
+          restored_tab.is_active = false;
+          created_contents->push_back(restored_tab);
+        }
       }
     }
   }
 
   // |tab_index| is ignored for pinned tabs which will always be pushed behind
   // the last existing pinned tab.
   // |tab_loader_| will schedule this tab for loading if |is_selected_tab| is
   // false.
   WebContents* RestoreTab(const sessions::SessionTab& tab,
                           const int tab_index,
@@ skipping 23 matching lines @@
     WebContents* web_contents = chrome::AddRestoredTab(
         browser, tab.navigations, tab_index, selected_index,
         tab.extension_app_id,
         false,  // select
         tab.pinned, true, session_storage_namespace.get(),
         tab.user_agent_override);
     // Regression check: check that the tab didn't start loading right away. The
     // focused tab will be loaded by Browser, and TabLoader will load the rest.
     DCHECK(web_contents->GetController().NeedsReload());
 
-    if (!is_selected_tab)
-      tab_loader_->ScheduleLoad(&web_contents->GetController());
     return web_contents;
   }
 
   Browser* CreateRestoredBrowser(Browser::Type type,
                                  gfx::Rect bounds,
                                  ui::WindowShowState show_state,
                                  const std::string& app_name) {
     Browser::CreateParams params(type, profile_, host_desktop_type_);
     if (!app_name.empty()) {
       const bool trusted_source = true;  // We only store trusted app windows.
@@ skipping 223 matching lines @@
 // static
 SessionRestore::CallbackSubscription
     SessionRestore::RegisterOnSessionRestoredCallback(
         const base::Callback<void(int)>& callback) {
   return on_session_restored_callbacks()->Add(callback);
 }
 
 // static
 base::CallbackList<void(int)>*
     SessionRestore::on_session_restored_callbacks_ = nullptr;