Return webcontents and add in test.

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 549 matching lines @@
     }
 
     if (browser_) {
       registrar_.Add(this, chrome::NOTIFICATION_BROWSER_CLOSED,
                      content::Source<Browser>(browser_));
     }
 
     return browser_;
   }
 
-  // Restore window(s) from a foreign session.
-  void RestoreForeignSession(
+  // Restore window(s) from a foreign session. Returns newly created Browsers.
+  std::vector<Browser*> RestoreForeignSession(
       std::vector<const SessionWindow*>::const_iterator begin,
       std::vector<const SessionWindow*>::const_iterator end) {
     StartTabCreation();
+    std::vector<Browser*> browsers;
     // Create a browser instance to put the restored tabs in.
     for (std::vector<const SessionWindow*>::const_iterator i = begin;
          i != end; ++i) {
       Browser* browser = CreateRestoredBrowser(
           static_cast<Browser::Type>((*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);
       NotifySessionServiceOfRestoredTabs(browser, initial_tab_count);
     }
 
     // Always create in a new window
     FinishedTabCreation(true, true);
+    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.
-  void RestoreForeignTab(const SessionTab& tab,
-                         WindowOpenDisposition disposition) {
+  // NEW_WINDOW, in which case the tab will be opened in a new browser. Returns
+  // the WebContents of the restored tab.
+  WebContents* RestoreForeignTab(const SessionTab& tab,
+                                 WindowOpenDisposition disposition) {
     DCHECK(!tab.navigations.empty());
     int selected_index = tab.current_navigation_index;
     selected_index = std::max(
         0,
         std::min(selected_index,
                  static_cast<int>(tab.navigations.size() - 1)));
 
     bool use_new_window = disposition == NEW_WINDOW;
 
     Browser* browser = use_new_window ?
         new Browser(Browser::CreateParams(profile_, host_desktop_type_)) :
         browser_;
 
     RecordAppLaunchForTab(browser, tab, selected_index);
 
+    WebContents* web_contents;
     if (disposition == CURRENT_TAB) {
       DCHECK(!use_new_window);
-      chrome::ReplaceRestoredTab(browser,
-                                 tab.navigations,
-                                 selected_index,
-                                 true,
-                                 tab.extension_app_id,
-                                 NULL,
-                                 tab.user_agent_override);
+      web_contents = chrome::ReplaceRestoredTab(browser,
+                                                tab.navigations,
+                                                selected_index,
+                                                true,
+                                                tab.extension_app_id,
+                                                NULL,
+                                                tab.user_agent_override);
     } else {
       int tab_index =
           use_new_window ? 0 : browser->tab_strip_model()->active_index() + 1;
-      WebContents* web_contents = chrome::AddRestoredTab(
+      web_contents = chrome::AddRestoredTab(
           browser,
           tab.navigations,
           tab_index,
           selected_index,
           tab.extension_app_id,
           disposition == NEW_FOREGROUND_TAB,  // selected
           tab.pinned,
           true,
           NULL,
           tab.user_agent_override);
       // Start loading the tab immediately.
       web_contents->GetController().LoadIfNecessary();
     }
 
     if (use_new_window) {
       browser->tab_strip_model()->ActivateTabAt(0, true);
       browser->window()->Show();
     }
     NotifySessionServiceOfRestoredTabs(browser,
                                        browser->tab_strip_model()->count());
 
     // Since FinishedTabCreation() is not called here, |this| will leak if we
     // are not in sychronous mode.
     DCHECK(synchronous_);
+    return web_contents;
   }
 
   virtual ~SessionRestoreImpl() {
     STLDeleteElements(&windows_);
 
     active_session_restorers->erase(this);
     if (active_session_restorers->empty()) {
       delete active_session_restorers;
       active_session_restorers = NULL;
     }
@@ skipping 546 matching lines @@
   // SessionRestoreImpl takes care of deleting itself when done.
   SessionRestoreImpl* restorer = new SessionRestoreImpl(
       profile, browser, host_desktop_type, (behavior & SYNCHRONOUS) != 0,
       (behavior & CLOBBER_CURRENT_TAB) != 0,
       (behavior & ALWAYS_CREATE_TABBED_BROWSER) != 0,
       urls_to_open);
   return restorer->Restore();
 }
 
 // static
-void SessionRestore::RestoreForeignSessionWindows(
+std::vector<Browser*> SessionRestore::RestoreForeignSessionWindows(
     Profile* profile,
     chrome::HostDesktopType host_desktop_type,
     std::vector<const SessionWindow*>::const_iterator begin,
     std::vector<const SessionWindow*>::const_iterator end) {
   std::vector<GURL> gurls;
   SessionRestoreImpl restorer(profile,
       static_cast<Browser*>(NULL), host_desktop_type, true, false, true, gurls);
-  restorer.RestoreForeignSession(begin, end);
+  return restorer.RestoreForeignSession(begin, end);
 }
 
 // static
-void SessionRestore::RestoreForeignSessionTab(
+WebContents* SessionRestore::RestoreForeignSessionTab(
     content::WebContents* source_web_contents,
     const SessionTab& tab,
     WindowOpenDisposition disposition) {
   Browser* browser = chrome::FindBrowserWithWebContents(source_web_contents);
   Profile* profile = browser->profile();
   std::vector<GURL> gurls;
   SessionRestoreImpl restorer(profile, browser, browser->host_desktop_type(),
                               true, false, false, gurls);
-  restorer.RestoreForeignTab(tab, disposition);
+  return restorer.RestoreForeignTab(tab, disposition);
 }
 
 // static
 bool SessionRestore::IsRestoring(const Profile* profile) {
   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;
 }
 
 // static
 bool SessionRestore::IsRestoringSynchronously() {
   if (!active_session_restorers)
     return false;
   for (std::set<SessionRestoreImpl*>::const_iterator it =
            active_session_restorers->begin();
        it != active_session_restorers->end(); ++it) {
     if ((*it)->synchronous())
       return true;
   }
   return false;
 }