Update entry page type to include error pages when appropriate.

chrome/browser/ssl/ssl_browser_tests.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/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/path_service.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_util.h"
@@ skipping 81 matching lines @@
   bool waiting_;
   bool seen_;
 };
 
 namespace AuthState {
 
 enum AuthStateFlags {
   NONE = 0,
   DISPLAYED_INSECURE_CONTENT = 1 << 0,
   RAN_INSECURE_CONTENT = 1 << 1,
-  SHOWING_INTERSTITIAL = 1 << 2
+  SHOWING_INTERSTITIAL = 1 << 2,
+  SHOWING_ERROR = 1 << 3
 };
 
 void Check(const NavigationEntry& entry, int expected_authentication_state) {
-  EXPECT_EQ(!!(expected_authentication_state & AuthState::SHOWING_INTERSTITIAL)
-                ? content::PAGE_TYPE_INTERSTITIAL
-                : content::PAGE_TYPE_NORMAL,
-            entry.GetPageType());
+  if (expected_authentication_state == AuthState::SHOWING_ERROR) {
+    EXPECT_EQ(content::PAGE_TYPE_ERROR, entry.GetPageType());
+  } else {
+    EXPECT_EQ(
+        !!(expected_authentication_state & AuthState::SHOWING_INTERSTITIAL)
+            ? content::PAGE_TYPE_INTERSTITIAL
+            : content::PAGE_TYPE_NORMAL,
+        entry.GetPageType());
+  }
 
   bool displayed_insecure_content =
       !!(entry.GetSSL().content_status & SSLStatus::DISPLAYED_INSECURE_CONTENT);
   EXPECT_EQ(
       !!(expected_authentication_state & AuthState::DISPLAYED_INSECURE_CONTENT),
       displayed_insecure_content);
 
   bool ran_insecure_content =
       !!(entry.GetSSL().content_status & SSLStatus::RAN_INSECURE_CONTENT);
   EXPECT_EQ(!!(expected_authentication_state & AuthState::RAN_INSECURE_CONTENT),
@@ skipping 70 matching lines @@
   }
 
   void CheckAuthenticatedState(WebContents* tab,
                                int expected_authentication_state) {
     CheckSecurityState(tab,
                        CertError::NONE,
                        content::SECURITY_STYLE_AUTHENTICATED,
                        expected_authentication_state);
   }
 
-  void CheckUnauthenticatedState(WebContents* tab) {
+  void CheckUnauthenticatedState(WebContents* tab,
+                                 int expected_authentication_state) {
     CheckSecurityState(tab,
                        CertError::NONE,
                        content::SECURITY_STYLE_UNAUTHENTICATED,
-                       AuthState::NONE);
+                       expected_authentication_state);
   }
 
   void CheckAuthenticationBrokenState(WebContents* tab,
                                       net::CertStatus error,
                                       int expected_authentication_state) {
     CheckSecurityState(tab,
                        error,
                        content::SECURITY_STYLE_AUTHENTICATION_BROKEN,
                        expected_authentication_state);
     // CERT_STATUS_UNABLE_TO_CHECK_REVOCATION doesn't lower the security style
@@ skipping 159 matching lines @@
 };
 
 // Visits a regular page over http.
 IN_PROC_BROWSER_TEST_F(SSLUITest, TestHTTP) {
   ASSERT_TRUE(test_server()->Start());
 
   ui_test_utils::NavigateToURL(browser(),
                                test_server()->GetURL("files/ssl/google.html"));
 
   CheckUnauthenticatedState(
-      browser()->tab_strip_model()->GetActiveWebContents());
+      browser()->tab_strip_model()->GetActiveWebContents(), AuthState::NONE);
 }
 
 // Visits a page over http which includes broken https resources (status should
 // be OK).
 // TODO(jcampan): test that bad HTTPS content is blocked (otherwise we'll give
 //                the secure cookies away!).
 IN_PROC_BROWSER_TEST_F(SSLUITest, TestHTTPWithBrokenHTTPSResource) {
   ASSERT_TRUE(test_server()->Start());
   ASSERT_TRUE(https_server_expired_.Start());
 
   std::string replacement_path;
   ASSERT_TRUE(GetFilePathWithHostAndPortReplacement(
       "files/ssl/page_with_unsafe_contents.html",
       https_server_expired_.host_port_pair(),
       &replacement_path));
 
   ui_test_utils::NavigateToURL(
       browser(), test_server()->GetURL(replacement_path));
 
   CheckUnauthenticatedState(
-      browser()->tab_strip_model()->GetActiveWebContents());
+      browser()->tab_strip_model()->GetActiveWebContents(), AuthState::NONE);
 }
 
 IN_PROC_BROWSER_TEST_F(SSLUITest, TestBrokenHTTPSWithInsecureContent) {
   ASSERT_TRUE(test_server()->Start());
   ASSERT_TRUE(https_server_expired_.Start());
 
   std::string replacement_path;
   ASSERT_TRUE(GetFilePathWithHostAndPortReplacement(
       "files/ssl/page_displays_insecure_content.html",
       test_server()->host_port_pair(),
@@ skipping 101 matching lines @@
   InterstitialPage* interstitial_page = tab->GetInterstitialPage();
   ASSERT_TRUE(interstitial_page);
   interstitial_page->DontProceed();
 
   // We should be back to the original good page.
   CheckAuthenticatedState(tab, AuthState::NONE);
 
   // Try to navigate to a new page. (to make sure bug 5800 is fixed).
   ui_test_utils::NavigateToURL(browser(),
                                test_server()->GetURL("files/ssl/google.html"));
-  CheckUnauthenticatedState(tab);
+  CheckUnauthenticatedState(tab, AuthState::NONE);
 }
 
 // Visits a page with https error and then goes back using Browser::GoBack.
 IN_PROC_BROWSER_TEST_F(SSLUITest,
                        TestHTTPSExpiredCertAndGoBackViaButton) {
   ASSERT_TRUE(test_server()->Start());
   ASSERT_TRUE(https_server_expired_.Start());
 
   // First navigate to an HTTP page.
   ui_test_utils::NavigateToURL(browser(),
@@ skipping 15 matching lines @@
 
   // Wait until we hear the load failure, and make sure we haven't swapped out
   // the previous page.  Prevents regression of http://crbug.com/82667.
   load_failed_observer.Wait();
   EXPECT_FALSE(content::RenderViewHostTester::IsRenderViewHostSwappedOut(
       tab->GetRenderViewHost()));
 
   // We should be back at the original good page.
   EXPECT_FALSE(browser()->tab_strip_model()->GetActiveWebContents()->
                    GetInterstitialPage());
-  CheckUnauthenticatedState(tab);
+  CheckUnauthenticatedState(tab, AuthState::NONE);
 }
 
 // Visits a page with https error and then goes back using GoToOffset.
 // Disabled because its flaky: http://crbug.com/40932, http://crbug.com/43575.
 IN_PROC_BROWSER_TEST_F(SSLUITest,
                        TestHTTPSExpiredCertAndGoBackViaMenu) {
   ASSERT_TRUE(test_server()->Start());
   ASSERT_TRUE(https_server_expired_.Start());
 
   // First navigate to an HTTP page.
   ui_test_utils::NavigateToURL(browser(),
       test_server()->GetURL("files/ssl/google.html"));
   WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents();
   NavigationEntry* entry = tab->GetController().GetActiveEntry();
   ASSERT_TRUE(entry);
 
   // Now go to a bad HTTPS page that shows an interstitial.
   ui_test_utils::NavigateToURL(browser(),
       https_server_expired_.GetURL("files/ssl/google.html"));
   CheckAuthenticationBrokenState(
       tab, net::CERT_STATUS_DATE_INVALID, AuthState::SHOWING_INTERSTITIAL);
 
   // Simulate user clicking and holding on back button (crbug.com/37215).
   tab->GetController().GoToOffset(-1);
 
   // We should be back at the original good page.
   EXPECT_FALSE(browser()->tab_strip_model()->GetActiveWebContents()->
                    GetInterstitialPage());
-  CheckUnauthenticatedState(tab);
+  CheckUnauthenticatedState(tab, AuthState::NONE);
 }
 
 // Visits a page with https error and then goes forward using GoToOffset.
 IN_PROC_BROWSER_TEST_F(SSLUITest, TestHTTPSExpiredCertAndGoForward) {
   ASSERT_TRUE(test_server()->Start());
   ASSERT_TRUE(https_server_expired_.Start());
 
   // First navigate to two HTTP pages.
   ui_test_utils::NavigateToURL(browser(),
       test_server()->GetURL("files/ssl/google.html"));
@@ skipping 28 matching lines @@
     content::WindowedNotificationObserver observer(
         content::NOTIFICATION_LOAD_STOP,
         content::Source<NavigationController>(&tab->GetController()));
     tab->GetController().GoToOffset(1);
     observer.Wait();
   }
 
   // We should be showing the second good page.
   EXPECT_FALSE(browser()->tab_strip_model()->GetActiveWebContents()->
                    GetInterstitialPage());
-  CheckUnauthenticatedState(tab);
+  CheckUnauthenticatedState(tab, AuthState::NONE);
   EXPECT_FALSE(tab->GetController().CanGoForward());
   NavigationEntry* entry4 = tab->GetController().GetActiveEntry();
   EXPECT_TRUE(entry2 == entry4);
 }
 
 // Visit a HTTP page which request WSS connection to a server providing invalid
 // certificate. Close the page while WSS connection waits for SSLManager's
 // response from UI thread.
 // Disabled on Windows because it was flaking on XP Tests (1). crbug.com/165258
 #if defined(OS_WIN)
@@ skipping 480 matching lines @@
   std::string replacement_path;
   ASSERT_TRUE(GetFilePathWithHostAndPortReplacement(
       "files/ssl/page_displays_insecure_content.html",
       test_server()->host_port_pair(),
       &replacement_path));
 
   // Load original page over HTTP.
   const GURL url_http = test_server()->GetURL(replacement_path);
   ui_test_utils::NavigateToURL(browser(), url_http);
   WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents();
-  CheckUnauthenticatedState(tab);
+  CheckUnauthenticatedState(tab, AuthState::NONE);
 
   // Load again but over SSL.  It should be marked as displaying insecure
   // content (even though the image comes from the WebCore memory cache).
   const GURL url_https = https_server_.GetURL(replacement_path);
   ui_test_utils::NavigateToURL(browser(), url_https);
   CheckAuthenticatedState(tab, AuthState::DISPLAYED_INSECURE_CONTENT);
 }
 
 // http://crbug.com/84729
 #if defined(OS_CHROMEOS)
@@ skipping 13 matching lines @@
   std::string replacement_path;
   ASSERT_TRUE(GetFilePathWithHostAndPortReplacement(
       "files/ssl/page_runs_insecure_content.html",
       test_server()->host_port_pair(),
       &replacement_path));
 
   // Load original page over HTTP.
   const GURL url_http = test_server()->GetURL(replacement_path);
   ui_test_utils::NavigateToURL(browser(), url_http);
   WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents();
-  CheckUnauthenticatedState(tab);
+  CheckUnauthenticatedState(tab, AuthState::NONE);
 
   // Load again but over SSL.  It should be marked as displaying insecure
   // content (even though the image comes from the WebCore memory cache).
   const GURL url_https = https_server_.GetURL(replacement_path);
   ui_test_utils::NavigateToURL(browser(), url_https);
   CheckAuthenticationBrokenState(
       tab,
       CertError::NONE,
       AuthState::DISPLAYED_INSECURE_CONTENT | AuthState::RAN_INSECURE_CONTENT);
 }
