src/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/file_util.h"
   7 #include "base/files/file_path.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/confirm_infobar_delegate.h"
  18 #include "chrome/browser/infobars/infobar_service.h"
  19 #include "chrome/browser/lifetime/application_lifetime.h"
  20 #include "chrome/browser/prefs/session_startup_pref.h"
  21 #include "chrome/browser/profiles/profile.h"
  22 #include "chrome/browser/profiles/profile_impl.h"
  23 #include "chrome/browser/profiles/profile_manager.h"
  24 #include "chrome/browser/sessions/session_backend.h"
  25 #include "chrome/browser/sessions/session_service_factory.h"
  26 #include "chrome/browser/sessions/session_service_test_helper.h"
  27 #include "chrome/browser/ui/browser.h"
  28 #include "chrome/browser/ui/browser_commands.h"
  29 #include "chrome/browser/ui/browser_iterator.h"
  30 #include "chrome/browser/ui/browser_window.h"
  31 #include "chrome/browser/ui/startup/startup_browser_creator.h"
  32 #include "chrome/browser/ui/tabs/tab_strip_model.h"
  33 #include "chrome/common/chrome_switches.h"
  34 #include "chrome/common/content_settings.h"
  35 #include "chrome/common/pref_names.h"
  36 #include "chrome/common/url_constants.h"
  37 #include "chrome/test/base/in_process_browser_test.h"
  38 #include "chrome/test/base/ui_test_utils.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(content::kAboutBlankURL),
 684             web_contents->GetURL().spec());
 685   // When we navigate to the page again, it doens't see the data previously
 686   // stored.
 687   StoreDataWithPage("session_cookies.html");
 688 }
 689
 690 IN_PROC_BROWSER_TEST_F(NoSessionRestoreTest, PRE_SessionStorage) {
 691   StoreDataWithPage("session_storage.html");
 692 }
 693
 694 IN_PROC_BROWSER_TEST_F(NoSessionRestoreTest, SessionStorage) {
 695   content::WebContents* web_contents =
 696       browser()->tab_strip_model()->GetActiveWebContents();
 697   EXPECT_EQ(std::string(content::kAboutBlankURL),
 698             web_contents->GetURL().spec());
 699   StoreDataWithPage("session_storage.html");
 700 }
 701
 702 IN_PROC_BROWSER_TEST_F(NoSessionRestoreTest,
 703                        PRE_PRE_LocalStorageClearedOnExit) {
 704   StoreDataWithPage("local_storage.html");
 705 }
 706
 707 IN_PROC_BROWSER_TEST_F(NoSessionRestoreTest, PRE_LocalStorageClearedOnExit) {
 708   // Normally localStorage is persisted.
 709   content::WebContents* web_contents =
 710       browser()->tab_strip_model()->GetActiveWebContents();
 711   EXPECT_EQ(std::string(content::kAboutBlankURL),
 712             web_contents->GetURL().spec());
 713   NavigateAndCheckStoredData("local_storage.html");
 714   // ... but not if it's set to clear on exit.
 715   CookieSettings::Factory::GetForProfile(browser()->profile())->
 716       SetDefaultCookieSetting(CONTENT_SETTING_SESSION_ONLY);
 717 }
 718
 719 IN_PROC_BROWSER_TEST_F(NoSessionRestoreTest, LocalStorageClearedOnExit) {
 720   content::WebContents* web_contents =
 721       browser()->tab_strip_model()->GetActiveWebContents();
 722   EXPECT_EQ(std::string(content::kAboutBlankURL),
 723             web_contents->GetURL().spec());
 724   StoreDataWithPage("local_storage.html");
 725 }
 726
 727 IN_PROC_BROWSER_TEST_F(NoSessionRestoreTest, PRE_PRE_CookiesClearedOnExit) {
 728   StoreDataWithPage("cookies.html");
 729 }
 730
 731 IN_PROC_BROWSER_TEST_F(NoSessionRestoreTest, PRE_CookiesClearedOnExit) {
 732   // Normally cookies are restored.
 733   content::WebContents* web_contents =
 734       browser()->tab_strip_model()->GetActiveWebContents();
 735   EXPECT_EQ(std::string(content::kAboutBlankURL),
 736             web_contents->GetURL().spec());
 737   NavigateAndCheckStoredData("cookies.html");
 738   // ... but not if the content setting is set to clear on exit.
 739   CookieSettings::Factory::GetForProfile(browser()->profile())->
 740       SetDefaultCookieSetting(CONTENT_SETTING_SESSION_ONLY);
 741 }
 742
 743 IN_PROC_BROWSER_TEST_F(NoSessionRestoreTest, CookiesClearedOnExit) {
 744   content::WebContents* web_contents =
 745       browser()->tab_strip_model()->GetActiveWebContents();
 746   EXPECT_EQ(std::string(content::kAboutBlankURL),
 747             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 }