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 "base/command_line.h" 6 #include "base/files/file_path.h" 7 #include "base/files/file_util.h" 8 #include "base/lazy_instance.h" 9 #include "base/path_service.h" 10 #include "base/prefs/pref_service.h" 11 #include "base/strings/utf_string_conversions.h" 12 #include "chrome/browser/background/background_mode_manager.h" 13 #include "chrome/browser/browser_process.h" 14 #include "chrome/browser/chrome_notification_types.h" 15 #include "chrome/browser/content_settings/cookie_settings.h" 16 #include "chrome/browser/defaults.h" 17 #include "chrome/browser/infobars/infobar_service.h" 18 #include "chrome/browser/lifetime/application_lifetime.h" 19 #include "chrome/browser/prefs/session_startup_pref.h" 20 #include "chrome/browser/profiles/profile.h" 21 #include "chrome/browser/profiles/profile_impl.h" 22 #include "chrome/browser/profiles/profile_manager.h" 23 #include "chrome/browser/sessions/session_backend.h" 24 #include "chrome/browser/sessions/session_service_factory.h" 25 #include "chrome/browser/sessions/session_service_test_helper.h" 26 #include "chrome/browser/ui/browser.h" 27 #include "chrome/browser/ui/browser_commands.h" 28 #include "chrome/browser/ui/browser_iterator.h" 29 #include "chrome/browser/ui/browser_window.h" 30 #include "chrome/browser/ui/startup/startup_browser_creator.h" 31 #include "chrome/browser/ui/tabs/tab_strip_model.h" 32 #include "chrome/common/chrome_switches.h" 33 #include "chrome/common/pref_names.h" 34 #include "chrome/common/url_constants.h" 35 #include "chrome/test/base/in_process_browser_test.h" 36 #include "chrome/test/base/ui_test_utils.h" 37 #include "components/content_settings/core/common/content_settings.h" 38 #include "components/infobars/core/confirm_infobar_delegate.h" 39 #include "content/public/browser/web_contents.h" 40 #include "content/public/common/url_constants.h" 41 #include "content/public/test/browser_test_utils.h" 42 #include "net/base/net_util.h" 43 #include "net/base/upload_bytes_element_reader.h" 44 #include "net/base/upload_data_stream.h" 45 #include "net/url_request/url_request.h" 46 #include "net/url_request/url_request_filter.h" 47 #include "net/url_request/url_request_test_job.h" 48 49 #if defined(OS_MACOSX) 50 #include "base/mac/scoped_nsautorelease_pool.h" 51 #endif 52 53 namespace { 54 55 // We need to serve the test files so that PRE_Test and Test can access the same 56 // page using the same URL. In addition, perceived security origin of the page 57 // needs to stay the same, so e.g., redirecting the URL requests doesn't 58 // work. (If we used a test server, the PRE_Test and Test would have separate 59 // instances running on separate ports.) 60 61 base::LazyInstance<std::map<std::string, std::string> > g_file_contents = 62 LAZY_INSTANCE_INITIALIZER; 63 64 net::URLRequestJob* URLRequestFaker( 65 net::URLRequest* request, 66 net::NetworkDelegate* network_delegate, 67 const std::string& scheme) { 68 return new net::URLRequestTestJob( 69 request, network_delegate, net::URLRequestTestJob::test_headers(), 70 g_file_contents.Get()[request->url().path()], true); 71 } 72 73 base::LazyInstance<std::string> g_last_upload_bytes = LAZY_INSTANCE_INITIALIZER; 74 75 net::URLRequestJob* URLRequestFakerForPostRequests( 76 net::URLRequest* request, 77 net::NetworkDelegate* network_delegate, 78 const std::string& scheme) { 79 // Read the uploaded data and store it to g_last_upload_bytes. 80 const net::UploadDataStream* upload_data = request->get_upload(); 81 g_last_upload_bytes.Get().clear(); 82 if (upload_data) { 83 const ScopedVector<net::UploadElementReader>& readers = 84 upload_data->element_readers(); 85 for (size_t i = 0; i < readers.size(); ++i) { 86 const net::UploadBytesElementReader* bytes_reader = 87 readers[i]->AsBytesReader(); 88 if (bytes_reader) { 89 g_last_upload_bytes.Get() += 90 std::string(bytes_reader->bytes(), bytes_reader->length()); 91 } 92 } 93 } 94 return new net::URLRequestTestJob( 95 request, network_delegate, net::URLRequestTestJob::test_headers(), 96 "<html><head><title>PASS</title></head><body>Data posted</body></html>", 97 true); 98 } 99 100 class FakeBackgroundModeManager : public BackgroundModeManager { 101 public: 102 FakeBackgroundModeManager() 103 : BackgroundModeManager( 104 CommandLine::ForCurrentProcess(), 105 &g_browser_process->profile_manager()->GetProfileInfoCache()), 106 background_mode_active_(false) {} 107 108 void SetBackgroundModeActive(bool active) { 109 background_mode_active_ = active; 110 } 111 112 virtual bool IsBackgroundModeActive() OVERRIDE { 113 return background_mode_active_; 114 } 115 116 private: 117 bool background_mode_active_; 118 119 }; 120 121 } // namespace 122 123 class BetterSessionRestoreTest : public InProcessBrowserTest { 124 public: 125 BetterSessionRestoreTest() 126 : fake_server_address_("http://www.test.com/"), 127 test_path_("session_restore/"), 128 title_pass_(base::ASCIIToUTF16("PASS")), 129 title_storing_(base::ASCIIToUTF16("STORING")), 130 title_error_write_failed_(base::ASCIIToUTF16("ERROR_WRITE_FAILED")), 131 title_error_empty_(base::ASCIIToUTF16("ERROR_EMPTY")) { 132 // Set up the URL request filtering. 133 std::vector<std::string> test_files; 134 test_files.push_back("common.js"); 135 test_files.push_back("cookies.html"); 136 test_files.push_back("local_storage.html"); 137 test_files.push_back("post.html"); 138 test_files.push_back("post_with_password.html"); 139 test_files.push_back("session_cookies.html"); 140 test_files.push_back("session_storage.html"); 141 base::FilePath test_file_dir; 142 CHECK(PathService::Get(base::DIR_SOURCE_ROOT, &test_file_dir)); 143 test_file_dir = 144 test_file_dir.AppendASCII("chrome/test/data").AppendASCII(test_path_); 145 146 for (std::vector<std::string>::const_iterator it = test_files.begin(); 147 it != test_files.end(); ++it) { 148 base::FilePath path = test_file_dir.AppendASCII(*it); 149 std::string contents; 150 CHECK(base::ReadFileToString(path, &contents)); 151 g_file_contents.Get()["/" + test_path_ + *it] = contents; 152 net::URLRequestFilter::GetInstance()->AddUrlHandler( 153 GURL(fake_server_address_ + test_path_ + *it), 154 &URLRequestFaker); 155 } 156 net::URLRequestFilter::GetInstance()->AddUrlHandler( 157 GURL(fake_server_address_ + test_path_ + "posted.php"), 158 &URLRequestFakerForPostRequests); 159 } 160 161 protected: 162 virtual void SetUpOnMainThread() OVERRIDE { 163 SessionServiceTestHelper helper( 164 SessionServiceFactory::GetForProfile(browser()->profile())); 165 helper.SetForceBrowserNotAliveWithNoWindows(true); 166 helper.ReleaseService(); 167 g_browser_process->set_background_mode_manager_for_test( 168 scoped_ptr<BackgroundModeManager>(new FakeBackgroundModeManager)); 169 } 170 171 void StoreDataWithPage(const std::string& filename) { 172 StoreDataWithPage(browser(), filename); 173 } 174 175 void StoreDataWithPage(Browser* browser, const std::string& filename) { 176 content::WebContents* web_contents = 177 browser->tab_strip_model()->GetActiveWebContents(); 178 content::TitleWatcher title_watcher(web_contents, title_storing_); 179 title_watcher.AlsoWaitForTitle(title_pass_); 180 title_watcher.AlsoWaitForTitle(title_error_write_failed_); 181 title_watcher.AlsoWaitForTitle(title_error_empty_); 182 ui_test_utils::NavigateToURL( 183 browser, GURL(fake_server_address_ + test_path_ + filename)); 184 base::string16 final_title = title_watcher.WaitAndGetTitle(); 185 EXPECT_EQ(title_storing_, final_title); 186 } 187 188 void NavigateAndCheckStoredData(const std::string& filename) { 189 NavigateAndCheckStoredData(browser(), filename); 190 } 191 192 void NavigateAndCheckStoredData(Browser* browser, 193 const std::string& filename) { 194 // Navigate to a page which has previously stored data; check that the 195 // stored data can be accessed. 196 content::WebContents* web_contents = 197 browser->tab_strip_model()->GetActiveWebContents(); 198 content::TitleWatcher title_watcher(web_contents, title_pass_); 199 title_watcher.AlsoWaitForTitle(title_storing_); 200 title_watcher.AlsoWaitForTitle(title_error_write_failed_); 201 title_watcher.AlsoWaitForTitle(title_error_empty_); 202 ui_test_utils::NavigateToURL( 203 browser, GURL(fake_server_address_ + test_path_ + filename)); 204 base::string16 final_title = title_watcher.WaitAndGetTitle(); 205 EXPECT_EQ(title_pass_, final_title); 206 } 207 208 void CheckReloadedPageRestored() { 209 CheckTitle(browser(), title_pass_); 210 } 211 212 void CheckReloadedPageRestored(Browser* browser) { 213 CheckTitle(browser, title_pass_); 214 } 215 216 void CheckReloadedPageNotRestored() { 217 CheckReloadedPageNotRestored(browser()); 218 } 219 220 void CheckReloadedPageNotRestored(Browser* browser) { 221 CheckTitle(browser, title_storing_); 222 } 223 224 void CheckTitle(Browser* browser, const base::string16& expected_title) { 225 content::WebContents* web_contents = 226 browser->tab_strip_model()->GetWebContentsAt(0); 227 content::TitleWatcher title_watcher(web_contents, expected_title); 228 title_watcher.AlsoWaitForTitle(title_pass_); 229 title_watcher.AlsoWaitForTitle(title_storing_); 230 title_watcher.AlsoWaitForTitle(title_error_write_failed_); 231 title_watcher.AlsoWaitForTitle(title_error_empty_); 232 // It's possible that the title was already the right one before 233 // title_watcher was created. 234 base::string16 first_title = web_contents->GetTitle(); 235 if (first_title != title_pass_ && 236 first_title != title_storing_ && 237 first_title != title_error_write_failed_ && 238 first_title != title_error_empty_) { 239 base::string16 final_title = title_watcher.WaitAndGetTitle(); 240 EXPECT_EQ(expected_title, final_title); 241 } else { 242 EXPECT_EQ(expected_title, first_title); 243 } 244 } 245 246 void PostFormWithPage(const std::string& filename, bool password_present) { 247 content::WebContents* web_contents = 248 browser()->tab_strip_model()->GetActiveWebContents(); 249 content::TitleWatcher title_watcher(web_contents, title_pass_); 250 ui_test_utils::NavigateToURL( 251 browser(), GURL(fake_server_address_ + test_path_ + filename)); 252 base::string16 final_title = title_watcher.WaitAndGetTitle(); 253 EXPECT_EQ(title_pass_, final_title); 254 EXPECT_TRUE(g_last_upload_bytes.Get().find("posted-text") != 255 std::string::npos); 256 EXPECT_TRUE(g_last_upload_bytes.Get().find("text-entered") != 257 std::string::npos); 258 if (password_present) { 259 EXPECT_TRUE(g_last_upload_bytes.Get().find("posted-password") != 260 std::string::npos); 261 EXPECT_TRUE(g_last_upload_bytes.Get().find("password-entered") != 262 std::string::npos); 263 } 264 } 265 266 void CheckFormRestored(bool text_present, bool password_present) { 267 CheckFormRestored(browser(), text_present, password_present); 268 } 269 270 void CheckFormRestored( 271 Browser* browser, bool text_present, bool password_present) { 272 CheckReloadedPageRestored(browser); 273 if (text_present) { 274 EXPECT_TRUE(g_last_upload_bytes.Get().find("posted-text") != 275 std::string::npos); 276 EXPECT_TRUE(g_last_upload_bytes.Get().find("text-entered") != 277 std::string::npos); 278 } else { 279 EXPECT_TRUE(g_last_upload_bytes.Get().find("posted-text") == 280 std::string::npos); 281 EXPECT_TRUE(g_last_upload_bytes.Get().find("text-entered") == 282 std::string::npos); 283 } 284 if (password_present) { 285 EXPECT_TRUE(g_last_upload_bytes.Get().find("posted-password") != 286 std::string::npos); 287 EXPECT_TRUE(g_last_upload_bytes.Get().find("password-entered") != 288 std::string::npos); 289 } else { 290 EXPECT_TRUE(g_last_upload_bytes.Get().find("posted-password") == 291 std::string::npos); 292 EXPECT_TRUE(g_last_upload_bytes.Get().find("password-entered") == 293 std::string::npos); 294 } 295 } 296 297 void CloseBrowserSynchronously(Browser* browser, bool close_all_windows) { 298 content::WindowedNotificationObserver observer( 299 chrome::NOTIFICATION_BROWSER_CLOSED, 300 content::NotificationService::AllSources()); 301 if (close_all_windows) 302 chrome::CloseAllBrowsers(); 303 else 304 browser->window()->Close(); 305 #if defined(OS_MACOSX) 306 // BrowserWindowController depends on the auto release pool being recycled 307 // in the message loop to delete itself, which frees the Browser object 308 // which fires this event. 309 AutoreleasePool()->Recycle(); 310 #endif 311 observer.Wait(); 312 } 313 314 virtual Browser* QuitBrowserAndRestore(Browser* browser, 315 bool close_all_windows) { 316 Profile* profile = browser->profile(); 317 318 // Close the browser. 319 chrome::IncrementKeepAliveCount(); 320 CloseBrowserSynchronously(browser, close_all_windows); 321 322 SessionServiceTestHelper helper; 323 helper.SetService( 324 SessionServiceFactory::GetForProfileForSessionRestore(profile)); 325 helper.SetForceBrowserNotAliveWithNoWindows(true); 326 helper.ReleaseService(); 327 328 // Create a new window, which should trigger session restore. 329 ui_test_utils::BrowserAddedObserver window_observer; 330 chrome::NewEmptyWindow(profile, chrome::HOST_DESKTOP_TYPE_NATIVE); 331 Browser* new_browser = window_observer.WaitForSingleNewBrowser(); 332 chrome::DecrementKeepAliveCount(); 333 334 return new_browser; 335 } 336 337 std::string fake_server_address() { 338 return fake_server_address_; 339 } 340 341 std::string test_path() { 342 return test_path_; 343 } 344 345 void EnableBackgroundMode() { 346 static_cast<FakeBackgroundModeManager*>( 347 g_browser_process->background_mode_manager())-> 348 SetBackgroundModeActive(true); 349 } 350 351 void DisableBackgroundMode() { 352 static_cast<FakeBackgroundModeManager*>( 353 g_browser_process->background_mode_manager())-> 354 SetBackgroundModeActive(false); 355 } 356 357 private: 358 const std::string fake_server_address_; 359 const std::string test_path_; 360 const base::string16 title_pass_; 361 const base::string16 title_storing_; 362 const base::string16 title_error_write_failed_; 363 const base::string16 title_error_empty_; 364 365 DISALLOW_COPY_AND_ASSIGN(BetterSessionRestoreTest); 366 }; 367 368 class ContinueWhereILeftOffTest : public BetterSessionRestoreTest { 369 public: 370 ContinueWhereILeftOffTest() { } 371 372 virtual void SetUpOnMainThread() OVERRIDE { 373 BetterSessionRestoreTest::SetUpOnMainThread(); 374 SessionStartupPref::SetStartupPref( 375 browser()->profile(), SessionStartupPref(SessionStartupPref::LAST)); 376 } 377 378 protected: 379 virtual Browser* QuitBrowserAndRestore(Browser* browser, 380 bool close_all_windows) OVERRIDE { 381 content::WindowedNotificationObserver session_restore_observer( 382 chrome::NOTIFICATION_SESSION_RESTORE_DONE, 383 content::NotificationService::AllSources()); 384 Browser* new_browser = BetterSessionRestoreTest::QuitBrowserAndRestore( 385 browser, close_all_windows); 386 session_restore_observer.Wait(); 387 return new_browser; 388 } 389 390 DISALLOW_COPY_AND_ASSIGN(ContinueWhereILeftOffTest); 391 }; 392 393 IN_PROC_BROWSER_TEST_F(ContinueWhereILeftOffTest, PRE_SessionCookies) { 394 // Set the startup preference to "continue where I left off" and visit a page 395 // which stores a session cookie. 396 StoreDataWithPage("session_cookies.html"); 397 } 398 399 IN_PROC_BROWSER_TEST_F(ContinueWhereILeftOffTest, SessionCookies) { 400 // The browsing session will be continued; just wait for the page to reload 401 // and check the stored data. 402 CheckReloadedPageRestored(); 403 } 404 405 IN_PROC_BROWSER_TEST_F(ContinueWhereILeftOffTest, PRE_SessionStorage) { 406 StoreDataWithPage("session_storage.html"); 407 } 408 409 IN_PROC_BROWSER_TEST_F(ContinueWhereILeftOffTest, SessionStorage) { 410 CheckReloadedPageRestored(); 411 } 412 413 IN_PROC_BROWSER_TEST_F(ContinueWhereILeftOffTest, 414 PRE_PRE_LocalStorageClearedOnExit) { 415 StoreDataWithPage("local_storage.html"); 416 } 417 418 IN_PROC_BROWSER_TEST_F(ContinueWhereILeftOffTest, 419 PRE_LocalStorageClearedOnExit) { 420 // Normally localStorage is restored. 421 CheckReloadedPageRestored(); 422 // ... but not if it's set to clear on exit. 423 CookieSettings::Factory::GetForProfile(browser()->profile())-> 424 SetDefaultCookieSetting(CONTENT_SETTING_SESSION_ONLY); 425 } 426 427 IN_PROC_BROWSER_TEST_F(ContinueWhereILeftOffTest, LocalStorageClearedOnExit) { 428 CheckReloadedPageNotRestored(); 429 } 430 431 IN_PROC_BROWSER_TEST_F(ContinueWhereILeftOffTest, 432 PRE_PRE_CookiesClearedOnExit) { 433 StoreDataWithPage("cookies.html"); 434 } 435 436 IN_PROC_BROWSER_TEST_F(ContinueWhereILeftOffTest, PRE_CookiesClearedOnExit) { 437 // Normally cookies are restored. 438 CheckReloadedPageRestored(); 439 // ... but not if the content setting is set to clear on exit. 440 CookieSettings::Factory::GetForProfile(browser()->profile())-> 441 SetDefaultCookieSetting(CONTENT_SETTING_SESSION_ONLY); 442 } 443 444 IN_PROC_BROWSER_TEST_F(ContinueWhereILeftOffTest, CookiesClearedOnExit) { 445 CheckReloadedPageNotRestored(); 446 } 447 448 IN_PROC_BROWSER_TEST_F(ContinueWhereILeftOffTest, PRE_Post) { 449 PostFormWithPage("post.html", false); 450 } 451 452 IN_PROC_BROWSER_TEST_F(ContinueWhereILeftOffTest, Post) { 453 CheckFormRestored(true, false); 454 } 455 456 IN_PROC_BROWSER_TEST_F(ContinueWhereILeftOffTest, PRE_PostWithPassword) { 457 PostFormWithPage("post_with_password.html", true); 458 } 459 460 IN_PROC_BROWSER_TEST_F(ContinueWhereILeftOffTest, PostWithPassword) { 461 CheckReloadedPageRestored(); 462 // The form data contained passwords, so it's removed completely. 463 CheckFormRestored(false, false); 464 } 465 466 IN_PROC_BROWSER_TEST_F(ContinueWhereILeftOffTest, SessionCookiesBrowserClose) { 467 // Set the startup preference to "continue where I left off" and visit a page 468 // which stores a session cookie. 469 StoreDataWithPage("session_cookies.html"); 470 Browser* new_browser = QuitBrowserAndRestore(browser(), false); 471 // The browsing session will be continued; just wait for the page to reload 472 // and check the stored data. 473 CheckReloadedPageRestored(new_browser); 474 } 475 476 // Test that leaving a popup open will not prevent session restore. 477 IN_PROC_BROWSER_TEST_F(ContinueWhereILeftOffTest, 478 SessionCookiesBrowserCloseWithPopupOpen) { 479 // Set the startup preference to "continue where I left off" and visit a page 480 // which stores a session cookie. 481 StoreDataWithPage("session_cookies.html"); 482 Browser* popup = new Browser(Browser::CreateParams( 483 Browser::TYPE_POPUP, 484 browser()->profile(), 485 chrome::HOST_DESKTOP_TYPE_NATIVE)); 486 popup->window()->Show(); 487 488 Browser* new_browser = QuitBrowserAndRestore(browser(), false); 489 // The browsing session will be continued; just wait for the page to reload 490 // and check the stored data. 491 CheckReloadedPageRestored(new_browser); 492 } 493 IN_PROC_BROWSER_TEST_F(ContinueWhereILeftOffTest, 494 CookiesClearedOnBrowserClose) { 495 StoreDataWithPage("cookies.html"); 496 // Normally cookies are restored. 497 Browser* new_browser = QuitBrowserAndRestore(browser(), false); 498 CheckReloadedPageRestored(new_browser); 499 // ... but not if the content setting is set to clear on exit. 500 CookieSettings::Factory::GetForProfile(new_browser->profile())-> 501 SetDefaultCookieSetting(CONTENT_SETTING_SESSION_ONLY); 502 // ... unless background mode is active. 503 EnableBackgroundMode(); 504 new_browser = QuitBrowserAndRestore(new_browser, false); 505 CheckReloadedPageRestored(new_browser); 506 507 DisableBackgroundMode(); 508 new_browser = QuitBrowserAndRestore(new_browser, false); 509 if (browser_defaults::kBrowserAliveWithNoWindows) 510 CheckReloadedPageRestored(new_browser); 511 else 512 CheckReloadedPageNotRestored(new_browser); 513 } 514 515 IN_PROC_BROWSER_TEST_F(ContinueWhereILeftOffTest, PostBrowserClose) { 516 PostFormWithPage("post.html", false); 517 Browser* new_browser = QuitBrowserAndRestore(browser(), false); 518 CheckFormRestored(new_browser, true, false); 519 } 520 521 IN_PROC_BROWSER_TEST_F(ContinueWhereILeftOffTest, 522 PostWithPasswordBrowserClose) { 523 PostFormWithPage("post_with_password.html", true); 524 Browser* new_browser = QuitBrowserAndRestore(browser(), false); 525 CheckReloadedPageRestored(new_browser); 526 // The form data contained passwords, so it's removed completely. 527 CheckFormRestored(new_browser, false, false); 528 } 529 530 // Check that session cookies are cleared on a wrench menu quit. 531 IN_PROC_BROWSER_TEST_F(ContinueWhereILeftOffTest, 532 SessionCookiesCloseAllBrowsers) { 533 // Set the startup preference to "continue where I left off" and visit a page 534 // which stores a session cookie. 535 StoreDataWithPage("session_cookies.html"); 536 Browser* new_browser = QuitBrowserAndRestore(browser(), true); 537 // The browsing session will be continued; just wait for the page to reload 538 // and check the stored data. 539 CheckReloadedPageRestored(new_browser); 540 } 541 542 // Check that cookies are cleared on a wrench menu quit only if cookies are set 543 // to current session only, regardless of whether background mode is enabled. 544 IN_PROC_BROWSER_TEST_F(ContinueWhereILeftOffTest, 545 CookiesClearedOnCloseAllBrowsers) { 546 StoreDataWithPage("cookies.html"); 547 // Normally cookies are restored. 548 Browser* new_browser = QuitBrowserAndRestore(browser(), true); 549 CheckReloadedPageRestored(new_browser); 550 // ... but not if the content setting is set to clear on exit. 551 CookieSettings::Factory::GetForProfile(new_browser->profile())-> 552 SetDefaultCookieSetting(CONTENT_SETTING_SESSION_ONLY); 553 // ... even if background mode is active. 554 EnableBackgroundMode(); 555 new_browser = QuitBrowserAndRestore(new_browser, true); 556 CheckReloadedPageNotRestored(new_browser); 557 558 DisableBackgroundMode(); 559 new_browser = QuitBrowserAndRestore(new_browser, true); 560 CheckReloadedPageNotRestored(new_browser); 561 } 562 563 // Check that form data is restored after wrench menu quit. 564 IN_PROC_BROWSER_TEST_F(ContinueWhereILeftOffTest, PostCloseAllBrowsers) { 565 PostFormWithPage("post.html", false); 566 Browser* new_browser = QuitBrowserAndRestore(browser(), true); 567 CheckFormRestored(new_browser, true, false); 568 } 569 570 // Check that form data with a password field is cleared after wrench menu quit. 571 IN_PROC_BROWSER_TEST_F(ContinueWhereILeftOffTest, 572 PostWithPasswordCloseAllBrowsers) { 573 PostFormWithPage("post_with_password.html", true); 574 Browser* new_browser = QuitBrowserAndRestore(browser(), true); 575 CheckReloadedPageRestored(new_browser); 576 // The form data contained passwords, so it's removed completely. 577 CheckFormRestored(new_browser, false, false); 578 } 579 580 class RestartTest : public BetterSessionRestoreTest { 581 public: 582 RestartTest() { } 583 virtual ~RestartTest() { } 584 protected: 585 void Restart() { 586 // Simluate restarting the browser, but let the test exit peacefully. 587 for (chrome::BrowserIterator it; !it.done(); it.Next()) 588 content::BrowserContext::SaveSessionState(it->profile()); 589 PrefService* pref_service = g_browser_process->local_state(); 590 pref_service->SetBoolean(prefs::kWasRestarted, true); 591 #if defined(OS_WIN) 592 if (pref_service->HasPrefPath(prefs::kRelaunchMode)) 593 pref_service->ClearPref(prefs::kRelaunchMode); 594 #endif 595 } 596 597 private: 598 DISALLOW_COPY_AND_ASSIGN(RestartTest); 599 }; 600 601 IN_PROC_BROWSER_TEST_F(RestartTest, PRE_SessionCookies) { 602 StoreDataWithPage("session_cookies.html"); 603 Restart(); 604 } 605 606 IN_PROC_BROWSER_TEST_F(RestartTest, SessionCookies) { 607 CheckReloadedPageRestored(); 608 } 609 610 IN_PROC_BROWSER_TEST_F(RestartTest, PRE_SessionStorage) { 611 StoreDataWithPage("session_storage.html"); 612 Restart(); 613 } 614 615 IN_PROC_BROWSER_TEST_F(RestartTest, SessionStorage) { 616 CheckReloadedPageRestored(); 617 } 618 619 IN_PROC_BROWSER_TEST_F(RestartTest, PRE_LocalStorageClearedOnExit) { 620 StoreDataWithPage("local_storage.html"); 621 CookieSettings::Factory::GetForProfile(browser()->profile())-> 622 SetDefaultCookieSetting(CONTENT_SETTING_SESSION_ONLY); 623 Restart(); 624 } 625 626 IN_PROC_BROWSER_TEST_F(RestartTest, LocalStorageClearedOnExit) { 627 CheckReloadedPageRestored(); 628 } 629 630 IN_PROC_BROWSER_TEST_F(RestartTest, PRE_CookiesClearedOnExit) { 631 StoreDataWithPage("cookies.html"); 632 CookieSettings::Factory::GetForProfile(browser()->profile())-> 633 SetDefaultCookieSetting(CONTENT_SETTING_SESSION_ONLY); 634 Restart(); 635 } 636 637 IN_PROC_BROWSER_TEST_F(RestartTest, CookiesClearedOnExit) { 638 CheckReloadedPageRestored(); 639 } 640 641 IN_PROC_BROWSER_TEST_F(RestartTest, PRE_Post) { 642 PostFormWithPage("post.html", false); 643 Restart(); 644 } 645 646 IN_PROC_BROWSER_TEST_F(RestartTest, Post) { 647 CheckFormRestored(true, false); 648 } 649 650 IN_PROC_BROWSER_TEST_F(RestartTest, PRE_PostWithPassword) { 651 PostFormWithPage("post_with_password.html", true); 652 Restart(); 653 } 654 655 IN_PROC_BROWSER_TEST_F(RestartTest, PostWithPassword) { 656 // The form data contained passwords, so it's removed completely. 657 CheckFormRestored(false, false); 658 } 659 660 // These tests ensure that the Better Session Restore features are not triggered 661 // when they shouldn't be. 662 class NoSessionRestoreTest : public BetterSessionRestoreTest { 663 public: 664 NoSessionRestoreTest() { } 665 666 virtual void SetUpOnMainThread() OVERRIDE { 667 BetterSessionRestoreTest::SetUpOnMainThread(); 668 SessionStartupPref::SetStartupPref( 669 browser()->profile(), SessionStartupPref(SessionStartupPref::DEFAULT)); 670 } 671 672 private: 673 DISALLOW_COPY_AND_ASSIGN(NoSessionRestoreTest); 674 }; 675 676 IN_PROC_BROWSER_TEST_F(NoSessionRestoreTest, PRE_SessionCookies) { 677 StoreDataWithPage("session_cookies.html"); 678 } 679 680 IN_PROC_BROWSER_TEST_F(NoSessionRestoreTest, SessionCookies) { 681 content::WebContents* web_contents = 682 browser()->tab_strip_model()->GetActiveWebContents(); 683 EXPECT_EQ(std::string(url::kAboutBlankURL), web_contents->GetURL().spec()); 684 // When we navigate to the page again, it doens't see the data previously 685 // stored. 686 StoreDataWithPage("session_cookies.html"); 687 } 688 689 IN_PROC_BROWSER_TEST_F(NoSessionRestoreTest, PRE_SessionStorage) { 690 StoreDataWithPage("session_storage.html"); 691 } 692 693 IN_PROC_BROWSER_TEST_F(NoSessionRestoreTest, SessionStorage) { 694 content::WebContents* web_contents = 695 browser()->tab_strip_model()->GetActiveWebContents(); 696 EXPECT_EQ(std::string(url::kAboutBlankURL), web_contents->GetURL().spec()); 697 StoreDataWithPage("session_storage.html"); 698 } 699 700 IN_PROC_BROWSER_TEST_F(NoSessionRestoreTest, 701 PRE_PRE_LocalStorageClearedOnExit) { 702 StoreDataWithPage("local_storage.html"); 703 } 704 705 IN_PROC_BROWSER_TEST_F(NoSessionRestoreTest, PRE_LocalStorageClearedOnExit) { 706 // Normally localStorage is persisted. 707 content::WebContents* web_contents = 708 browser()->tab_strip_model()->GetActiveWebContents(); 709 EXPECT_EQ(std::string(url::kAboutBlankURL), web_contents->GetURL().spec()); 710 NavigateAndCheckStoredData("local_storage.html"); 711 // ... but not if it's set to clear on exit. 712 CookieSettings::Factory::GetForProfile(browser()->profile())-> 713 SetDefaultCookieSetting(CONTENT_SETTING_SESSION_ONLY); 714 } 715 716 IN_PROC_BROWSER_TEST_F(NoSessionRestoreTest, LocalStorageClearedOnExit) { 717 content::WebContents* web_contents = 718 browser()->tab_strip_model()->GetActiveWebContents(); 719 EXPECT_EQ(std::string(url::kAboutBlankURL), web_contents->GetURL().spec()); 720 StoreDataWithPage("local_storage.html"); 721 } 722 723 IN_PROC_BROWSER_TEST_F(NoSessionRestoreTest, PRE_PRE_CookiesClearedOnExit) { 724 StoreDataWithPage("cookies.html"); 725 } 726 727 IN_PROC_BROWSER_TEST_F(NoSessionRestoreTest, PRE_CookiesClearedOnExit) { 728 // Normally cookies are restored. 729 content::WebContents* web_contents = 730 browser()->tab_strip_model()->GetActiveWebContents(); 731 EXPECT_EQ(std::string(url::kAboutBlankURL), web_contents->GetURL().spec()); 732 NavigateAndCheckStoredData("cookies.html"); 733 // ... but not if the content setting is set to clear on exit. 734 CookieSettings::Factory::GetForProfile(browser()->profile())-> 735 SetDefaultCookieSetting(CONTENT_SETTING_SESSION_ONLY); 736 } 737 738 IN_PROC_BROWSER_TEST_F(NoSessionRestoreTest, CookiesClearedOnExit) { 739 content::WebContents* web_contents = 740 browser()->tab_strip_model()->GetActiveWebContents(); 741 EXPECT_EQ(std::string(url::kAboutBlankURL), web_contents->GetURL().spec()); 742 StoreDataWithPage("local_storage.html"); 743 } 744 745 IN_PROC_BROWSER_TEST_F(NoSessionRestoreTest, SessionCookiesBrowserClose) { 746 StoreDataWithPage("session_cookies.html"); 747 EnableBackgroundMode(); 748 Browser* new_browser = QuitBrowserAndRestore(browser(), false); 749 NavigateAndCheckStoredData(new_browser, "session_cookies.html"); 750 DisableBackgroundMode(); 751 new_browser = QuitBrowserAndRestore(new_browser, false); 752 if (browser_defaults::kBrowserAliveWithNoWindows) 753 NavigateAndCheckStoredData(new_browser, "session_cookies.html"); 754 else 755 StoreDataWithPage(new_browser, "session_cookies.html"); 756 } 757 758 // Tests that session cookies are not cleared when only a popup window is open. 759 IN_PROC_BROWSER_TEST_F(NoSessionRestoreTest, 760 SessionCookiesBrowserCloseWithPopupOpen) { 761 StoreDataWithPage("session_cookies.html"); 762 Browser* popup = new Browser(Browser::CreateParams( 763 Browser::TYPE_POPUP, 764 browser()->profile(), 765 chrome::HOST_DESKTOP_TYPE_NATIVE)); 766 popup->window()->Show(); 767 Browser* new_browser = QuitBrowserAndRestore(browser(), false); 768 NavigateAndCheckStoredData(new_browser, "session_cookies.html"); 769 } 770 771 // Tests that session cookies are cleared if the last window to close is a 772 // popup. 773 IN_PROC_BROWSER_TEST_F(NoSessionRestoreTest, 774 SessionCookiesBrowserClosePopupLast) { 775 StoreDataWithPage("session_cookies.html"); 776 Browser* popup = new Browser(Browser::CreateParams( 777 Browser::TYPE_POPUP, 778 browser()->profile(), 779 chrome::HOST_DESKTOP_TYPE_NATIVE)); 780 popup->window()->Show(); 781 CloseBrowserSynchronously(browser(), false); 782 Browser* new_browser = QuitBrowserAndRestore(popup, false); 783 if (browser_defaults::kBrowserAliveWithNoWindows) 784 NavigateAndCheckStoredData(new_browser, "session_cookies.html"); 785 else 786 StoreDataWithPage(new_browser, "session_cookies.html"); 787 } 788 789 IN_PROC_BROWSER_TEST_F(NoSessionRestoreTest, CookiesClearedOnBrowserClose) { 790 StoreDataWithPage("cookies.html"); 791 792 // Normally cookies are restored. 793 Browser* new_browser = QuitBrowserAndRestore(browser(), false); 794 NavigateAndCheckStoredData(new_browser, "cookies.html"); 795 796 // ... but not if the content setting is set to clear on exit. 797 CookieSettings::Factory::GetForProfile(new_browser->profile())-> 798 SetDefaultCookieSetting(CONTENT_SETTING_SESSION_ONLY); 799 // ... unless background mode is active. 800 EnableBackgroundMode(); 801 new_browser = QuitBrowserAndRestore(new_browser, false); 802 NavigateAndCheckStoredData(new_browser, "cookies.html"); 803 DisableBackgroundMode(); 804 new_browser = QuitBrowserAndRestore(new_browser, false); 805 if (browser_defaults::kBrowserAliveWithNoWindows) 806 NavigateAndCheckStoredData(new_browser, "cookies.html"); 807 else 808 StoreDataWithPage(new_browser, "cookies.html"); 809 } 810 811 // Check that session cookies are cleared on a wrench menu quit. 812 IN_PROC_BROWSER_TEST_F(NoSessionRestoreTest, SessionCookiesCloseAllBrowsers) { 813 StoreDataWithPage("session_cookies.html"); 814 EnableBackgroundMode(); 815 Browser* new_browser = QuitBrowserAndRestore(browser(), true); 816 StoreDataWithPage(new_browser, "session_cookies.html"); 817 DisableBackgroundMode(); 818 new_browser = QuitBrowserAndRestore(new_browser, true); 819 StoreDataWithPage(new_browser, "session_cookies.html"); 820 } 821 822 // Check that cookies are cleared on a wrench menu quit only if cookies are set 823 // to current session only, regardless of whether background mode is enabled. 824 IN_PROC_BROWSER_TEST_F(NoSessionRestoreTest, CookiesClearedOnCloseAllBrowsers) { 825 StoreDataWithPage("cookies.html"); 826 827 // Normally cookies are restored. 828 Browser* new_browser = QuitBrowserAndRestore(browser(), true); 829 NavigateAndCheckStoredData(new_browser, "cookies.html"); 830 831 // ... but not if the content setting is set to clear on exit. 832 CookieSettings::Factory::GetForProfile(new_browser->profile())-> 833 SetDefaultCookieSetting(CONTENT_SETTING_SESSION_ONLY); 834 // ... even if background mode is active. 835 EnableBackgroundMode(); 836 new_browser = QuitBrowserAndRestore(new_browser, true); 837 StoreDataWithPage(new_browser, "cookies.html"); 838 DisableBackgroundMode(); 839 new_browser = QuitBrowserAndRestore(new_browser, true); 840 StoreDataWithPage(new_browser, "cookies.html"); 841 } 842