@@ skipping 208 matching lines @@
 IN_PROC_BROWSER_TEST_F(SSLUITest, TestRedirectHTTPSToHTTP) {
   ASSERT_TRUE(test_server()->Start());
   ASSERT_TRUE(https_server_.Start());
 
   GURL https_url = https_server_.GetURL("server-redirect?");
   GURL http_url = test_server()->GetURL("files/ssl/google.html");
 
   ui_test_utils::NavigateToURL(browser(),
                                GURL(https_url.spec() + http_url.spec()));
   CheckUnauthenticatedState(
-      browser()->tab_strip_model()->GetActiveWebContents());
+      browser()->tab_strip_model()->GetActiveWebContents(), AuthState::NONE);
 }
 
 // Visits a page to which we could not connect (bad port) over http and https
 // and make sure the security style is correct.
 IN_PROC_BROWSER_TEST_F(SSLUITest, TestConnectToBadPort) {
   ui_test_utils::NavigateToURL(browser(), GURL("http://localhost:17"));
   CheckUnauthenticatedState(
-      browser()->tab_strip_model()->GetActiveWebContents());
+      browser()->tab_strip_model()->GetActiveWebContents(),
+      AuthState::SHOWING_ERROR);
 
   // Same thing over HTTPS.
   ui_test_utils::NavigateToURL(browser(), GURL("https://localhost:17"));
   CheckUnauthenticatedState(
-      browser()->tab_strip_model()->GetActiveWebContents());
+      browser()->tab_strip_model()->GetActiveWebContents(),
+      AuthState::SHOWING_ERROR);
 }
 
 //
 // Frame navigation
 //
 
 // From a good HTTPS top frame:
 // - navigate to an OK HTTPS frame
 // - navigate to a bad HTTPS (expect unsafe content and filtered frame), then
 //   back
