Return webcontents and add in test.

chrome/browser/sessions/session_restore_browsertest.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 <vector>
+
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/process/launch.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/defaults.h"
 #include "chrome/browser/first_run/first_run.h"
 #include "chrome/browser/profiles/profile.h"
@@ skipping 334 matching lines @@
 
   // Find the SessionID for entry2. Since the session service was destroyed,
   // there is no guarantee that the SessionID for the tab has remained the same.
   base::Time timestamp;
   for (std::vector<TabRestoreService::Tab>::const_iterator it =
            window->tabs.begin(); it != window->tabs.end(); ++it) {
     const TabRestoreService::Tab& tab = *it;
     // If this tab held url2, then restore this single tab.
     if (tab.navigations[0].virtual_url() == url2) {
       timestamp = tab.navigations[0].timestamp();
-      service->RestoreEntryById(NULL, tab.id, host_desktop_type, UNKNOWN);
+      std::vector<content::WebContents*> content =
+          service->RestoreEntryById(NULL, tab.id, host_desktop_type, UNKNOWN);
+      ASSERT_EQ(1U, content.size());
+      ASSERT_TRUE(content[0]);
+      EXPECT_EQ(url2, content[0]->GetURL());
       break;
     }
   }
   EXPECT_FALSE(timestamp.is_null());
 
   // Make sure that the restored tab is removed from the service.
   ASSERT_EQ(1U, service->entries().size());
   ASSERT_EQ(TabRestoreService::WINDOW, service->entries().front()->type);
   window = static_cast<TabRestoreService::Window*>(service->entries().front());
   EXPECT_EQ(2U, window->tabs.size());
@@ skipping 27 matching lines @@
   // Close the window.
   browser()->window()->Close();
 
   // Expect the window to be converted to a tab by the TRS.
   EXPECT_EQ(1U, service->entries().size());
   ASSERT_EQ(TabRestoreService::TAB, service->entries().front()->type);
   const TabRestoreService::Tab* tab =
       static_cast<TabRestoreService::Tab*>(service->entries().front());
 
   // Restore the tab.
-  service->RestoreEntryById(NULL, tab->id, host_desktop_type, UNKNOWN);
+  std::vector<content::WebContents*> content =
+      service->RestoreEntryById(NULL, tab->id, host_desktop_type, UNKNOWN);
+  ASSERT_EQ(1U, content.size());
+  ASSERT_TRUE(content[0]);
+  EXPECT_EQ(url, content[0]->GetURL());
 
   // Make sure the restore was successful.
   EXPECT_EQ(0U, service->entries().size());
 }
 
 #if !defined(OS_CHROMEOS)
 // This test does not apply to ChromeOS as ChromeOS does not do session
 // restore when a new window is open.
 
 // Verifies we remember the last browser window when closing the last
@@ skipping 62 matching lines @@
 
   SessionTab tab;
   tab.SetFromSyncData(sync_data, base::Time::Now());
   EXPECT_EQ(2U, tab.navigations.size());
   for (size_t i = 0; i < tab.navigations.size(); ++i)
     EXPECT_TRUE(tab.navigations[i].timestamp().is_null());
 
   ASSERT_EQ(1, browser()->tab_strip_model()->count());
 
   // Restore in the current tab.
