src/chrome/browser/sessions/session_restore_browsertest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <vector>
   6
   7 #include "base/command_line.h"
   8 #include "base/files/file_path.h"
   9 #include "base/process/launch.h"
  10 #include "base/strings/utf_string_conversions.h"
  11 #include "base/time/time.h"
  12 #include "chrome/browser/browser_process.h"
  13 #include "chrome/browser/chrome_notification_types.h"
  14 #include "chrome/browser/defaults.h"
  15 #include "chrome/browser/first_run/first_run.h"
  16 #include "chrome/browser/profiles/profile.h"
  17 #include "chrome/browser/profiles/profile_manager.h"
  18 #include "chrome/browser/sessions/session_restore.h"
  19 #include "chrome/browser/sessions/session_service.h"
  20 #include "chrome/browser/sessions/session_service_factory.h"
  21 #include "chrome/browser/sessions/session_service_test_helper.h"
  22 #include "chrome/browser/sessions/session_types.h"
  23 #include "chrome/browser/sessions/tab_restore_service.h"
  24 #include "chrome/browser/sessions/tab_restore_service_factory.h"
  25 #include "chrome/browser/ui/browser.h"
  26 #include "chrome/browser/ui/browser_commands.h"
  27 #include "chrome/browser/ui/browser_list.h"
  28 #include "chrome/browser/ui/browser_tabstrip.h"
  29 #include "chrome/browser/ui/browser_window.h"
  30 #include "chrome/browser/ui/host_desktop.h"
  31 #include "chrome/browser/ui/tabs/tab_strip_model.h"
  32 #include "chrome/common/chrome_switches.h"
  33 #include "chrome/common/url_constants.h"
  34 #include "chrome/test/base/in_process_browser_test.h"
  35 #include "chrome/test/base/test_switches.h"
  36 #include "chrome/test/base/ui_test_utils.h"
  37 #include "components/sessions/serialized_navigation_entry_test_helper.h"
  38 #include "content/public/browser/navigation_controller.h"
  39 #include "content/public/browser/navigation_entry.h"
  40 #include "content/public/browser/notification_service.h"
  41 #include "content/public/browser/notification_types.h"
  42 #include "content/public/browser/render_process_host.h"
  43 #include "content/public/browser/render_view_host.h"
  44 #include "content/public/browser/web_contents.h"
  45 #include "content/public/common/bindings_policy.h"
  46 #include "content/public/common/page_transition_types.h"
  47 #include "content/public/test/test_navigation_observer.h"
  48 #include "sync/protocol/session_specifics.pb.h"
  49
  50 using sessions::SerializedNavigationEntry;
  51 using sessions::SerializedNavigationEntryTestHelper;
  52
  53 #if defined(OS_MACOSX)
  54 #include "base/mac/scoped_nsautorelease_pool.h"
  55 #endif
  56
  57 class SessionRestoreTest : public InProcessBrowserTest {
  58  public:
  59   SessionRestoreTest() : active_browser_list_(NULL) {}
  60
  61  protected:
  62 #if defined(OS_CHROMEOS)
  63   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
  64     // TODO(nkostylev): Investigate if we can remove this switch.
  65     command_line->AppendSwitch(switches::kCreateBrowserOnStartupForTests);
  66     InProcessBrowserTest::SetUpCommandLine(command_line);
  67   }
  68 #endif
  69
  70   virtual void SetUpOnMainThread() OVERRIDE {
  71     active_browser_list_ = BrowserList::GetInstance(chrome::GetActiveDesktop());
  72
  73     SessionStartupPref pref(SessionStartupPref::LAST);
  74     SessionStartupPref::SetStartupPref(browser()->profile(), pref);
  75 #if defined(OS_CHROMEOS) || defined(OS_MACOSX)
  76     const testing::TestInfo* const test_info =
  77         testing::UnitTest::GetInstance()->current_test_info();
  78     if (strcmp(test_info->name(), "NoSessionRestoreNewWindowChromeOS")) {
  79       // Undo the effect of kBrowserAliveWithNoWindows in defaults.cc so that we
  80       // can get these test to work without quitting.
  81       SessionServiceTestHelper helper(
  82           SessionServiceFactory::GetForProfile(browser()->profile()));
  83       helper.SetForceBrowserNotAliveWithNoWindows(true);
  84       helper.ReleaseService();
  85     }
  86 #endif
  87
  88     InProcessBrowserTest::SetUpOnMainThread();
  89   }
  90
  91   virtual bool SetUpUserDataDirectory() OVERRIDE {
  92     url1_ = ui_test_utils::GetTestUrl(
  93         base::FilePath().AppendASCII("session_history"),
  94         base::FilePath().AppendASCII("bot1.html"));
  95     url2_ = ui_test_utils::GetTestUrl(
  96         base::FilePath().AppendASCII("session_history"),
  97         base::FilePath().AppendASCII("bot2.html"));
  98     url3_ = ui_test_utils::GetTestUrl(
  99         base::FilePath().AppendASCII("session_history"),
 100         base::FilePath().AppendASCII("bot3.html"));
 101
 102     return InProcessBrowserTest::SetUpUserDataDirectory();
 103   }
 104
 105   void CloseBrowserSynchronously(Browser* browser) {
 106     content::WindowedNotificationObserver observer(
 107         chrome::NOTIFICATION_BROWSER_CLOSED,
 108         content::NotificationService::AllSources());
 109     browser->window()->Close();
 110 #if defined(OS_MACOSX)
 111     // BrowserWindowController depends on the auto release pool being recycled
 112     // in the message loop to delete itself, which frees the Browser object
 113     // which fires this event.
 114     AutoreleasePool()->Recycle();
 115 #endif
 116     observer.Wait();
 117   }
 118
 119   Browser* QuitBrowserAndRestore(Browser* browser, int expected_tab_count) {
 120     return QuitBrowserAndRestoreWithURL(browser, expected_tab_count, GURL());
 121   }
 122
 123   Browser* QuitBrowserAndRestoreWithURL(Browser* browser,
 124                                         int expected_tab_count,
 125                                         const GURL& url) {
 126     Profile* profile = browser->profile();
 127
 128     // Close the browser.
 129     g_browser_process->AddRefModule();
 130     CloseBrowserSynchronously(browser);
 131
 132     // Create a new window, which should trigger session restore.
 133     ui_test_utils::BrowserAddedObserver window_observer;
 134     content::WindowedNotificationObserver restore_observer(
 135         chrome::NOTIFICATION_SESSION_RESTORE_DONE,
 136         content::NotificationService::AllSources());
 137     if (url.is_empty()) {
 138       chrome::NewEmptyWindow(profile, chrome::HOST_DESKTOP_TYPE_NATIVE);
 139     } else {
 140       chrome::NavigateParams params(profile,
 141                                     url,
 142                                     content::PAGE_TRANSITION_LINK);
 143       chrome::Navigate(&params);
 144     }
 145     Browser* new_browser = window_observer.WaitForSingleNewBrowser();
 146     restore_observer.Wait();
 147     g_browser_process->ReleaseModule();
 148
 149     return new_browser;
 150   }
 151
 152   void GoBack(Browser* browser) {
 153     content::TestNavigationObserver observer(
 154         browser->tab_strip_model()->GetActiveWebContents());
 155     chrome::GoBack(browser, CURRENT_TAB);
 156     observer.Wait();
 157   }
 158
 159   void GoForward(Browser* browser) {
 160     content::TestNavigationObserver observer(
 161         browser->tab_strip_model()->GetActiveWebContents());
 162     chrome::GoForward(browser, CURRENT_TAB);
 163     observer.Wait();
 164   }
 165
 166   void AssertOneWindowWithOneTab(Browser* browser) {
 167     ASSERT_EQ(1u, active_browser_list_->size());
 168     ASSERT_EQ(1, browser->tab_strip_model()->count());
 169   }
 170
 171   int RenderProcessHostCount() {
 172     content::RenderProcessHost::iterator hosts =
 173         content::RenderProcessHost::AllHostsIterator();
 174     int count = 0;
 175     while (!hosts.IsAtEnd()) {
 176       if (hosts.GetCurrentValue()->HasConnection())
 177         count++;
 178       hosts.Advance();
 179     }
 180     return count;
 181   }
 182
 183   GURL url1_;
 184   GURL url2_;
 185   GURL url3_;
 186
 187   const BrowserList* active_browser_list_;
 188 };
 189
 190 #if defined(OS_CHROMEOS)
 191 // Verify that session restore does not occur when a user opens a browser window
 192 // when no other browser windows are open on ChromeOS.
 193 // TODO(pkotwicz): Add test which doesn't open incognito browser once
 194 // disable-zero-browsers-open-for-tests is removed.
 195 // (http://crbug.com/119175)
 196 // TODO(pkotwicz): Mac should have the behavior outlined by this test. It should
 197 // not do session restore if an incognito window is already open.
 198 // (http://crbug.com/120927)
 199 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, NoSessionRestoreNewWindowChromeOS) {
 200   GURL url(ui_test_utils::GetTestUrl(
 201       base::FilePath(base::FilePath::kCurrentDirectory),
 202       base::FilePath(FILE_PATH_LITERAL("title1.html"))));
 203
 204   // Add a single tab.
 205   ui_test_utils::NavigateToURL(browser(), url);
 206
 207   Browser* incognito_browser = CreateIncognitoBrowser();
 208   chrome::AddTabAt(incognito_browser, GURL(), -1, true);
 209   incognito_browser->window()->Show();
 210
 211   // Close the normal browser. After this we only have the incognito window
 212   // open.
 213   CloseBrowserSynchronously(browser());
 214
 215   // Create a new window, which should open NTP.
 216   ui_test_utils::BrowserAddedObserver browser_added_observer;
 217   chrome::NewWindow(incognito_browser);
 218   Browser* new_browser = browser_added_observer.WaitForSingleNewBrowser();
 219
 220   ASSERT_TRUE(new_browser);
 221   EXPECT_EQ(1, new_browser->tab_strip_model()->count());
 222   EXPECT_EQ(GURL(chrome::kChromeUINewTabURL),
 223             new_browser->tab_strip_model()->GetWebContentsAt(0)->GetURL());
 224 }
 225
 226 // Test that maximized applications get restored maximized.
 227 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, MaximizedApps) {
 228   const char* app_name = "TestApp";
 229   Browser* app_browser = CreateBrowserForApp(app_name, browser()->profile());
 230   app_browser->window()->Maximize();
 231   app_browser->window()->Show();
 232   EXPECT_TRUE(app_browser->window()->IsMaximized());
 233   EXPECT_TRUE(app_browser->is_app());
 234   EXPECT_TRUE(app_browser->is_type_popup());
 235
 236   // Close the normal browser. After this we only have the app_browser window.
 237   CloseBrowserSynchronously(browser());
 238
 239   // Create a new window, which should open NTP.
 240   ui_test_utils::BrowserAddedObserver browser_added_observer;
 241   chrome::NewWindow(app_browser);
 242   Browser* new_browser = browser_added_observer.WaitForSingleNewBrowser();
 243
 244   ASSERT_TRUE(new_browser);
 245   EXPECT_TRUE(app_browser->window()->IsMaximized());
 246   EXPECT_TRUE(app_browser->is_app());
 247   EXPECT_TRUE(app_browser->is_type_popup());
 248 }
 249 #endif  // OS_CHROMEOS
 250
 251 #if !defined(OS_CHROMEOS)
 252 // This test does not apply to ChromeOS as it does not do session restore when
 253 // a new window is opened.
 254
 255 #if defined(OS_LINUX) && defined(TOOLKIT_VIEWS)
 256 // Crashes on Linux Views: http://crbug.com/39476
 257 #define MAYBE_RestoreOnNewWindowWithNoTabbedBrowsers \
 258         DISABLED_RestoreOnNewWindowWithNoTabbedBrowsers
 259 #else
 260 #define MAYBE_RestoreOnNewWindowWithNoTabbedBrowsers \
 261         RestoreOnNewWindowWithNoTabbedBrowsers
 262 #endif
 263
 264 // Makes sure when session restore is triggered in the same process we don't end
 265 // up with an extra tab.
 266 IN_PROC_BROWSER_TEST_F(SessionRestoreTest,
 267                        MAYBE_RestoreOnNewWindowWithNoTabbedBrowsers) {
 268   if (browser_defaults::kRestorePopups)
 269     return;
 270
 271   const base::FilePath::CharType* kTitle1File =
 272       FILE_PATH_LITERAL("title1.html");
 273   GURL url(ui_test_utils::GetTestUrl(base::FilePath(
 274       base::FilePath::kCurrentDirectory), base::FilePath(kTitle1File)));
 275   ui_test_utils::NavigateToURL(browser(), url);
 276
 277   // Turn on session restore.
 278   SessionStartupPref::SetStartupPref(
 279       browser()->profile(),
 280       SessionStartupPref(SessionStartupPref::LAST));
 281
 282   // Create a new popup.
 283   Profile* profile = browser()->profile();
 284   Browser* popup =
 285       new Browser(Browser::CreateParams(Browser::TYPE_POPUP, profile,
 286                                         browser()->host_desktop_type()));
 287   popup->window()->Show();
 288
 289   // Close the browser.
 290   CloseBrowserSynchronously(browser());
 291
 292   // Create a new window, which should trigger session restore.
 293   ui_test_utils::BrowserAddedObserver observer;
 294   chrome::NewWindow(popup);
 295   Browser* new_browser = observer.WaitForSingleNewBrowser();
 296
 297   ASSERT_TRUE(new_browser != NULL);
 298
 299   // The browser should only have one tab.
 300   ASSERT_EQ(1, new_browser->tab_strip_model()->count());
 301
 302   // And the first url should be url.
 303   EXPECT_EQ(url, new_browser->tab_strip_model()->GetWebContentsAt(0)->GetURL());
 304 }
 305 #endif  // !OS_CHROMEOS
 306
 307 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, RestoreIndividualTabFromWindow) {
 308   GURL url1(ui_test_utils::GetTestUrl(
 309       base::FilePath(base::FilePath::kCurrentDirectory),
 310       base::FilePath(FILE_PATH_LITERAL("title1.html"))));
 311   // Any page that will yield a 200 status code will work here.
 312   GURL url2("about:version");
 313   GURL url3(ui_test_utils::GetTestUrl(
 314       base::FilePath(base::FilePath::kCurrentDirectory),
 315       base::FilePath(FILE_PATH_LITERAL("title3.html"))));
 316
 317   // Add and navigate three tabs.
 318   ui_test_utils::NavigateToURL(browser(), url1);
 319   {
 320     content::WindowedNotificationObserver observer(
 321         content::NOTIFICATION_LOAD_STOP,
 322         content::NotificationService::AllSources());
 323     chrome::AddSelectedTabWithURL(browser(), url2,
 324                                   content::PAGE_TRANSITION_LINK);
 325     observer.Wait();
 326   }
 327   {
 328     content::WindowedNotificationObserver observer(
 329         content::NOTIFICATION_LOAD_STOP,
 330         content::NotificationService::AllSources());
 331     chrome::AddSelectedTabWithURL(browser(), url3,
 332                                   content::PAGE_TRANSITION_LINK);
 333     observer.Wait();
 334   }
 335
 336   TabRestoreService* service =
 337       TabRestoreServiceFactory::GetForProfile(browser()->profile());
 338   service->ClearEntries();
 339
 340   chrome::HostDesktopType host_desktop_type = browser()->host_desktop_type();
 341
 342   browser()->window()->Close();
 343
 344   // Expect a window with three tabs.
 345   ASSERT_EQ(1U, service->entries().size());
 346   ASSERT_EQ(TabRestoreService::WINDOW, service->entries().front()->type);
 347   const TabRestoreService::Window* window =
 348       static_cast<TabRestoreService::Window*>(service->entries().front());
 349   EXPECT_EQ(3U, window->tabs.size());
 350
 351   // Find the SessionID for entry2. Since the session service was destroyed,
 352   // there is no guarantee that the SessionID for the tab has remained the same.
 353   base::Time timestamp;
 354   int http_status_code = 0;
 355   for (std::vector<TabRestoreService::Tab>::const_iterator it =
 356            window->tabs.begin(); it != window->tabs.end(); ++it) {
 357     const TabRestoreService::Tab& tab = *it;
 358     // If this tab held url2, then restore this single tab.
 359     if (tab.navigations[0].virtual_url() == url2) {
 360       timestamp = tab.navigations[0].timestamp();
 361       http_status_code = tab.navigations[0].http_status_code();
 362       std::vector<content::WebContents*> content =
 363           service->RestoreEntryById(NULL, tab.id, host_desktop_type, UNKNOWN);
 364       ASSERT_EQ(1U, content.size());
 365       ASSERT_TRUE(content[0]);
 366       EXPECT_EQ(url2, content[0]->GetURL());
 367       break;
 368     }
 369   }
 370   EXPECT_FALSE(timestamp.is_null());
 371   EXPECT_EQ(200, http_status_code);
 372
 373   // Make sure that the restored tab is removed from the service.
 374   ASSERT_EQ(1U, service->entries().size());
 375   ASSERT_EQ(TabRestoreService::WINDOW, service->entries().front()->type);
 376   window = static_cast<TabRestoreService::Window*>(service->entries().front());
 377   EXPECT_EQ(2U, window->tabs.size());
 378
 379   // Make sure that the restored tab was restored with the correct
 380   // timestamp and status code.
 381   const content::WebContents* contents =
 382       browser()->tab_strip_model()->GetActiveWebContents();
 383   ASSERT_TRUE(contents);
 384   const content::NavigationEntry* entry =
 385       contents->GetController().GetActiveEntry();
 386   ASSERT_TRUE(entry);
 387   EXPECT_EQ(timestamp, entry->GetTimestamp());
 388   EXPECT_EQ(http_status_code, entry->GetHttpStatusCode());
 389 }
 390
 391 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, WindowWithOneTab) {
 392   GURL url(ui_test_utils::GetTestUrl(
 393       base::FilePath(base::FilePath::kCurrentDirectory),
 394       base::FilePath(FILE_PATH_LITERAL("title1.html"))));
 395
 396   // Add a single tab.
 397   ui_test_utils::NavigateToURL(browser(), url);
 398
 399   TabRestoreService* service =
 400       TabRestoreServiceFactory::GetForProfile(browser()->profile());
 401   service->ClearEntries();
 402   EXPECT_EQ(0U, service->entries().size());
 403
 404   chrome::HostDesktopType host_desktop_type = browser()->host_desktop_type();
 405
 406   // Close the window.
 407   browser()->window()->Close();
 408
 409   // Expect the window to be converted to a tab by the TRS.
 410   EXPECT_EQ(1U, service->entries().size());
 411   ASSERT_EQ(TabRestoreService::TAB, service->entries().front()->type);
 412   const TabRestoreService::Tab* tab =
 413       static_cast<TabRestoreService::Tab*>(service->entries().front());
 414
 415   // Restore the tab.
 416   std::vector<content::WebContents*> content =
 417       service->RestoreEntryById(NULL, tab->id, host_desktop_type, UNKNOWN);
 418   ASSERT_EQ(1U, content.size());
 419   ASSERT_TRUE(content[0]);
 420   EXPECT_EQ(url, content[0]->GetURL());
 421
 422   // Make sure the restore was successful.
 423   EXPECT_EQ(0U, service->entries().size());
 424 }
 425
 426 #if !defined(OS_CHROMEOS)
 427 // This test does not apply to ChromeOS as ChromeOS does not do session
 428 // restore when a new window is open.
 429
 430 // Verifies we remember the last browser window when closing the last
 431 // non-incognito window while an incognito window is open.
 432 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, IncognitotoNonIncognito) {
 433   GURL url(ui_test_utils::GetTestUrl(
 434       base::FilePath(base::FilePath::kCurrentDirectory),
 435       base::FilePath(FILE_PATH_LITERAL("title1.html"))));
 436
 437   // Add a single tab.
 438   ui_test_utils::NavigateToURL(browser(), url);
 439
 440   // Create a new incognito window.
 441   Browser* incognito_browser = CreateIncognitoBrowser();
 442   chrome::AddTabAt(incognito_browser, GURL(), -1, true);
 443   incognito_browser->window()->Show();
 444
 445   // Close the normal browser. After this we only have the incognito window
 446   // open.
 447   CloseBrowserSynchronously(browser());
 448
 449   // Create a new window, which should trigger session restore.
 450   ui_test_utils::BrowserAddedObserver browser_added_observer;
 451   chrome::NewWindow(incognito_browser);
 452   Browser* new_browser = browser_added_observer.WaitForSingleNewBrowser();
 453
 454   // The first tab should have 'url' as its url.
 455   ASSERT_TRUE(new_browser);
 456   EXPECT_EQ(url, new_browser->tab_strip_model()->GetWebContentsAt(0)->GetURL());
 457 }
 458 #endif  // !OS_CHROMEOS
 459
 460 namespace {
 461
 462 // Verifies that the given NavigationController has exactly two
 463 // entries that correspond to the given URLs and that all but the last
 464 // entry have null timestamps.
 465 void VerifyNavigationEntries(
 466     const content::NavigationController& controller,
 467     GURL url1, GURL url2) {
 468   ASSERT_EQ(2, controller.GetEntryCount());
 469   EXPECT_EQ(1, controller.GetCurrentEntryIndex());
 470   EXPECT_EQ(url1, controller.GetEntryAtIndex(0)->GetURL());
 471   EXPECT_EQ(url2, controller.GetEntryAtIndex(1)->GetURL());
 472   EXPECT_TRUE(controller.GetEntryAtIndex(0)->GetTimestamp().is_null());
 473   EXPECT_FALSE(controller.GetEntryAtIndex(1)->GetTimestamp().is_null());
 474 }
 475
 476 }  // namespace
 477
 478 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, RestoreForeignTab) {
 479   GURL url1("http://google.com");
 480   GURL url2("http://google2.com");
 481   SerializedNavigationEntry nav1 =
 482       SerializedNavigationEntryTestHelper::CreateNavigation(url1.spec(), "one");
 483   SerializedNavigationEntry nav2 =
 484       SerializedNavigationEntryTestHelper::CreateNavigation(url2.spec(), "two");
 485
 486   // Set up the restore data.
 487   sync_pb::SessionTab sync_data;
 488   sync_data.set_tab_visual_index(0);
 489   sync_data.set_current_navigation_index(1);
 490   sync_data.set_pinned(false);
 491   sync_data.add_navigation()->CopyFrom(nav1.ToSyncData());
 492   sync_data.add_navigation()->CopyFrom(nav2.ToSyncData());
 493
 494   SessionTab tab;
 495   tab.SetFromSyncData(sync_data, base::Time::Now());
 496   EXPECT_EQ(2U, tab.navigations.size());
 497   for (size_t i = 0; i < tab.navigations.size(); ++i)
 498     EXPECT_TRUE(tab.navigations[i].timestamp().is_null());
 499
 500   ASSERT_EQ(1, browser()->tab_strip_model()->count());
 501
 502   // Restore in the current tab.
 503   content::WebContents* tab_content = NULL;
 504   {
 505     content::WindowedNotificationObserver observer(
 506         content::NOTIFICATION_LOAD_STOP,
 507         content::NotificationService::AllSources());
 508     tab_content = SessionRestore::RestoreForeignSessionTab(
 509         browser()->tab_strip_model()->GetActiveWebContents(), tab, CURRENT_TAB);
 510     observer.Wait();
 511   }
 512   ASSERT_EQ(1, browser()->tab_strip_model()->count());
 513   content::WebContents* web_contents =
 514       browser()->tab_strip_model()->GetWebContentsAt(0);
 515   VerifyNavigationEntries(web_contents->GetController(), url1, url2);
 516   ASSERT_TRUE(web_contents->GetUserAgentOverride().empty());
 517   ASSERT_TRUE(tab_content);
 518   ASSERT_EQ(url2, tab_content->GetURL());
 519
 520   // Restore in a new tab.
 521   tab_content = NULL;
 522   {
 523     content::WindowedNotificationObserver observer(
 524         content::NOTIFICATION_LOAD_STOP,
 525         content::NotificationService::AllSources());
 526     tab_content = SessionRestore::RestoreForeignSessionTab(
 527         browser()->tab_strip_model()->GetActiveWebContents(),
 528         tab, NEW_BACKGROUND_TAB);
 529     observer.Wait();
 530   }
 531   ASSERT_EQ(2, browser()->tab_strip_model()->count());
 532   ASSERT_EQ(0, browser()->tab_strip_model()->active_index());
 533   web_contents = browser()->tab_strip_model()->GetWebContentsAt(1);
 534   VerifyNavigationEntries(web_contents->GetController(), url1, url2);
 535   ASSERT_TRUE(web_contents->GetUserAgentOverride().empty());
 536   ASSERT_TRUE(tab_content);
 537   ASSERT_EQ(url2, tab_content->GetURL());
 538
 539   // Restore in a new window.
 540   Browser* new_browser = NULL;
 541   tab_content = NULL;
 542   {
 543     ui_test_utils::BrowserAddedObserver browser_observer;
 544     content::WindowedNotificationObserver observer(
 545         content::NOTIFICATION_LOAD_STOP,
 546         content::NotificationService::AllSources());
 547     tab_content = SessionRestore::RestoreForeignSessionTab(
 548         browser()->tab_strip_model()->GetActiveWebContents(), tab, NEW_WINDOW);
 549     new_browser = browser_observer.WaitForSingleNewBrowser();
 550     observer.Wait();
 551   }
 552
 553   ASSERT_EQ(1, new_browser->tab_strip_model()->count());
 554   web_contents = new_browser->tab_strip_model()->GetWebContentsAt(0);
 555   VerifyNavigationEntries(web_contents->GetController(), url1, url2);
 556   ASSERT_TRUE(web_contents->GetUserAgentOverride().empty());
 557   ASSERT_TRUE(tab_content);
 558   ASSERT_EQ(url2, tab_content->GetURL());
 559 }
 560
 561 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, RestoreForeignSession) {
 562   Profile* profile = browser()->profile();
 563
 564   GURL url1("http://google.com");
 565   GURL url2("http://google2.com");
 566   SerializedNavigationEntry nav1 =
 567       SerializedNavigationEntryTestHelper::CreateNavigation(url1.spec(), "one");
 568   SerializedNavigationEntry nav2 =
 569       SerializedNavigationEntryTestHelper::CreateNavigation(url2.spec(), "two");
 570   SerializedNavigationEntryTestHelper::SetIsOverridingUserAgent(true, &nav2);
 571
 572   // Set up the restore data -- one window with two tabs.
 573   std::vector<const SessionWindow*> session;
 574   SessionWindow window;
 575   SessionTab tab1;
 576   {
 577     sync_pb::SessionTab sync_data;
 578     sync_data.set_tab_visual_index(0);
 579     sync_data.set_current_navigation_index(0);
 580     sync_data.set_pinned(true);
 581     sync_data.add_navigation()->CopyFrom(nav1.ToSyncData());
 582     tab1.SetFromSyncData(sync_data, base::Time::Now());
 583   }
 584   window.tabs.push_back(&tab1);
 585
 586   SessionTab tab2;
 587   {
 588     sync_pb::SessionTab sync_data;
 589     sync_data.set_tab_visual_index(1);
 590     sync_data.set_current_navigation_index(0);
 591     sync_data.set_pinned(false);
 592     sync_data.add_navigation()->CopyFrom(nav2.ToSyncData());
 593     tab2.SetFromSyncData(sync_data, base::Time::Now());
 594   }
 595   window.tabs.push_back(&tab2);
 596
 597   session.push_back(static_cast<const SessionWindow*>(&window));
 598   ui_test_utils::BrowserAddedObserver window_observer;
 599   std::vector<Browser*> browsers =
 600       SessionRestore::RestoreForeignSessionWindows(
 601           profile, browser()->host_desktop_type(), session.begin(),
 602           session.end());
 603   Browser* new_browser = window_observer.WaitForSingleNewBrowser();
 604   ASSERT_TRUE(new_browser);
 605   ASSERT_EQ(2u, active_browser_list_->size());
 606   ASSERT_EQ(2, new_browser->tab_strip_model()->count());
 607
 608   ASSERT_EQ(1u, browsers.size());
 609   ASSERT_TRUE(browsers[0]);
 610   ASSERT_EQ(2, browsers[0]->tab_strip_model()->count());
 611
 612   content::WebContents* web_contents_1 =
 613       new_browser->tab_strip_model()->GetWebContentsAt(0);
 614   content::WebContents* web_contents_2 =
 615       new_browser->tab_strip_model()->GetWebContentsAt(1);
 616   ASSERT_EQ(url1, web_contents_1->GetURL());
 617   ASSERT_EQ(url2, web_contents_2->GetURL());
 618
 619   // Check user agent override state.
 620   ASSERT_TRUE(web_contents_1->GetUserAgentOverride().empty());
 621   ASSERT_TRUE(web_contents_2->GetUserAgentOverride().empty());
 622
 623   content::NavigationEntry* entry =
 624       web_contents_1->GetController().GetActiveEntry();
 625   ASSERT_TRUE(entry);
 626   ASSERT_FALSE(entry->GetIsOverridingUserAgent());
 627
 628   entry = web_contents_2->GetController().GetActiveEntry();
 629   ASSERT_TRUE(entry);
 630   ASSERT_FALSE(entry->GetIsOverridingUserAgent());
 631
 632   // The SessionWindow destructor deletes the tabs, so we have to clear them
 633   // here to avoid a crash.
 634   window.tabs.clear();
 635 }
 636
 637 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, Basic) {
 638   ui_test_utils::NavigateToURL(browser(), url1_);
 639   ui_test_utils::NavigateToURL(browser(), url2_);
 640
 641   Browser* new_browser = QuitBrowserAndRestore(browser(), 1);
 642   ASSERT_EQ(1u, active_browser_list_->size());
 643   ASSERT_EQ(url2_,
 644             new_browser->tab_strip_model()->GetActiveWebContents()->GetURL());
 645   GoBack(new_browser);
 646   ASSERT_EQ(url1_,
 647             new_browser->tab_strip_model()->GetActiveWebContents()->GetURL());
 648 }
 649
 650 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, RestoreWebUI) {
 651   const GURL webui_url("chrome://omnibox");
 652   ui_test_utils::NavigateToURL(browser(), webui_url);
 653   const content::WebContents* old_tab =
 654       browser()->tab_strip_model()->GetActiveWebContents();
 655   EXPECT_EQ(content::BINDINGS_POLICY_WEB_UI,
 656             old_tab->GetRenderViewHost()->GetEnabledBindings());
 657
 658   Browser* new_browser = QuitBrowserAndRestore(browser(), 1);
 659   ASSERT_EQ(1u, active_browser_list_->size());
 660   const content::WebContents* new_tab =
 661       new_browser->tab_strip_model()->GetActiveWebContents();
 662   EXPECT_EQ(webui_url, new_tab->GetURL());
 663   EXPECT_EQ(content::BINDINGS_POLICY_WEB_UI,
 664             new_tab->GetRenderViewHost()->GetEnabledBindings());
 665 }
 666
 667 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, RestoreWebUISettings) {
 668   const GURL webui_url("chrome://settings");
 669   ui_test_utils::NavigateToURL(browser(), webui_url);
 670   const content::WebContents* old_tab =
 671       browser()->tab_strip_model()->GetActiveWebContents();
 672   EXPECT_EQ(content::BINDINGS_POLICY_WEB_UI,
 673             old_tab->GetRenderViewHost()->GetEnabledBindings());
 674
 675   Browser* new_browser = QuitBrowserAndRestore(browser(), 1);
 676   ASSERT_EQ(1u, active_browser_list_->size());
 677   const content::WebContents* new_tab =
 678       new_browser->tab_strip_model()->GetActiveWebContents();
 679   EXPECT_EQ(webui_url, new_tab->GetURL());
 680   EXPECT_EQ(content::BINDINGS_POLICY_WEB_UI,
 681             new_tab->GetRenderViewHost()->GetEnabledBindings());
 682 }
 683
 684 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, RestoresForwardAndBackwardNavs) {
 685   ui_test_utils::NavigateToURL(browser(), url1_);
 686   ui_test_utils::NavigateToURL(browser(), url2_);
 687   ui_test_utils::NavigateToURL(browser(), url3_);
 688
 689   GoBack(browser());
 690   Browser* new_browser = QuitBrowserAndRestore(browser(), 1);
 691   ASSERT_EQ(1u, active_browser_list_->size());
 692   ASSERT_EQ(url2_,
 693             new_browser->tab_strip_model()->GetActiveWebContents()->GetURL());
 694   GoForward(new_browser);
 695   ASSERT_EQ(url3_,
 696             new_browser->tab_strip_model()->GetActiveWebContents()->GetURL());
 697   GoBack(new_browser);
 698   ASSERT_EQ(url2_,
 699             new_browser->tab_strip_model()->GetActiveWebContents()->GetURL());
 700
 701   // Test renderer-initiated back/forward as well.
 702   GURL go_back_url("javascript:history.back();");
 703   ui_test_utils::NavigateToURL(new_browser, go_back_url);
 704   ASSERT_EQ(url1_,
 705             new_browser->tab_strip_model()->GetActiveWebContents()->GetURL());
 706 }
 707
 708 // Tests that the SiteInstances used for entries in a restored tab's history
 709 // are given appropriate max page IDs, so that going back to a restored
 710 // cross-site page and then forward again works.  (Bug 1204135)
 711 // This test fails. See http://crbug.com/237497.
 712 IN_PROC_BROWSER_TEST_F(SessionRestoreTest,
 713                        DISABLED_RestoresCrossSiteForwardAndBackwardNavs) {
 714   ASSERT_TRUE(test_server()->Start());
 715
 716   GURL cross_site_url(test_server()->GetURL("files/title2.html"));
 717
 718   // Visit URLs on different sites.
 719   ui_test_utils::NavigateToURL(browser(), url1_);
 720   ui_test_utils::NavigateToURL(browser(), cross_site_url);
 721   ui_test_utils::NavigateToURL(browser(), url2_);
 722
 723   GoBack(browser());
 724   Browser* new_browser = QuitBrowserAndRestore(browser(), 1);
 725   ASSERT_EQ(1u, active_browser_list_->size());
 726   ASSERT_EQ(1, new_browser->tab_strip_model()->count());
 727
 728   // Check that back and forward work as expected.
 729   ASSERT_EQ(cross_site_url,
 730             new_browser->tab_strip_model()->GetActiveWebContents()->GetURL());
 731
 732   GoBack(new_browser);
 733   ASSERT_EQ(url1_,
 734             new_browser->tab_strip_model()->GetActiveWebContents()->GetURL());
 735
 736   GoForward(new_browser);
 737   ASSERT_EQ(cross_site_url,
 738             new_browser->tab_strip_model()->GetActiveWebContents()->GetURL());
 739
 740   // Test renderer-initiated back/forward as well.
 741   GURL go_forward_url("javascript:history.forward();");
 742   ui_test_utils::NavigateToURL(new_browser, go_forward_url);
 743   ASSERT_EQ(url2_,
 744             new_browser->tab_strip_model()->GetActiveWebContents()->GetURL());
 745 }
 746
 747 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, TwoTabsSecondSelected) {
 748   ui_test_utils::NavigateToURL(browser(), url1_);
 749
 750   ui_test_utils::NavigateToURLWithDisposition(
 751       browser(), url2_, NEW_FOREGROUND_TAB,
 752       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 753
 754   Browser* new_browser = QuitBrowserAndRestore(browser(), 2);
 755
 756   ASSERT_EQ(1u, active_browser_list_->size());
 757   ASSERT_EQ(2, new_browser->tab_strip_model()->count());
 758   ASSERT_EQ(1, new_browser->tab_strip_model()->active_index());
 759   ASSERT_EQ(url2_,
 760             new_browser->tab_strip_model()->GetActiveWebContents()->GetURL());
 761
 762   ASSERT_EQ(url1_,
 763             new_browser->tab_strip_model()->GetWebContentsAt(0)->GetURL());
 764 }
 765
 766 // Creates two tabs, closes one, quits and makes sure only one tab is restored.
 767 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, ClosedTabStaysClosed) {
 768   ui_test_utils::NavigateToURL(browser(), url1_);
 769
 770   ui_test_utils::NavigateToURLWithDisposition(
 771       browser(), url2_, NEW_FOREGROUND_TAB,
 772       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 773   chrome::CloseTab(browser());
 774
 775   Browser* new_browser = QuitBrowserAndRestore(browser(), 1);
 776
 777   AssertOneWindowWithOneTab(new_browser);
 778   ASSERT_EQ(url1_,
 779             new_browser->tab_strip_model()->GetActiveWebContents()->GetURL());
 780 }
 781
 782 // Ensures active tab properly restored when tabs before it closed.
 783 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, ActiveIndexUpdatedAtClose) {
 784   ui_test_utils::NavigateToURL(browser(), url1_);
 785   ui_test_utils::NavigateToURLWithDisposition(
 786       browser(), url2_, NEW_FOREGROUND_TAB,
 787       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 788   ui_test_utils::NavigateToURLWithDisposition(
 789       browser(), url3_, NEW_BACKGROUND_TAB,
 790       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 791
 792   browser()->tab_strip_model()->CloseWebContentsAt(
 793       0,
 794       TabStripModel::CLOSE_CREATE_HISTORICAL_TAB);
 795
 796   Browser* new_browser = QuitBrowserAndRestore(browser(), 2);
 797
 798   ASSERT_EQ(url2_,
 799             new_browser->tab_strip_model()->GetActiveWebContents()->GetURL());
 800   ASSERT_EQ(new_browser->tab_strip_model()->active_index(), 0);
 801 }
 802
 803 // Ensures active tab properly restored when tabs are inserted before it .
 804 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, ActiveIndexUpdatedAtInsert) {
 805   ui_test_utils::NavigateToURL(browser(), url1_);
 806   ui_test_utils::NavigateToURLWithDisposition(
 807       browser(), url2_, NEW_BACKGROUND_TAB,
 808       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 809
 810   chrome::NavigateParams navigate_params(browser(), url3_,
 811                                          content::PAGE_TRANSITION_TYPED);
 812   navigate_params.tabstrip_index = 0;
 813   navigate_params.disposition = NEW_BACKGROUND_TAB;
 814   ui_test_utils::NavigateToURL(&navigate_params);
 815
 816   Browser* new_browser = QuitBrowserAndRestore(browser(), 3);
 817
 818   ASSERT_EQ(url1_,
 819             new_browser->tab_strip_model()->GetActiveWebContents()->GetURL());
 820   ASSERT_EQ(new_browser->tab_strip_model()->active_index(), 1);
 821 }
 822
 823 // Creates a tabbed browser and popup and makes sure we restore both.
 824 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, NormalAndPopup) {
 825   if (!browser_defaults::kRestorePopups)
 826     return;  // Test only applicable if restoring popups.
 827
 828   ui_test_utils::NavigateToURL(browser(), url1_);
 829
 830   // Make sure we have one window.
 831   AssertOneWindowWithOneTab(browser());
 832
 833   // Open a popup.
 834   Browser* popup = new Browser(
 835       Browser::CreateParams(Browser::TYPE_POPUP, browser()->profile(),
 836                             browser()->host_desktop_type()));
 837   popup->window()->Show();
 838   ASSERT_EQ(2u, active_browser_list_->size());
 839
 840   ui_test_utils::NavigateToURL(popup, url1_);
 841
 842   // Simulate an exit by shuting down the session service. If we don't do this
 843   // the first window close is treated as though the user closed the window
 844   // and won't be restored.
 845   SessionServiceFactory::ShutdownForProfile(browser()->profile());
 846
 847   // Restart and make sure we have two windows.
 848   QuitBrowserAndRestore(browser(), 1);
 849
 850   ASSERT_EQ(2u, active_browser_list_->size());
 851
 852   Browser* browser1 = active_browser_list_->get(0);
 853   Browser* browser2 = active_browser_list_->get(1);
 854
 855   Browser::Type type1 = browser1->type();
 856   Browser::Type type2 = browser2->type();
 857
 858   // The order of whether the normal window or popup is first depends upon
 859   // activation order, which is not necessarily consistant across runs.
 860   if (type1 == Browser::TYPE_TABBED) {
 861     EXPECT_EQ(type2, Browser::TYPE_POPUP);
 862   } else {
 863     EXPECT_EQ(type1, Browser::TYPE_POPUP);
 864     EXPECT_EQ(type2, Browser::TYPE_TABBED);
 865   }
 866 }
 867
 868 #if !defined(OS_CHROMEOS) && !defined(OS_MACOSX)
 869 // This test doesn't apply to the Mac version; see GetCommandLineForRelaunch
 870 // for details. It was disabled for a long time so might never have worked on
 871 // ChromeOS.
 872
 873 // Launches an app window, closes tabbed browser, launches and makes sure
 874 // we restore the tabbed browser url.
 875 // If this test flakes, use http://crbug.com/29110
 876 IN_PROC_BROWSER_TEST_F(SessionRestoreTest,
 877                        RestoreAfterClosingTabbedBrowserWithAppAndLaunching) {
 878 #if defined(OS_WIN) && defined(USE_ASH)
 879   // Disable this test in Metro+Ash for now (http://crbug.com/262796).
 880   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kAshBrowserTests))
 881     return;
 882 #endif
 883
 884   ui_test_utils::NavigateToURL(browser(), url1_);
 885
 886   // Launch an app.
 887   CommandLine app_launch_arguments = GetCommandLineForRelaunch();
 888   app_launch_arguments.AppendSwitchASCII(switches::kApp, url2_.spec());
 889
 890   ui_test_utils::BrowserAddedObserver window_observer;
 891
 892   base::LaunchProcess(app_launch_arguments, base::LaunchOptions(), NULL);
 893
 894   Browser* app_window = window_observer.WaitForSingleNewBrowser();
 895   ASSERT_EQ(2u, active_browser_list_->size());
 896
 897   // Close the first window. The only window left is the App window.
 898   CloseBrowserSynchronously(browser());
 899
 900   // Restore the session, which should bring back the first window with url1_.
 901   Browser* new_browser = QuitBrowserAndRestore(app_window, 1);
 902
 903   AssertOneWindowWithOneTab(new_browser);
 904
 905   ASSERT_EQ(url1_,
 906             new_browser->tab_strip_model()->GetActiveWebContents()->GetURL());
 907 }
 908
 909 #endif  // !defined(OS_CHROMEOS) && !defined(OS_MACOSX)
 910
 911 // Creates two windows, closes one, restores, make sure only one window open.
 912 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, TwoWindowsCloseOneRestoreOnlyOne) {
 913   ui_test_utils::NavigateToURL(browser(), url1_);
 914
 915   // Open a second window.
 916   ui_test_utils::NavigateToURLWithDisposition(
 917       browser(), GURL(content::kAboutBlankURL), NEW_WINDOW,
 918       ui_test_utils::BROWSER_TEST_WAIT_FOR_BROWSER);
 919
 920   ASSERT_EQ(2u, active_browser_list_->size());
 921
 922   // Close it.
 923   Browser* new_window = active_browser_list_->get(1);
 924   CloseBrowserSynchronously(new_window);
 925
 926   // Restart and make sure we have only one window with one tab and the url
 927   // is url1_.
 928   Browser* new_browser = QuitBrowserAndRestore(browser(), 1);
 929
 930   AssertOneWindowWithOneTab(new_browser);
 931
 932   ASSERT_EQ(url1_,
 933             new_browser->tab_strip_model()->GetActiveWebContents()->GetURL());
 934 }
 935
 936 // Make sure after a restore the number of processes matches that of the number
 937 // of processes running before the restore. This creates a new tab so that
 938 // we should have two new tabs running.  (This test will pass in both
 939 // process-per-site and process-per-site-instance, because we treat the new tab
 940 // as a special case in process-per-site-instance so that it only ever uses one
 941 // process.)
 942 //
 943 // Flaky: http://code.google.com/p/chromium/issues/detail?id=52022
 944 // Unfortunately, the fix at http://codereview.chromium.org/6546078
 945 // breaks NTP background image refreshing, so ThemeSource had to revert to
 946 // replacing the existing data source.
 947 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, ShareProcessesOnRestore) {
 948   // Create two new tabs.
 949   ui_test_utils::NavigateToURLWithDisposition(
 950       browser(), GURL(content::kAboutBlankURL), NEW_FOREGROUND_TAB,
 951       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 952   ui_test_utils::NavigateToURLWithDisposition(
 953       browser(), GURL(content::kAboutBlankURL), NEW_FOREGROUND_TAB,
 954       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 955
 956   int expected_process_count = RenderProcessHostCount();
 957
 958   // Restart.
 959   Browser* new_browser = QuitBrowserAndRestore(browser(), 3);
 960
 961   ASSERT_EQ(3, new_browser->tab_strip_model()->count());
 962
 963   ASSERT_EQ(expected_process_count, RenderProcessHostCount());
 964 }
 965
 966 // Test that changing the user agent override will persist it to disk.
 967 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, PersistAndRestoreUserAgentOverride) {
 968   // Create a tab with an overridden user agent.
 969   ui_test_utils::NavigateToURL(browser(), url1_);
 970   ASSERT_EQ(0, browser()->tab_strip_model()->active_index());
 971   browser()->tab_strip_model()->GetWebContentsAt(0)->
 972       SetUserAgentOverride("override");
 973
 974   // Create a tab without an overridden user agent.
 975   ui_test_utils::NavigateToURLWithDisposition(
 976       browser(), url2_, NEW_FOREGROUND_TAB,
 977       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 978   ASSERT_EQ(1, browser()->tab_strip_model()->active_index());
 979
 980   // Kill the original browser then open a new one to trigger a restore.
 981   Browser* new_browser = QuitBrowserAndRestore(browser(), 1);
 982   ASSERT_EQ(1u, active_browser_list_->size());
 983   ASSERT_EQ(2, new_browser->tab_strip_model()->count());
 984   ASSERT_EQ(1, new_browser->tab_strip_model()->active_index());
 985
 986   // Confirm that the user agent overrides are properly set.
 987   EXPECT_EQ("override",
 988             new_browser->tab_strip_model()->GetWebContentsAt(0)->
 989                 GetUserAgentOverride());
 990   EXPECT_EQ("",
 991             new_browser->tab_strip_model()->GetWebContentsAt(1)->
 992                 GetUserAgentOverride());
 993 }
 994
 995 // Regression test for crbug.com/125958. When restoring a pinned selected tab in
 996 // a setting where there are existing tabs, the selected index computation was
 997 // wrong, leading to the wrong tab getting selected, DCHECKs firing, and the
 998 // pinned tab not getting loaded.
 999 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, RestorePinnedSelectedTab) {
1000   // Create a pinned tab.
1001   ui_test_utils::NavigateToURL(browser(), url1_);
1002   browser()->tab_strip_model()->SetTabPinned(0, true);
1003   ASSERT_EQ(0, browser()->tab_strip_model()->active_index());
1004   // Create a nonpinned tab.
1005   ui_test_utils::NavigateToURLWithDisposition(
1006       browser(), url2_, NEW_FOREGROUND_TAB,
1007       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
1008   ASSERT_EQ(1, browser()->tab_strip_model()->active_index());
1009   // Select the pinned tab.
1010   browser()->tab_strip_model()->ActivateTabAt(0, true);
1011   ASSERT_EQ(0, browser()->tab_strip_model()->active_index());
1012   Profile* profile = browser()->profile();
1013
1014   // This will also initiate a session restore, but we're not interested in it.
1015   Browser* new_browser = QuitBrowserAndRestore(browser(), 1);
1016   ASSERT_EQ(1u, active_browser_list_->size());
1017   ASSERT_EQ(2, new_browser->tab_strip_model()->count());
1018   ASSERT_EQ(0, new_browser->tab_strip_model()->active_index());
1019   // Close the pinned tab.
1020   chrome::CloseTab(new_browser);
1021   ASSERT_EQ(1, new_browser->tab_strip_model()->count());
1022   ASSERT_EQ(0, new_browser->tab_strip_model()->active_index());
1023   // Use the existing tab to navigate away, so that we can verify it was really
1024   // clobbered.
1025   ui_test_utils::NavigateToURL(new_browser, url3_);
1026
1027   // Restore the session again, clobbering the existing tab.
1028   SessionRestore::RestoreSession(
1029       profile, new_browser,
1030       new_browser->host_desktop_type(),
1031       SessionRestore::CLOBBER_CURRENT_TAB | SessionRestore::SYNCHRONOUS,
1032       std::vector<GURL>());
1033
1034   // The pinned tab is the selected tab.
1035   ASSERT_EQ(2, new_browser->tab_strip_model()->count());
1036   EXPECT_EQ(0, new_browser->tab_strip_model()->active_index());
1037   EXPECT_EQ(url1_,
1038             new_browser->tab_strip_model()->GetActiveWebContents()->GetURL());
1039   EXPECT_EQ(url2_,
1040             new_browser->tab_strip_model()->GetWebContentsAt(1)->GetURL());
1041 }
1042
1043 // Regression test for crbug.com/240156. When restoring tabs with a navigation,
1044 // the navigation should take active tab focus.
1045 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, RestoreWithNavigateSelectedTab) {
1046   // Create 2 tabs.
1047   ui_test_utils::NavigateToURL(browser(), url1_);
1048   ui_test_utils::NavigateToURLWithDisposition(
1049       browser(), url2_, NEW_FOREGROUND_TAB,
1050       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
1051
1052   // Restore the session by calling chrome::Navigate().
1053   Browser* new_browser = QuitBrowserAndRestoreWithURL(browser(), 3, url3_);
1054   ASSERT_EQ(1u, active_browser_list_->size());
1055   ASSERT_EQ(3, new_browser->tab_strip_model()->count());
1056   // Navigated url should be the active tab.
1057   ASSERT_EQ(url3_,
1058             new_browser->tab_strip_model()->GetActiveWebContents()->GetURL());
1059 }
1060
1061 // Do a clobber restore from the new tab page. This test follows the code path
1062 // of a crash followed by the user clicking restore from the new tab page.
1063 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, ClobberRestoreTest) {
1064   // Create 2 tabs.
1065   ui_test_utils::NavigateToURL(browser(), url1_);
1066   ASSERT_EQ(0, browser()->tab_strip_model()->active_index());
1067   ui_test_utils::NavigateToURLWithDisposition(
1068       browser(), url2_, NEW_FOREGROUND_TAB,
1069       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
1070   ASSERT_EQ(1, browser()->tab_strip_model()->active_index());
1071   Profile* profile = browser()->profile();
1072
1073   // This will also initiate a session restore, but we're not interested in it.
1074   Browser* new_browser = QuitBrowserAndRestore(browser(), 1);
1075   ASSERT_EQ(1u, active_browser_list_->size());
1076   ASSERT_EQ(2, new_browser->tab_strip_model()->count());
1077   ASSERT_EQ(1, new_browser->tab_strip_model()->active_index());
1078   // Close the first tab.
1079   chrome::CloseTab(new_browser);
1080   ASSERT_EQ(1, new_browser->tab_strip_model()->count());
1081   ASSERT_EQ(0, new_browser->tab_strip_model()->active_index());
1082   // Use the existing tab to navigate to the NTP.
1083   ui_test_utils::NavigateToURL(new_browser, GURL(chrome::kChromeUINewTabURL));
1084
1085   // Restore the session again, clobbering the existing tab.
1086   SessionRestore::RestoreSession(
1087       profile, new_browser,
1088       new_browser->host_desktop_type(),
1089       SessionRestore::CLOBBER_CURRENT_TAB | SessionRestore::SYNCHRONOUS,
1090       std::vector<GURL>());
1091
1092   // 2 tabs should have been restored, with the existing tab clobbered, giving
1093   // us a total of 2 tabs.
1094   ASSERT_EQ(2, new_browser->tab_strip_model()->count());
1095   EXPECT_EQ(1, new_browser->tab_strip_model()->active_index());
1096   EXPECT_EQ(url1_,
1097             new_browser->tab_strip_model()->GetWebContentsAt(0)->GetURL());
1098   EXPECT_EQ(url2_,
1099             new_browser->tab_strip_model()->GetActiveWebContents()->GetURL());
1100 }
1101
1102 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, SessionStorage) {
1103   ui_test_utils::NavigateToURL(browser(), url1_);
1104   content::NavigationController* controller =
1105       &browser()->tab_strip_model()->GetActiveWebContents()->GetController();
1106   ASSERT_TRUE(controller->GetDefaultSessionStorageNamespace());
1107   std::string session_storage_persistent_id =
1108       controller->GetDefaultSessionStorageNamespace()->persistent_id();
1109   Browser* new_browser = QuitBrowserAndRestore(browser(), 1);
1110   ASSERT_EQ(1u, active_browser_list_->size());
1111   ASSERT_EQ(url1_,
1112             new_browser->tab_strip_model()->GetActiveWebContents()->GetURL());
1113   content::NavigationController* new_controller =
1114       &new_browser->tab_strip_model()->GetActiveWebContents()->GetController();
1115   ASSERT_TRUE(new_controller->GetDefaultSessionStorageNamespace());
1116   std::string restored_session_storage_persistent_id =
1117       new_controller->GetDefaultSessionStorageNamespace()->persistent_id();
1118   EXPECT_EQ(session_storage_persistent_id,
1119             restored_session_storage_persistent_id);
1120 }
1121
1122 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, SessionStorageAfterTabReplace) {
1123   // Simulate what prerendering does: create a new WebContents with the same
1124   // SessionStorageNamespace as an existing tab, then replace the tab with it.
1125   {
1126     content::NavigationController* controller =
1127         &browser()->tab_strip_model()->GetActiveWebContents()->GetController();
1128     ASSERT_TRUE(controller->GetDefaultSessionStorageNamespace());
1129
1130     content::SessionStorageNamespaceMap session_storage_namespace_map;
1131     session_storage_namespace_map[std::string()] =
1132         controller->GetDefaultSessionStorageNamespace();
1133     scoped_ptr<content::WebContents> web_contents(
1134         content::WebContents::CreateWithSessionStorage(
1135             content::WebContents::CreateParams(browser()->profile()),
1136             session_storage_namespace_map));
1137
1138     TabStripModel* tab_strip_model = browser()->tab_strip_model();
1139     scoped_ptr<content::WebContents> old_web_contents(
1140         tab_strip_model->ReplaceWebContentsAt(
1141             tab_strip_model->active_index(), web_contents.release()));
1142     // Navigate with the new tab.
1143     ui_test_utils::NavigateToURL(browser(), url2_);
1144     // old_web_contents goes out of scope.
1145   }
1146
1147   // Check that the sessionStorage data is going to be persisted.
1148   content::NavigationController* controller =
1149       &browser()->tab_strip_model()->GetActiveWebContents()->GetController();
1150   EXPECT_TRUE(
1151       controller->GetDefaultSessionStorageNamespace()->should_persist());
1152
1153   // Quit and restore. Check that no extra tabs were created.
1154   Browser* new_browser = QuitBrowserAndRestore(browser(), 1);
1155   ASSERT_EQ(1u, active_browser_list_->size());
1156   EXPECT_EQ(1, new_browser->tab_strip_model()->count());
1157 }