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(¶ms); 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::AddBlankTabAt(incognito_browser, -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 GURL url2(ui_test_utils::GetTestUrl( 312 base::FilePath(base::FilePath::kCurrentDirectory), 313 base::FilePath(FILE_PATH_LITERAL("title2.html")))); 314 GURL url3(ui_test_utils::GetTestUrl( 315 base::FilePath(base::FilePath::kCurrentDirectory), 316 base::FilePath(FILE_PATH_LITERAL("title3.html")))); 317 318 // Add and navigate three tabs. 319 ui_test_utils::NavigateToURL(browser(), url1); 320 { 321 content::WindowedNotificationObserver observer( 322 content::NOTIFICATION_LOAD_STOP, 323 content::NotificationService::AllSources()); 324 chrome::AddSelectedTabWithURL(browser(), url2, 325 content::PAGE_TRANSITION_LINK); 326 observer.Wait(); 327 } 328 { 329 content::WindowedNotificationObserver observer( 330 content::NOTIFICATION_LOAD_STOP, 331 content::NotificationService::AllSources()); 332 chrome::AddSelectedTabWithURL(browser(), url3, 333 content::PAGE_TRANSITION_LINK); 334 observer.Wait(); 335 } 336 337 TabRestoreService* service = 338 TabRestoreServiceFactory::GetForProfile(browser()->profile()); 339 service->ClearEntries(); 340 341 chrome::HostDesktopType host_desktop_type = browser()->host_desktop_type(); 342 343 browser()->window()->Close(); 344 345 // Expect a window with three tabs. 346 ASSERT_EQ(1U, service->entries().size()); 347 ASSERT_EQ(TabRestoreService::WINDOW, service->entries().front()->type); 348 const TabRestoreService::Window* window = 349 static_cast<TabRestoreService::Window*>(service->entries().front()); 350 EXPECT_EQ(3U, window->tabs.size()); 351 352 // Find the SessionID for entry2. Since the session service was destroyed, 353 // there is no guarantee that the SessionID for the tab has remained the same. 354 base::Time timestamp; 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 std::vector<content::WebContents*> content = 362 service->RestoreEntryById(NULL, tab.id, host_desktop_type, UNKNOWN); 363 ASSERT_EQ(1U, content.size()); 364 ASSERT_TRUE(content[0]); 365 EXPECT_EQ(url2, content[0]->GetURL()); 366 break; 367 } 368 } 369 EXPECT_FALSE(timestamp.is_null()); 370 371 // Make sure that the restored tab is removed from the service. 372 ASSERT_EQ(1U, service->entries().size()); 373 ASSERT_EQ(TabRestoreService::WINDOW, service->entries().front()->type); 374 window = static_cast<TabRestoreService::Window*>(service->entries().front()); 375 EXPECT_EQ(2U, window->tabs.size()); 376 377 // Make sure that the restored tab was restored with the correct 378 // timestamp. 379 const content::WebContents* contents = 380 browser()->tab_strip_model()->GetActiveWebContents(); 381 ASSERT_TRUE(contents); 382 const content::NavigationEntry* entry = 383 contents->GetController().GetActiveEntry(); 384 ASSERT_TRUE(entry); 385 EXPECT_EQ(timestamp, entry->GetTimestamp()); 386 } 387 388 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, WindowWithOneTab) { 389 GURL url(ui_test_utils::GetTestUrl( 390 base::FilePath(base::FilePath::kCurrentDirectory), 391 base::FilePath(FILE_PATH_LITERAL("title1.html")))); 392 393 // Add a single tab. 394 ui_test_utils::NavigateToURL(browser(), url); 395 396 TabRestoreService* service = 397 TabRestoreServiceFactory::GetForProfile(browser()->profile()); 398 service->ClearEntries(); 399 EXPECT_EQ(0U, service->entries().size()); 400 401 chrome::HostDesktopType host_desktop_type = browser()->host_desktop_type(); 402 403 // Close the window. 404 browser()->window()->Close(); 405 406 // Expect the window to be converted to a tab by the TRS. 407 EXPECT_EQ(1U, service->entries().size()); 408 ASSERT_EQ(TabRestoreService::TAB, service->entries().front()->type); 409 const TabRestoreService::Tab* tab = 410 static_cast<TabRestoreService::Tab*>(service->entries().front()); 411 412 // Restore the tab. 413 std::vector<content::WebContents*> content = 414 service->RestoreEntryById(NULL, tab->id, host_desktop_type, UNKNOWN); 415 ASSERT_EQ(1U, content.size()); 416 ASSERT_TRUE(content[0]); 417 EXPECT_EQ(url, content[0]->GetURL()); 418 419 // Make sure the restore was successful. 420 EXPECT_EQ(0U, service->entries().size()); 421 } 422 423 #if !defined(OS_CHROMEOS) 424 // This test does not apply to ChromeOS as ChromeOS does not do session 425 // restore when a new window is open. 426 427 // Verifies we remember the last browser window when closing the last 428 // non-incognito window while an incognito window is open. 429 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, IncognitotoNonIncognito) { 430 GURL url(ui_test_utils::GetTestUrl( 431 base::FilePath(base::FilePath::kCurrentDirectory), 432 base::FilePath(FILE_PATH_LITERAL("title1.html")))); 433 434 // Add a single tab. 435 ui_test_utils::NavigateToURL(browser(), url); 436 437 // Create a new incognito window. 438 Browser* incognito_browser = CreateIncognitoBrowser(); 439 chrome::AddBlankTabAt(incognito_browser, -1, true); 440 incognito_browser->window()->Show(); 441 442 // Close the normal browser. After this we only have the incognito window 443 // open. 444 CloseBrowserSynchronously(browser()); 445 446 // Create a new window, which should trigger session restore. 447 ui_test_utils::BrowserAddedObserver browser_added_observer; 448 chrome::NewWindow(incognito_browser); 449 Browser* new_browser = browser_added_observer.WaitForSingleNewBrowser(); 450 451 // The first tab should have 'url' as its url. 452 ASSERT_TRUE(new_browser); 453 EXPECT_EQ(url, new_browser->tab_strip_model()->GetWebContentsAt(0)->GetURL()); 454 } 455 #endif // !OS_CHROMEOS 456 457 namespace { 458 459 // Verifies that the given NavigationController has exactly two 460 // entries that correspond to the given URLs and that all but the last 461 // entry have null timestamps. 462 void VerifyNavigationEntries( 463 const content::NavigationController& controller, 464 GURL url1, GURL url2) { 465 ASSERT_EQ(2, controller.GetEntryCount()); 466 EXPECT_EQ(1, controller.GetCurrentEntryIndex()); 467 EXPECT_EQ(url1, controller.GetEntryAtIndex(0)->GetURL()); 468 EXPECT_EQ(url2, controller.GetEntryAtIndex(1)->GetURL()); 469 EXPECT_TRUE(controller.GetEntryAtIndex(0)->GetTimestamp().is_null()); 470 EXPECT_FALSE(controller.GetEntryAtIndex(1)->GetTimestamp().is_null()); 471 } 472 473 } // namespace 474 475 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, RestoreForeignTab) { 476 GURL url1("http://google.com"); 477 GURL url2("http://google2.com"); 478 SerializedNavigationEntry nav1 = 479 SerializedNavigationEntryTestHelper::CreateNavigation(url1.spec(), "one"); 480 SerializedNavigationEntry nav2 = 481 SerializedNavigationEntryTestHelper::CreateNavigation(url2.spec(), "two"); 482 483 // Set up the restore data. 484 sync_pb::SessionTab sync_data; 485 sync_data.set_tab_visual_index(0); 486 sync_data.set_current_navigation_index(1); 487 sync_data.set_pinned(false); 488 sync_data.add_navigation()->CopyFrom(nav1.ToSyncData()); 489 sync_data.add_navigation()->CopyFrom(nav2.ToSyncData()); 490 491 SessionTab tab; 492 tab.SetFromSyncData(sync_data, base::Time::Now()); 493 EXPECT_EQ(2U, tab.navigations.size()); 494 for (size_t i = 0; i < tab.navigations.size(); ++i) 495 EXPECT_TRUE(tab.navigations[i].timestamp().is_null()); 496 497 ASSERT_EQ(1, browser()->tab_strip_model()->count()); 498 499 // Restore in the current tab. 500 content::WebContents* tab_content = NULL; 501 { 502 content::WindowedNotificationObserver observer( 503 content::NOTIFICATION_LOAD_STOP, 504 content::NotificationService::AllSources()); 505 tab_content = SessionRestore::RestoreForeignSessionTab( 506 browser()->tab_strip_model()->GetActiveWebContents(), tab, CURRENT_TAB); 507 observer.Wait(); 508 } 509 ASSERT_EQ(1, browser()->tab_strip_model()->count()); 510 content::WebContents* web_contents = 511 browser()->tab_strip_model()->GetWebContentsAt(0); 512 VerifyNavigationEntries(web_contents->GetController(), url1, url2); 513 ASSERT_TRUE(web_contents->GetUserAgentOverride().empty()); 514 ASSERT_TRUE(tab_content); 515 ASSERT_EQ(url2, tab_content->GetURL()); 516 517 // Restore in a new tab. 518 tab_content = NULL; 519 { 520 content::WindowedNotificationObserver observer( 521 content::NOTIFICATION_LOAD_STOP, 522 content::NotificationService::AllSources()); 523 tab_content = SessionRestore::RestoreForeignSessionTab( 524 browser()->tab_strip_model()->GetActiveWebContents(), 525 tab, NEW_BACKGROUND_TAB); 526 observer.Wait(); 527 } 528 ASSERT_EQ(2, browser()->tab_strip_model()->count()); 529 ASSERT_EQ(0, browser()->tab_strip_model()->active_index()); 530 web_contents = browser()->tab_strip_model()->GetWebContentsAt(1); 531 VerifyNavigationEntries(web_contents->GetController(), url1, url2); 532 ASSERT_TRUE(web_contents->GetUserAgentOverride().empty()); 533 ASSERT_TRUE(tab_content); 534 ASSERT_EQ(url2, tab_content->GetURL()); 535 536 // Restore in a new window. 537 Browser* new_browser = NULL; 538 tab_content = NULL; 539 { 540 ui_test_utils::BrowserAddedObserver browser_observer; 541 content::WindowedNotificationObserver observer( 542 content::NOTIFICATION_LOAD_STOP, 543 content::NotificationService::AllSources()); 544 tab_content = SessionRestore::RestoreForeignSessionTab( 545 browser()->tab_strip_model()->GetActiveWebContents(), tab, NEW_WINDOW); 546 new_browser = browser_observer.WaitForSingleNewBrowser(); 547 observer.Wait(); 548 } 549 550 ASSERT_EQ(1, new_browser->tab_strip_model()->count()); 551 web_contents = new_browser->tab_strip_model()->GetWebContentsAt(0); 552 VerifyNavigationEntries(web_contents->GetController(), url1, url2); 553 ASSERT_TRUE(web_contents->GetUserAgentOverride().empty()); 554 ASSERT_TRUE(tab_content); 555 ASSERT_EQ(url2, tab_content->GetURL()); 556 } 557 558 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, RestoreForeignSession) { 559 Profile* profile = browser()->profile(); 560 561 GURL url1("http://google.com"); 562 GURL url2("http://google2.com"); 563 SerializedNavigationEntry nav1 = 564 SerializedNavigationEntryTestHelper::CreateNavigation(url1.spec(), "one"); 565 SerializedNavigationEntry nav2 = 566 SerializedNavigationEntryTestHelper::CreateNavigation(url2.spec(), "two"); 567 SerializedNavigationEntryTestHelper::SetIsOverridingUserAgent(true, &nav2); 568 569 // Set up the restore data -- one window with two tabs. 570 std::vector<const SessionWindow*> session; 571 SessionWindow window; 572 SessionTab tab1; 573 { 574 sync_pb::SessionTab sync_data; 575 sync_data.set_tab_visual_index(0); 576 sync_data.set_current_navigation_index(0); 577 sync_data.set_pinned(true); 578 sync_data.add_navigation()->CopyFrom(nav1.ToSyncData()); 579 tab1.SetFromSyncData(sync_data, base::Time::Now()); 580 } 581 window.tabs.push_back(&tab1); 582 583 SessionTab tab2; 584 { 585 sync_pb::SessionTab sync_data; 586 sync_data.set_tab_visual_index(1); 587 sync_data.set_current_navigation_index(0); 588 sync_data.set_pinned(false); 589 sync_data.add_navigation()->CopyFrom(nav2.ToSyncData()); 590 tab2.SetFromSyncData(sync_data, base::Time::Now()); 591 } 592 window.tabs.push_back(&tab2); 593 594 session.push_back(static_cast<const SessionWindow*>(&window)); 595 ui_test_utils::BrowserAddedObserver window_observer; 596 std::vector<Browser*> browsers = 597 SessionRestore::RestoreForeignSessionWindows( 598 profile, browser()->host_desktop_type(), session.begin(), 599 session.end()); 600 Browser* new_browser = window_observer.WaitForSingleNewBrowser(); 601 ASSERT_TRUE(new_browser); 602 ASSERT_EQ(2u, active_browser_list_->size()); 603 ASSERT_EQ(2, new_browser->tab_strip_model()->count()); 604 605 ASSERT_EQ(1u, browsers.size()); 606 ASSERT_TRUE(browsers[0]); 607 ASSERT_EQ(2, browsers[0]->tab_strip_model()->count()); 608 609 content::WebContents* web_contents_1 = 610 new_browser->tab_strip_model()->GetWebContentsAt(0); 611 content::WebContents* web_contents_2 = 612 new_browser->tab_strip_model()->GetWebContentsAt(1); 613 ASSERT_EQ(url1, web_contents_1->GetURL()); 614 ASSERT_EQ(url2, web_contents_2->GetURL()); 615 616 // Check user agent override state. 617 ASSERT_TRUE(web_contents_1->GetUserAgentOverride().empty()); 618 ASSERT_TRUE(web_contents_2->GetUserAgentOverride().empty()); 619 620 content::NavigationEntry* entry = 621 web_contents_1->GetController().GetActiveEntry(); 622 ASSERT_TRUE(entry); 623 ASSERT_FALSE(entry->GetIsOverridingUserAgent()); 624 625 entry = web_contents_2->GetController().GetActiveEntry(); 626 ASSERT_TRUE(entry); 627 ASSERT_FALSE(entry->GetIsOverridingUserAgent()); 628 629 // The SessionWindow destructor deletes the tabs, so we have to clear them 630 // here to avoid a crash. 631 window.tabs.clear(); 632 } 633 634 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, Basic) { 635 ui_test_utils::NavigateToURL(browser(), url1_); 636 ui_test_utils::NavigateToURL(browser(), url2_); 637 638 Browser* new_browser = QuitBrowserAndRestore(browser(), 1); 639 ASSERT_EQ(1u, active_browser_list_->size()); 640 ASSERT_EQ(url2_, 641 new_browser->tab_strip_model()->GetActiveWebContents()->GetURL()); 642 GoBack(new_browser); 643 ASSERT_EQ(url1_, 644 new_browser->tab_strip_model()->GetActiveWebContents()->GetURL()); 645 } 646 647 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, RestoreWebUI) { 648 const GURL webui_url("chrome://newtab"); 649 ui_test_utils::NavigateToURL(browser(), webui_url); 650 const content::WebContents* old_tab = 651 browser()->tab_strip_model()->GetActiveWebContents(); 652 EXPECT_EQ(content::BINDINGS_POLICY_WEB_UI, 653 old_tab->GetRenderViewHost()->GetEnabledBindings()); 654 655 Browser* new_browser = QuitBrowserAndRestore(browser(), 1); 656 ASSERT_EQ(1u, active_browser_list_->size()); 657 const content::WebContents* new_tab = 658 new_browser->tab_strip_model()->GetActiveWebContents(); 659 EXPECT_EQ(webui_url, new_tab->GetURL()); 660 EXPECT_EQ(content::BINDINGS_POLICY_WEB_UI, 661 new_tab->GetRenderViewHost()->GetEnabledBindings()); 662 } 663 664 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, RestoreWebUISettings) { 665 const GURL webui_url("chrome://settings"); 666 ui_test_utils::NavigateToURL(browser(), webui_url); 667 const content::WebContents* old_tab = 668 browser()->tab_strip_model()->GetActiveWebContents(); 669 EXPECT_EQ(content::BINDINGS_POLICY_WEB_UI, 670 old_tab->GetRenderViewHost()->GetEnabledBindings()); 671 672 Browser* new_browser = QuitBrowserAndRestore(browser(), 1); 673 ASSERT_EQ(1u, active_browser_list_->size()); 674 const content::WebContents* new_tab = 675 new_browser->tab_strip_model()->GetActiveWebContents(); 676 EXPECT_EQ(webui_url, new_tab->GetURL()); 677 EXPECT_EQ(content::BINDINGS_POLICY_WEB_UI, 678 new_tab->GetRenderViewHost()->GetEnabledBindings()); 679 } 680 681 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, RestoresForwardAndBackwardNavs) { 682 ui_test_utils::NavigateToURL(browser(), url1_); 683 ui_test_utils::NavigateToURL(browser(), url2_); 684 ui_test_utils::NavigateToURL(browser(), url3_); 685 686 GoBack(browser()); 687 Browser* new_browser = QuitBrowserAndRestore(browser(), 1); 688 ASSERT_EQ(1u, active_browser_list_->size()); 689 ASSERT_EQ(url2_, 690 new_browser->tab_strip_model()->GetActiveWebContents()->GetURL()); 691 GoForward(new_browser); 692 ASSERT_EQ(url3_, 693 new_browser->tab_strip_model()->GetActiveWebContents()->GetURL()); 694 GoBack(new_browser); 695 ASSERT_EQ(url2_, 696 new_browser->tab_strip_model()->GetActiveWebContents()->GetURL()); 697 698 // Test renderer-initiated back/forward as well. 699 GURL go_back_url("javascript:history.back();"); 700 ui_test_utils::NavigateToURL(new_browser, go_back_url); 701 ASSERT_EQ(url1_, 702 new_browser->tab_strip_model()->GetActiveWebContents()->GetURL()); 703 } 704 705 // Tests that the SiteInstances used for entries in a restored tab's history 706 // are given appropriate max page IDs, so that going back to a restored 707 // cross-site page and then forward again works. (Bug 1204135) 708 // This test fails. See http://crbug.com/237497. 709 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, 710 DISABLED_RestoresCrossSiteForwardAndBackwardNavs) { 711 ASSERT_TRUE(test_server()->Start()); 712 713 GURL cross_site_url(test_server()->GetURL("files/title2.html")); 714 715 // Visit URLs on different sites. 716 ui_test_utils::NavigateToURL(browser(), url1_); 717 ui_test_utils::NavigateToURL(browser(), cross_site_url); 718 ui_test_utils::NavigateToURL(browser(), url2_); 719 720 GoBack(browser()); 721 Browser* new_browser = QuitBrowserAndRestore(browser(), 1); 722 ASSERT_EQ(1u, active_browser_list_->size()); 723 ASSERT_EQ(1, new_browser->tab_strip_model()->count()); 724 725 // Check that back and forward work as expected. 726 ASSERT_EQ(cross_site_url, 727 new_browser->tab_strip_model()->GetActiveWebContents()->GetURL()); 728 729 GoBack(new_browser); 730 ASSERT_EQ(url1_, 731 new_browser->tab_strip_model()->GetActiveWebContents()->GetURL()); 732 733 GoForward(new_browser); 734 ASSERT_EQ(cross_site_url, 735 new_browser->tab_strip_model()->GetActiveWebContents()->GetURL()); 736 737 // Test renderer-initiated back/forward as well. 738 GURL go_forward_url("javascript:history.forward();"); 739 ui_test_utils::NavigateToURL(new_browser, go_forward_url); 740 ASSERT_EQ(url2_, 741 new_browser->tab_strip_model()->GetActiveWebContents()->GetURL()); 742 } 743 744 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, TwoTabsSecondSelected) { 745 ui_test_utils::NavigateToURL(browser(), url1_); 746 747 ui_test_utils::NavigateToURLWithDisposition( 748 browser(), url2_, NEW_FOREGROUND_TAB, 749 ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION); 750 751 Browser* new_browser = QuitBrowserAndRestore(browser(), 2); 752 753 ASSERT_EQ(1u, active_browser_list_->size()); 754 ASSERT_EQ(2, new_browser->tab_strip_model()->count()); 755 ASSERT_EQ(1, new_browser->tab_strip_model()->active_index()); 756 ASSERT_EQ(url2_, 757 new_browser->tab_strip_model()->GetActiveWebContents()->GetURL()); 758 759 ASSERT_EQ(url1_, 760 new_browser->tab_strip_model()->GetWebContentsAt(0)->GetURL()); 761 } 762 763 // Creates two tabs, closes one, quits and makes sure only one tab is restored. 764 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, ClosedTabStaysClosed) { 765 ui_test_utils::NavigateToURL(browser(), url1_); 766 767 ui_test_utils::NavigateToURLWithDisposition( 768 browser(), url2_, NEW_FOREGROUND_TAB, 769 ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION); 770 chrome::CloseTab(browser()); 771 772 Browser* new_browser = QuitBrowserAndRestore(browser(), 1); 773 774 AssertOneWindowWithOneTab(new_browser); 775 ASSERT_EQ(url1_, 776 new_browser->tab_strip_model()->GetActiveWebContents()->GetURL()); 777 } 778 779 // Ensures active tab properly restored when tabs before it closed. 780 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, ActiveIndexUpdatedAtClose) { 781 ui_test_utils::NavigateToURL(browser(), url1_); 782 ui_test_utils::NavigateToURLWithDisposition( 783 browser(), url2_, NEW_FOREGROUND_TAB, 784 ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION); 785 ui_test_utils::NavigateToURLWithDisposition( 786 browser(), url3_, NEW_BACKGROUND_TAB, 787 ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION); 788 789 browser()->tab_strip_model()->CloseWebContentsAt( 790 0, 791 TabStripModel::CLOSE_CREATE_HISTORICAL_TAB); 792 793 Browser* new_browser = QuitBrowserAndRestore(browser(), 2); 794 795 ASSERT_EQ(url2_, 796 new_browser->tab_strip_model()->GetActiveWebContents()->GetURL()); 797 ASSERT_EQ(new_browser->tab_strip_model()->active_index(), 0); 798 } 799 800 // Ensures active tab properly restored when tabs are inserted before it . 801 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, ActiveIndexUpdatedAtInsert) { 802 ui_test_utils::NavigateToURL(browser(), url1_); 803 ui_test_utils::NavigateToURLWithDisposition( 804 browser(), url2_, NEW_BACKGROUND_TAB, 805 ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION); 806 807 chrome::NavigateParams navigate_params(browser(), url3_, 808 content::PAGE_TRANSITION_TYPED); 809 navigate_params.tabstrip_index = 0; 810 navigate_params.disposition = NEW_BACKGROUND_TAB; 811 ui_test_utils::NavigateToURL(&navigate_params); 812 813 Browser* new_browser = QuitBrowserAndRestore(browser(), 3); 814 815 ASSERT_EQ(url1_, 816 new_browser->tab_strip_model()->GetActiveWebContents()->GetURL()); 817 ASSERT_EQ(new_browser->tab_strip_model()->active_index(), 1); 818 } 819 820 // Creates a tabbed browser and popup and makes sure we restore both. 821 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, NormalAndPopup) { 822 if (!browser_defaults::kRestorePopups) 823 return; // Test only applicable if restoring popups. 824 825 ui_test_utils::NavigateToURL(browser(), url1_); 826 827 // Make sure we have one window. 828 AssertOneWindowWithOneTab(browser()); 829 830 // Open a popup. 831 Browser* popup = new Browser( 832 Browser::CreateParams(Browser::TYPE_POPUP, browser()->profile(), 833 browser()->host_desktop_type())); 834 popup->window()->Show(); 835 ASSERT_EQ(2u, active_browser_list_->size()); 836 837 ui_test_utils::NavigateToURL(popup, url1_); 838 839 // Simulate an exit by shuting down the session service. If we don't do this 840 // the first window close is treated as though the user closed the window 841 // and won't be restored. 842 SessionServiceFactory::ShutdownForProfile(browser()->profile()); 843 844 // Restart and make sure we have two windows. 845 QuitBrowserAndRestore(browser(), 1); 846 847 ASSERT_EQ(2u, active_browser_list_->size()); 848 849 Browser* browser1 = active_browser_list_->get(0); 850 Browser* browser2 = active_browser_list_->get(1); 851 852 Browser::Type type1 = browser1->type(); 853 Browser::Type type2 = browser2->type(); 854 855 // The order of whether the normal window or popup is first depends upon 856 // activation order, which is not necessarily consistant across runs. 857 if (type1 == Browser::TYPE_TABBED) { 858 EXPECT_EQ(type2, Browser::TYPE_POPUP); 859 } else { 860 EXPECT_EQ(type1, Browser::TYPE_POPUP); 861 EXPECT_EQ(type2, Browser::TYPE_TABBED); 862 } 863 } 864 865 #if !defined(OS_CHROMEOS) && !defined(OS_MACOSX) 866 // This test doesn't apply to the Mac version; see GetCommandLineForRelaunch 867 // for details. It was disabled for a long time so might never have worked on 868 // ChromeOS. 869 870 // Launches an app window, closes tabbed browser, launches and makes sure 871 // we restore the tabbed browser url. 872 // If this test flakes, use http://crbug.com/29110 873 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, 874 RestoreAfterClosingTabbedBrowserWithAppAndLaunching) { 875 #if defined(OS_WIN) && defined(USE_ASH) 876 // Disable this test in Metro+Ash for now (http://crbug.com/262796). 877 if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kAshBrowserTests)) 878 return; 879 #endif 880 881 ui_test_utils::NavigateToURL(browser(), url1_); 882 883 // Launch an app. 884 CommandLine app_launch_arguments = GetCommandLineForRelaunch(); 885 app_launch_arguments.AppendSwitchASCII(switches::kApp, url2_.spec()); 886 887 ui_test_utils::BrowserAddedObserver window_observer; 888 889 base::LaunchProcess(app_launch_arguments, base::LaunchOptions(), NULL); 890 891 Browser* app_window = window_observer.WaitForSingleNewBrowser(); 892 ASSERT_EQ(2u, active_browser_list_->size()); 893 894 // Close the first window. The only window left is the App window. 895 CloseBrowserSynchronously(browser()); 896 897 // Restore the session, which should bring back the first window with url1_. 898 Browser* new_browser = QuitBrowserAndRestore(app_window, 1); 899 900 AssertOneWindowWithOneTab(new_browser); 901 902 ASSERT_EQ(url1_, 903 new_browser->tab_strip_model()->GetActiveWebContents()->GetURL()); 904 } 905 906 #endif // !defined(OS_CHROMEOS) && !defined(OS_MACOSX) 907 908 // Creates two windows, closes one, restores, make sure only one window open. 909 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, TwoWindowsCloseOneRestoreOnlyOne) { 910 ui_test_utils::NavigateToURL(browser(), url1_); 911 912 // Open a second window. 913 ui_test_utils::NavigateToURLWithDisposition( 914 browser(), GURL(content::kAboutBlankURL), NEW_WINDOW, 915 ui_test_utils::BROWSER_TEST_WAIT_FOR_BROWSER); 916 917 ASSERT_EQ(2u, active_browser_list_->size()); 918 919 // Close it. 920 Browser* new_window = active_browser_list_->get(1); 921 CloseBrowserSynchronously(new_window); 922 923 // Restart and make sure we have only one window with one tab and the url 924 // is url1_. 925 Browser* new_browser = QuitBrowserAndRestore(browser(), 1); 926 927 AssertOneWindowWithOneTab(new_browser); 928 929 ASSERT_EQ(url1_, 930 new_browser->tab_strip_model()->GetActiveWebContents()->GetURL()); 931 } 932 933 // Make sure after a restore the number of processes matches that of the number 934 // of processes running before the restore. This creates a new tab so that 935 // we should have two new tabs running. (This test will pass in both 936 // process-per-site and process-per-site-instance, because we treat the new tab 937 // as a special case in process-per-site-instance so that it only ever uses one 938 // process.) 939 // 940 // Flaky: http://code.google.com/p/chromium/issues/detail?id=52022 941 // Unfortunately, the fix at http://codereview.chromium.org/6546078 942 // breaks NTP background image refreshing, so ThemeSource had to revert to 943 // replacing the existing data source. 944 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, ShareProcessesOnRestore) { 945 // Create two new tabs. 946 ui_test_utils::NavigateToURLWithDisposition( 947 browser(), GURL(content::kAboutBlankURL), NEW_FOREGROUND_TAB, 948 ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION); 949 ui_test_utils::NavigateToURLWithDisposition( 950 browser(), GURL(content::kAboutBlankURL), NEW_FOREGROUND_TAB, 951 ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION); 952 953 int expected_process_count = RenderProcessHostCount(); 954 955 // Restart. 956 Browser* new_browser = QuitBrowserAndRestore(browser(), 3); 957 958 ASSERT_EQ(3, new_browser->tab_strip_model()->count()); 959 960 ASSERT_EQ(expected_process_count, RenderProcessHostCount()); 961 } 962 963 // Test that changing the user agent override will persist it to disk. 964 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, PersistAndRestoreUserAgentOverride) { 965 // Create a tab with an overridden user agent. 966 ui_test_utils::NavigateToURL(browser(), url1_); 967 ASSERT_EQ(0, browser()->tab_strip_model()->active_index()); 968 browser()->tab_strip_model()->GetWebContentsAt(0)-> 969 SetUserAgentOverride("override"); 970 971 // Create a tab without an overridden user agent. 972 ui_test_utils::NavigateToURLWithDisposition( 973 browser(), url2_, NEW_FOREGROUND_TAB, 974 ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION); 975 ASSERT_EQ(1, browser()->tab_strip_model()->active_index()); 976 977 // Kill the original browser then open a new one to trigger a restore. 978 Browser* new_browser = QuitBrowserAndRestore(browser(), 1); 979 ASSERT_EQ(1u, active_browser_list_->size()); 980 ASSERT_EQ(2, new_browser->tab_strip_model()->count()); 981 ASSERT_EQ(1, new_browser->tab_strip_model()->active_index()); 982 983 // Confirm that the user agent overrides are properly set. 984 EXPECT_EQ("override", 985 new_browser->tab_strip_model()->GetWebContentsAt(0)-> 986 GetUserAgentOverride()); 987 EXPECT_EQ("", 988 new_browser->tab_strip_model()->GetWebContentsAt(1)-> 989 GetUserAgentOverride()); 990 } 991 992 // Regression test for crbug.com/125958. When restoring a pinned selected tab in 993 // a setting where there are existing tabs, the selected index computation was 994 // wrong, leading to the wrong tab getting selected, DCHECKs firing, and the 995 // pinned tab not getting loaded. 996 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, RestorePinnedSelectedTab) { 997 // Create a pinned tab. 998 ui_test_utils::NavigateToURL(browser(), url1_); 999 browser()->tab_strip_model()->SetTabPinned(0, true); 1000 ASSERT_EQ(0, browser()->tab_strip_model()->active_index()); 1001 // Create a nonpinned tab. 1002 ui_test_utils::NavigateToURLWithDisposition( 1003 browser(), url2_, NEW_FOREGROUND_TAB, 1004 ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION); 1005 ASSERT_EQ(1, browser()->tab_strip_model()->active_index()); 1006 // Select the pinned tab. 1007 browser()->tab_strip_model()->ActivateTabAt(0, true); 1008 ASSERT_EQ(0, browser()->tab_strip_model()->active_index()); 1009 Profile* profile = browser()->profile(); 1010 1011 // This will also initiate a session restore, but we're not interested in it. 1012 Browser* new_browser = QuitBrowserAndRestore(browser(), 1); 1013 ASSERT_EQ(1u, active_browser_list_->size()); 1014 ASSERT_EQ(2, new_browser->tab_strip_model()->count()); 1015 ASSERT_EQ(0, new_browser->tab_strip_model()->active_index()); 1016 // Close the pinned tab. 1017 chrome::CloseTab(new_browser); 1018 ASSERT_EQ(1, new_browser->tab_strip_model()->count()); 1019 ASSERT_EQ(0, new_browser->tab_strip_model()->active_index()); 1020 // Use the existing tab to navigate away, so that we can verify it was really 1021 // clobbered. 1022 ui_test_utils::NavigateToURL(new_browser, url3_); 1023 1024 // Restore the session again, clobbering the existing tab. 1025 SessionRestore::RestoreSession( 1026 profile, new_browser, 1027 new_browser->host_desktop_type(), 1028 SessionRestore::CLOBBER_CURRENT_TAB | SessionRestore::SYNCHRONOUS, 1029 std::vector<GURL>()); 1030 1031 // The pinned tab is the selected tab. 1032 ASSERT_EQ(2, new_browser->tab_strip_model()->count()); 1033 EXPECT_EQ(0, new_browser->tab_strip_model()->active_index()); 1034 EXPECT_EQ(url1_, 1035 new_browser->tab_strip_model()->GetActiveWebContents()->GetURL()); 1036 EXPECT_EQ(url2_, 1037 new_browser->tab_strip_model()->GetWebContentsAt(1)->GetURL()); 1038 } 1039 1040 // Regression test for crbug.com/240156. When restoring tabs with a navigation, 1041 // the navigation should take active tab focus. 1042 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, RestoreWithNavigateSelectedTab) { 1043 // Create 2 tabs. 1044 ui_test_utils::NavigateToURL(browser(), url1_); 1045 ui_test_utils::NavigateToURLWithDisposition( 1046 browser(), url2_, NEW_FOREGROUND_TAB, 1047 ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION); 1048 1049 // Restore the session by calling chrome::Navigate(). 1050 Browser* new_browser = QuitBrowserAndRestoreWithURL(browser(), 3, url3_); 1051 ASSERT_EQ(1u, active_browser_list_->size()); 1052 ASSERT_EQ(3, new_browser->tab_strip_model()->count()); 1053 // Navigated url should be the active tab. 1054 ASSERT_EQ(url3_, 1055 new_browser->tab_strip_model()->GetActiveWebContents()->GetURL()); 1056 } 1057 1058 // Do a clobber restore from the new tab page. This test follows the code path 1059 // of a crash followed by the user clicking restore from the new tab page. 1060 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, ClobberRestoreTest) { 1061 // Create 2 tabs. 1062 ui_test_utils::NavigateToURL(browser(), url1_); 1063 ASSERT_EQ(0, browser()->tab_strip_model()->active_index()); 1064 ui_test_utils::NavigateToURLWithDisposition( 1065 browser(), url2_, NEW_FOREGROUND_TAB, 1066 ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION); 1067 ASSERT_EQ(1, browser()->tab_strip_model()->active_index()); 1068 Profile* profile = browser()->profile(); 1069 1070 // This will also initiate a session restore, but we're not interested in it. 1071 Browser* new_browser = QuitBrowserAndRestore(browser(), 1); 1072 ASSERT_EQ(1u, active_browser_list_->size()); 1073 ASSERT_EQ(2, new_browser->tab_strip_model()->count()); 1074 ASSERT_EQ(1, new_browser->tab_strip_model()->active_index()); 1075 // Close the first tab. 1076 chrome::CloseTab(new_browser); 1077 ASSERT_EQ(1, new_browser->tab_strip_model()->count()); 1078 ASSERT_EQ(0, new_browser->tab_strip_model()->active_index()); 1079 // Use the existing tab to navigate to the NTP. 1080 ui_test_utils::NavigateToURL(new_browser, GURL(chrome::kChromeUINewTabURL)); 1081 1082 // Restore the session again, clobbering the existing tab. 1083 SessionRestore::RestoreSession( 1084 profile, new_browser, 1085 new_browser->host_desktop_type(), 1086 SessionRestore::CLOBBER_CURRENT_TAB | SessionRestore::SYNCHRONOUS, 1087 std::vector<GURL>()); 1088 1089 // 2 tabs should have been restored, with the existing tab clobbered, giving 1090 // us a total of 2 tabs. 1091 ASSERT_EQ(2, new_browser->tab_strip_model()->count()); 1092 EXPECT_EQ(1, new_browser->tab_strip_model()->active_index()); 1093 EXPECT_EQ(url1_, 1094 new_browser->tab_strip_model()->GetWebContentsAt(0)->GetURL()); 1095 EXPECT_EQ(url2_, 1096 new_browser->tab_strip_model()->GetActiveWebContents()->GetURL()); 1097 } 1098 1099 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, SessionStorage) { 1100 ui_test_utils::NavigateToURL(browser(), url1_); 1101 content::NavigationController* controller = 1102 &browser()->tab_strip_model()->GetActiveWebContents()->GetController(); 1103 ASSERT_TRUE(controller->GetDefaultSessionStorageNamespace()); 1104 std::string session_storage_persistent_id = 1105 controller->GetDefaultSessionStorageNamespace()->persistent_id(); 1106 Browser* new_browser = QuitBrowserAndRestore(browser(), 1); 1107 ASSERT_EQ(1u, active_browser_list_->size()); 1108 ASSERT_EQ(url1_, 1109 new_browser->tab_strip_model()->GetActiveWebContents()->GetURL()); 1110 content::NavigationController* new_controller = 1111 &new_browser->tab_strip_model()->GetActiveWebContents()->GetController(); 1112 ASSERT_TRUE(new_controller->GetDefaultSessionStorageNamespace()); 1113 std::string restored_session_storage_persistent_id = 1114 new_controller->GetDefaultSessionStorageNamespace()->persistent_id(); 1115 EXPECT_EQ(session_storage_persistent_id, 1116 restored_session_storage_persistent_id); 1117 } 1118 1119 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, SessionStorageAfterTabReplace) { 1120 // Simulate what prerendering does: create a new WebContents with the same 1121 // SessionStorageNamespace as an existing tab, then replace the tab with it. 1122 { 1123 content::NavigationController* controller = 1124 &browser()->tab_strip_model()->GetActiveWebContents()->GetController(); 1125 ASSERT_TRUE(controller->GetDefaultSessionStorageNamespace()); 1126 1127 content::SessionStorageNamespaceMap session_storage_namespace_map; 1128 session_storage_namespace_map[std::string()] = 1129 controller->GetDefaultSessionStorageNamespace(); 1130 scoped_ptr<content::WebContents> web_contents( 1131 content::WebContents::CreateWithSessionStorage( 1132 content::WebContents::CreateParams(browser()->profile()), 1133 session_storage_namespace_map)); 1134 1135 TabStripModel* tab_strip_model = browser()->tab_strip_model(); 1136 scoped_ptr<content::WebContents> old_web_contents( 1137 tab_strip_model->ReplaceWebContentsAt( 1138 tab_strip_model->active_index(), web_contents.release())); 1139 // Navigate with the new tab. 1140 ui_test_utils::NavigateToURL(browser(), url2_); 1141 // old_web_contents goes out of scope. 1142 } 1143 1144 // Check that the sessionStorage data is going to be persisted. 1145 content::NavigationController* controller = 1146 &browser()->tab_strip_model()->GetActiveWebContents()->GetController(); 1147 EXPECT_TRUE( 1148 controller->GetDefaultSessionStorageNamespace()->should_persist()); 1149 1150 // Quit and restore. Check that no extra tabs were created. 1151 Browser* new_browser = QuitBrowserAndRestore(browser(), 1); 1152 ASSERT_EQ(1u, active_browser_list_->size()); 1153 EXPECT_EQ(1, new_browser->tab_strip_model()->count()); 1154 } 1155