+  content::WebContents* tab_content = NULL;
   {
     content::WindowedNotificationObserver observer(
         content::NOTIFICATION_LOAD_STOP,
         content::NotificationService::AllSources());
-    SessionRestore::RestoreForeignSessionTab(
+    tab_content = SessionRestore::RestoreForeignSessionTab(
         browser()->tab_strip_model()->GetActiveWebContents(), tab, CURRENT_TAB);
     observer.Wait();
   }
   ASSERT_EQ(1, browser()->tab_strip_model()->count());
   content::WebContents* web_contents =
       browser()->tab_strip_model()->GetWebContentsAt(0);
   VerifyNavigationEntries(web_contents->GetController(), url1, url2);
   ASSERT_TRUE(web_contents->GetUserAgentOverride().empty());
+  ASSERT_TRUE(tab_content);
+  ASSERT_EQ(url2, tab_content->GetURL());
 
   // Restore in a new tab.
+  tab_content = NULL;
   {
     content::WindowedNotificationObserver observer(
         content::NOTIFICATION_LOAD_STOP,
         content::NotificationService::AllSources());
-    SessionRestore::RestoreForeignSessionTab(
+    tab_content = SessionRestore::RestoreForeignSessionTab(
         browser()->tab_strip_model()->GetActiveWebContents(),
         tab, NEW_BACKGROUND_TAB);
     observer.Wait();
   }
   ASSERT_EQ(2, browser()->tab_strip_model()->count());
   ASSERT_EQ(0, browser()->tab_strip_model()->active_index());
   web_contents = browser()->tab_strip_model()->GetWebContentsAt(1);
   VerifyNavigationEntries(web_contents->GetController(), url1, url2);
   ASSERT_TRUE(web_contents->GetUserAgentOverride().empty());
+  ASSERT_TRUE(tab_content);
+  ASSERT_EQ(url2, tab_content->GetURL());
 
   // Restore in a new window.
   Browser* new_browser = NULL;
+  tab_content = NULL;
   {
     ui_test_utils::BrowserAddedObserver browser_observer;
     content::WindowedNotificationObserver observer(
         content::NOTIFICATION_LOAD_STOP,
         content::NotificationService::AllSources());
-    SessionRestore::RestoreForeignSessionTab(
+    tab_content = SessionRestore::RestoreForeignSessionTab(
         browser()->tab_strip_model()->GetActiveWebContents(), tab, NEW_WINDOW);
     new_browser = browser_observer.WaitForSingleNewBrowser();
     observer.Wait();
   }
 
   ASSERT_EQ(1, new_browser->tab_strip_model()->count());
   web_contents = new_browser->tab_strip_model()->GetWebContentsAt(0);
   VerifyNavigationEntries(web_contents->GetController(), url1, url2);
   ASSERT_TRUE(web_contents->GetUserAgentOverride().empty());
+  ASSERT_TRUE(tab_content);
+  ASSERT_EQ(url2, tab_content->GetURL());
 }
 
 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, RestoreForeignSession) {
   Profile* profile = browser()->profile();
 
   GURL url1("http://google.com");
   GURL url2("http://google2.com");
   SerializedNavigationEntry nav1 =
       SerializedNavigationEntryTestHelper::CreateNavigation(url1.spec(), "one");
   SerializedNavigationEntry nav2 =
@@ skipping 20 matching lines @@
     sync_data.set_tab_visual_index(1);
     sync_data.set_current_navigation_index(0);
     sync_data.set_pinned(false);
     sync_data.add_navigation()->CopyFrom(nav2.ToSyncData());
     tab2.SetFromSyncData(sync_data, base::Time::Now());
   }
   window.tabs.push_back(&tab2);
 
   session.push_back(static_cast<const SessionWindow*>(&window));
   ui_test_utils::BrowserAddedObserver window_observer;
-  SessionRestore::RestoreForeignSessionWindows(
-      profile, browser()->host_desktop_type(), session.begin(), session.end());
+  std::vector<Browser*> browsers =
+      SessionRestore::RestoreForeignSessionWindows(
+          profile, browser()->host_desktop_type(), session.begin(),
+          session.end());
   Browser* new_browser = window_observer.WaitForSingleNewBrowser();
   ASSERT_TRUE(new_browser);
   ASSERT_EQ(2u, active_browser_list_->size());
   ASSERT_EQ(2, new_browser->tab_strip_model()->count());
 
+  ASSERT_EQ(1u, browsers.size());
+  ASSERT_TRUE(browsers[0]);
+  ASSERT_EQ(2, browsers[0]->tab_strip_model()->count());
+
   content::WebContents* web_contents_1 =
       new_browser->tab_strip_model()->GetWebContentsAt(0);
   content::WebContents* web_contents_2 =
       new_browser->tab_strip_model()->GetWebContentsAt(1);
   ASSERT_EQ(url1, web_contents_1->GetURL());
   ASSERT_EQ(url2, web_contents_2->GetURL());
 
   // Check user agent override state.
   ASSERT_TRUE(web_contents_1->GetUserAgentOverride().empty());
   ASSERT_TRUE(web_contents_2->GetUserAgentOverride().empty());
@@ skipping 526 matching lines @@
   content::NavigationController* controller =
       &browser()->tab_strip_model()->GetActiveWebContents()->GetController();
   EXPECT_TRUE(
       controller->GetDefaultSessionStorageNamespace()->should_persist());
 
   // Quit and restore. Check that no extra tabs were created.
   Browser* new_browser = QuitBrowserAndRestore(browser(), 1);
   ASSERT_EQ(1u, active_browser_list_->size());
   EXPECT_EQ(1, new_browser->tab_strip_model()->count());
 }