better_session_restore_browsertest.cc revision f8ee788a64d60abd8f2d742a5fdedde054ecd910 
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/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/content_settings.h"
34#include "chrome/common/pref_names.h"
35#include "chrome/common/url_constants.h"
36#include "chrome/test/base/in_process_browser_test.h"
37#include "chrome/test/base/ui_test_utils.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
53namespace {
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
61base::LazyInstance<std::map<std::string, std::string> > g_file_contents =
62    LAZY_INSTANCE_INITIALIZER;
63
64net::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
73base::LazyInstance<std::string> g_last_upload_bytes = LAZY_INSTANCE_INITIALIZER;
74
75net::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
100class 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
123class 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
368class 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
393IN_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
399IN_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
405IN_PROC_BROWSER_TEST_F(ContinueWhereILeftOffTest, PRE_SessionStorage) {
406  StoreDataWithPage("session_storage.html");
407}
408
409IN_PROC_BROWSER_TEST_F(ContinueWhereILeftOffTest, SessionStorage) {
410  CheckReloadedPageRestored();
411}
412
413IN_PROC_BROWSER_TEST_F(ContinueWhereILeftOffTest,
414                       PRE_PRE_LocalStorageClearedOnExit) {
415  StoreDataWithPage("local_storage.html");
416}
417
418IN_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
427IN_PROC_BROWSER_TEST_F(ContinueWhereILeftOffTest, LocalStorageClearedOnExit) {
428  CheckReloadedPageNotRestored();
429}
430
431IN_PROC_BROWSER_TEST_F(ContinueWhereILeftOffTest,
432                       PRE_PRE_CookiesClearedOnExit) {
433  StoreDataWithPage("cookies.html");
434}
435
436IN_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
444IN_PROC_BROWSER_TEST_F(ContinueWhereILeftOffTest, CookiesClearedOnExit) {
445  CheckReloadedPageNotRestored();
446}
447
448IN_PROC_BROWSER_TEST_F(ContinueWhereILeftOffTest, PRE_Post) {
449  PostFormWithPage("post.html", false);
450}
451
452IN_PROC_BROWSER_TEST_F(ContinueWhereILeftOffTest, Post) {
453  CheckFormRestored(true, false);
454}
455
456IN_PROC_BROWSER_TEST_F(ContinueWhereILeftOffTest, PRE_PostWithPassword) {
457  PostFormWithPage("post_with_password.html", true);
458}
459
460IN_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
466IN_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.
477IN_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}
493IN_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
515IN_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
521IN_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.
531IN_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.
544IN_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.
564IN_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.
571IN_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
580class 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
601IN_PROC_BROWSER_TEST_F(RestartTest, PRE_SessionCookies) {
602  StoreDataWithPage("session_cookies.html");
603  Restart();
604}
605
606IN_PROC_BROWSER_TEST_F(RestartTest, SessionCookies) {
607  CheckReloadedPageRestored();
608}
609
610IN_PROC_BROWSER_TEST_F(RestartTest, PRE_SessionStorage) {
611  StoreDataWithPage("session_storage.html");
612  Restart();
613}
614
615IN_PROC_BROWSER_TEST_F(RestartTest, SessionStorage) {
616  CheckReloadedPageRestored();
617}
618
619IN_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
626IN_PROC_BROWSER_TEST_F(RestartTest, LocalStorageClearedOnExit) {
627  CheckReloadedPageRestored();
628}
629
630IN_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
637IN_PROC_BROWSER_TEST_F(RestartTest, CookiesClearedOnExit) {
638  CheckReloadedPageRestored();
639}
640
641IN_PROC_BROWSER_TEST_F(RestartTest, PRE_Post) {
642  PostFormWithPage("post.html", false);
643  Restart();
644}
645
646IN_PROC_BROWSER_TEST_F(RestartTest, Post) {
647  CheckFormRestored(true, false);
648}
649
650IN_PROC_BROWSER_TEST_F(RestartTest, PRE_PostWithPassword) {
651  PostFormWithPage("post_with_password.html", true);
652  Restart();
653}
654
655IN_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.
662class 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
676IN_PROC_BROWSER_TEST_F(NoSessionRestoreTest, PRE_SessionCookies) {
677  StoreDataWithPage("session_cookies.html");
678}
679
680IN_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
689IN_PROC_BROWSER_TEST_F(NoSessionRestoreTest, PRE_SessionStorage) {
690  StoreDataWithPage("session_storage.html");
691}
692
693IN_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
700IN_PROC_BROWSER_TEST_F(NoSessionRestoreTest,
701                       PRE_PRE_LocalStorageClearedOnExit) {
702  StoreDataWithPage("local_storage.html");
703}
704
705IN_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
716IN_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
723IN_PROC_BROWSER_TEST_F(NoSessionRestoreTest, PRE_PRE_CookiesClearedOnExit) {
724  StoreDataWithPage("cookies.html");
725}
726
727IN_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
738IN_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
745IN_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.
759IN_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.
773IN_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
789IN_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.
812IN_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.
824IN_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