@@ skipping 150 matching lines @@
 
   std::string top_frame_path;
   ASSERT_TRUE(GetTopFramePath(*test_server(),
                               https_server_,
                               https_server_expired_,
                               &top_frame_path));
 
   WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents();
   ui_test_utils::NavigateToURL(browser(),
                                test_server()->GetURL(top_frame_path));
-  CheckUnauthenticatedState(tab);
+  CheckUnauthenticatedState(tab, AuthState::NONE);
 
   // Now navigate inside the frame to a secure HTTPS frame.
   {
     bool success = false;
     content::WindowedNotificationObserver observer(
         content::NOTIFICATION_LOAD_STOP,
         content::Source<NavigationController>(&tab->GetController()));
     EXPECT_TRUE(content::ExecuteScriptAndExtractBool(
         tab,
         "window.domAutomationController.send(clickLink('goodHTTPSLink'));",
         &success));
     ASSERT_TRUE(success);
     observer.Wait();
   }
 
   // We should still be unauthenticated.
-  CheckUnauthenticatedState(tab);
+  CheckUnauthenticatedState(tab, AuthState::NONE);
 
   // Now navigate to a bad HTTPS frame.
   {
     bool success = false;
     content::WindowedNotificationObserver observer(
         content::NOTIFICATION_LOAD_STOP,
         content::Source<NavigationController>(&tab->GetController()));
     EXPECT_TRUE(content::ExecuteScriptAndExtractBool(
         tab,
         "window.domAutomationController.send(clickLink('badHTTPSLink'));",
         &success));
     ASSERT_TRUE(success);
     observer.Wait();
   }
 
   // State should not have changed.
-  CheckUnauthenticatedState(tab);
+  CheckUnauthenticatedState(tab, AuthState::NONE);
 
   // And the frame should have been blocked (see bug #2316).
   bool is_content_evil = true;
   content::RenderFrameHost* content_frame = content::FrameMatchingPredicate(
         tab, base::Bind(&content::FrameMatchesName, "contentFrame"));
   std::string is_evil_js("window.domAutomationController.send("
                          "document.getElementById('evilDiv') != null);");
   EXPECT_TRUE(content::ExecuteScriptAndExtractBool(content_frame,
                                                    is_evil_js,
                                                    &is_content_evil));
@@ skipping 235 matching lines @@
 
 // Visit a page over https that contains a frame with a redirect.
 
 // XMLHttpRequest insecure content in synchronous mode.
 
 // XMLHttpRequest insecure content in asynchronous mode.
 
 // XMLHttpRequest over bad ssl in synchronous mode.
 
 // XMLHttpRequest over OK ssl in synchronous mode.