Automate Better Session Restore tests: cases where it shouldn't be triggered.

chrome/browser/sessions/better_session_restore_browsertest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/path_service.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/content_settings/cookie_settings.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/prefs/session_startup_pref.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/content_settings.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/public/browser/web_contents.h"
+#include "content/public/common/url_constants.h"
 #include "content/public/test/browser_test_utils.h"
 #include "net/base/net_util.h"
 #include "net/base/upload_bytes_element_reader.h"
 #include "net/base/upload_data_stream.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_filter.h"
 #include "net/url_request/url_request_test_job.h"
 
 namespace {
 
@@ skipping 89 matching lines @@
     content::TitleWatcher title_watcher(web_contents, title_storing_);
     title_watcher.AlsoWaitForTitle(title_pass_);
     title_watcher.AlsoWaitForTitle(title_error_write_failed_);
     title_watcher.AlsoWaitForTitle(title_error_empty_);
     ui_test_utils::NavigateToURL(
         browser(), GURL(fake_server_address_ + test_path_ + filename));
     string16 final_title = title_watcher.WaitAndGetTitle();
     EXPECT_EQ(title_storing_, final_title);
   }
 
+  void NavigateAndCheckStoredData(const std::string& filename) {
+    // Navigate to a page which has previously stored data; check that the
+    // stored data can be accessed.
+    content::WebContents* web_contents =
+        chrome::GetActiveWebContents(browser());
+    content::TitleWatcher title_watcher(web_contents, title_pass_);
+    title_watcher.AlsoWaitForTitle(title_storing_);
+    title_watcher.AlsoWaitForTitle(title_error_write_failed_);
+    title_watcher.AlsoWaitForTitle(title_error_empty_);
+    ui_test_utils::NavigateToURL(
+        browser(), GURL(fake_server_address_ + test_path_ + filename));
+    string16 final_title = title_watcher.WaitAndGetTitle();
+    EXPECT_EQ(title_pass_, final_title);
+  }
+
   void CheckReloadedPageRestored() {
     CheckTitle(title_pass_);
   }
 
   void CheckReloadedPageNotRestored() {
     CheckTitle(title_storing_);
   }
 
   void CheckTitle(const string16& expected_title) {
     content::WebContents* web_contents = chrome::GetWebContentsAt(browser(), 0);
@@ skipping 67 matching lines @@
   std::string test_path_;
   string16 title_pass_;
   string16 title_storing_;
   string16 title_error_write_failed_;
   string16 title_error_empty_;
 
   DISALLOW_COPY_AND_ASSIGN(BetterSessionRestoreTest);
 };
 
 class ContinueWhereILeftOffTest : public BetterSessionRestoreTest {
+ public:
+  virtual void SetUpOnMainThread() OVERRIDE {
+    SessionStartupPref::SetStartupPref(
+        browser()->profile(), SessionStartupPref(SessionStartupPref::LAST));
+  }
 };
 
 IN_PROC_BROWSER_TEST_F(ContinueWhereILeftOffTest, PRE_SessionCookies) {
   // Set the startup preference to "continue where I left off" and visit a page
   // which stores a session cookie.
-  SessionStartupPref::SetStartupPref(
-      browser()->profile(), SessionStartupPref(SessionStartupPref::LAST));
   StoreDataWithPage("session_cookies.html");
 }
 
 IN_PROC_BROWSER_TEST_F(ContinueWhereILeftOffTest, SessionCookies) {
   // The browsing session will be continued; just wait for the page to reload
   // and check the stored data.
   CheckReloadedPageRestored();
 }
 
 IN_PROC_BROWSER_TEST_F(ContinueWhereILeftOffTest, PRE_SessionStorage) {
-  SessionStartupPref::SetStartupPref(
-      browser()->profile(), SessionStartupPref(SessionStartupPref::LAST));
   StoreDataWithPage("session_storage.html");
 }
 
 IN_PROC_BROWSER_TEST_F(ContinueWhereILeftOffTest, SessionStorage) {
   CheckReloadedPageRestored();
 }
 
 IN_PROC_BROWSER_TEST_F(ContinueWhereILeftOffTest,
                        PRE_PRE_LocalStorageClearedOnExit) {
-  SessionStartupPref::SetStartupPref(
-      browser()->profile(), SessionStartupPref(SessionStartupPref::LAST));
   StoreDataWithPage("local_storage.html");
 }
 
 IN_PROC_BROWSER_TEST_F(ContinueWhereILeftOffTest,
                        PRE_LocalStorageClearedOnExit) {
   // Normally localStorage is restored.
   CheckReloadedPageRestored();
   // ... but not if it's set to clear on exit.
   CookieSettings::Factory::GetForProfile(browser()->profile())->
       SetDefaultCookieSetting(CONTENT_SETTING_SESSION_ONLY);
 }
 
 // Flaky on Linux: http://crbug.com/163096
 #if defined(OS_LINUX)
 #define MAYBE_LocalStorageClearedOnExit DISABLED_LocalStorageClearedOnExit
 #else
 #define MAYBE_LocalStorageClearedOnExit LocalStorageClearedOnExit
 #endif
 IN_PROC_BROWSER_TEST_F(ContinueWhereILeftOffTest,
                        MAYBE_LocalStorageClearedOnExit) {
   CheckReloadedPageNotRestored();
 }
 
 IN_PROC_BROWSER_TEST_F(ContinueWhereILeftOffTest,
                        PRE_PRE_CookiesClearedOnExit) {
-  SessionStartupPref::SetStartupPref(
-      browser()->profile(), SessionStartupPref(SessionStartupPref::LAST));
   StoreDataWithPage("cookies.html");
 }
 
 IN_PROC_BROWSER_TEST_F(ContinueWhereILeftOffTest, PRE_CookiesClearedOnExit) {
   // Normally cookies are restored.
   CheckReloadedPageRestored();
   // ... but not if the content setting is set to clear on exit.
   CookieSettings::Factory::GetForProfile(browser()->profile())->
       SetDefaultCookieSetting(CONTENT_SETTING_SESSION_ONLY);
 }
 
 IN_PROC_BROWSER_TEST_F(ContinueWhereILeftOffTest, CookiesClearedOnExit) {
   CheckReloadedPageNotRestored();
 }
 
 IN_PROC_BROWSER_TEST_F(ContinueWhereILeftOffTest, PRE_Post) {
-  SessionStartupPref::SetStartupPref(
-      browser()->profile(), SessionStartupPref(SessionStartupPref::LAST));
   PostFormWithPage("post.html", false);
 }
 
 IN_PROC_BROWSER_TEST_F(ContinueWhereILeftOffTest, Post) {
   CheckFormRestored(true, false);
 }
 
 IN_PROC_BROWSER_TEST_F(ContinueWhereILeftOffTest, PRE_PostWithPassword) {
-  SessionStartupPref::SetStartupPref(
-      browser()->profile(), SessionStartupPref(SessionStartupPref::LAST));
   PostFormWithPage("post_with_password.html", true);
 }
 
 IN_PROC_BROWSER_TEST_F(ContinueWhereILeftOffTest, PostWithPassword) {
   CheckReloadedPageRestored();
   // The form data contained passwords, so it's removed completely.
   CheckFormRestored(false, false);
 }
 
 class RestartTest : public BetterSessionRestoreTest {
@@ skipping 69 matching lines @@
 
 IN_PROC_BROWSER_TEST_F(RestartTest, PRE_PostWithPassword) {
   PostFormWithPage("post_with_password.html", true);
   Restart();
 }
 
 IN_PROC_BROWSER_TEST_F(RestartTest, PostWithPassword) {
   // The form data contained passwords, so it's removed completely.
   CheckFormRestored(false, false);
 }
+
+// These tests ensure that the Better Session Restore features are not triggered
+// when they shouldn't be.
+class NoSessionRestoreTest : public BetterSessionRestoreTest {
+ public:
+  virtual void SetUpOnMainThread() OVERRIDE {
+    SessionStartupPref::SetStartupPref(
+        browser()->profile(), SessionStartupPref(SessionStartupPref::DEFAULT));
+  }
+};
+
+IN_PROC_BROWSER_TEST_F(NoSessionRestoreTest, PRE_SessionCookies) {
+  StoreDataWithPage("session_cookies.html");
+}
+
+IN_PROC_BROWSER_TEST_F(NoSessionRestoreTest, SessionCookies) {
+  content::WebContents* web_contents = chrome::GetActiveWebContents(browser());
+  EXPECT_EQ(std::string(chrome::kAboutBlankURL), web_contents->GetURL().spec());
+  // When we navigate to the page again, it doens't see the data previously
+  // stored.
+  StoreDataWithPage("session_cookies.html");
+}
+
+IN_PROC_BROWSER_TEST_F(NoSessionRestoreTest, PRE_SessionStorage) {
+  StoreDataWithPage("session_storage.html");
+}
+
+IN_PROC_BROWSER_TEST_F(NoSessionRestoreTest, SessionStorage) {
+  content::WebContents* web_contents = chrome::GetActiveWebContents(browser());
+  EXPECT_EQ(std::string(chrome::kAboutBlankURL), web_contents->GetURL().spec());
+  StoreDataWithPage("session_storage.html");
+}
+
+IN_PROC_BROWSER_TEST_F(NoSessionRestoreTest,
+                       PRE_PRE_LocalStorageClearedOnExit) {
+  StoreDataWithPage("local_storage.html");
+}
+
+IN_PROC_BROWSER_TEST_F(NoSessionRestoreTest, PRE_LocalStorageClearedOnExit) {
+  // Normally localStorage is persisted.
+  content::WebContents* web_contents = chrome::GetActiveWebContents(browser());
+  EXPECT_EQ(std::string(chrome::kAboutBlankURL), web_contents->GetURL().spec());
+  NavigateAndCheckStoredData("local_storage.html");
+  // ... but not if it's set to clear on exit.
+  CookieSettings::Factory::GetForProfile(browser()->profile())->
+      SetDefaultCookieSetting(CONTENT_SETTING_SESSION_ONLY);
+}
+
+// See flakiness comment above.
+IN_PROC_BROWSER_TEST_F(NoSessionRestoreTest, MAYBE_LocalStorageClearedOnExit) {
+  content::WebContents* web_contents = chrome::GetActiveWebContents(browser());
+  EXPECT_EQ(std::string(chrome::kAboutBlankURL), web_contents->GetURL().spec());
+  StoreDataWithPage("local_storage.html");
+}
+
+IN_PROC_BROWSER_TEST_F(NoSessionRestoreTest, PRE_PRE_CookiesClearedOnExit) {
+  StoreDataWithPage("cookies.html");
+}
+
+IN_PROC_BROWSER_TEST_F(NoSessionRestoreTest, PRE_CookiesClearedOnExit) {
+  // Normally cookies are restored.
+  content::WebContents* web_contents = chrome::GetActiveWebContents(browser());
+  EXPECT_EQ(std::string(chrome::kAboutBlankURL), web_contents->GetURL().spec());
+  NavigateAndCheckStoredData("cookies.html");
+  // ... but not if the content setting is set to clear on exit.
+  CookieSettings::Factory::GetForProfile(browser()->profile())->
+      SetDefaultCookieSetting(CONTENT_SETTING_SESSION_ONLY);
+}
+
+IN_PROC_BROWSER_TEST_F(NoSessionRestoreTest, CookiesClearedOnExit) {
+  content::WebContents* web_contents = chrome::GetActiveWebContents(browser());
+  EXPECT_EQ(std::string(chrome::kAboutBlankURL), web_contents->GetURL().spec());
+  StoreDataWithPage("local_storage.html");
+}