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