Add an error page for HTTP 404 error pages without bodies.

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 <utility>
 
 #include "base/base_switches.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
@@ skipping 450 matching lines @@
       certificate_reporting_test_utils::ExpectReport expect_report,
       Browser* browser) {
     base::RunLoop run_loop;
     ASSERT_TRUE(https_server_expired_.Start());
 
     ASSERT_NO_FATAL_FAILURE(SetUpMockReporter());
 
     // Opt in to sending reports for invalid certificate chains.
     certificate_reporting_test_utils::SetCertReportingOptIn(browser, opt_in);
 
-    ui_test_utils::NavigateToURL(browser, https_server_expired_.GetURL("/"));
+    ui_test_utils::NavigateToURL(browser,
+                                 https_server_expired_.GetURL("/title1.html"));
 
     WebContents* tab = browser->tab_strip_model()->GetActiveWebContents();
     ASSERT_TRUE(tab != nullptr);
     CheckAuthenticationBrokenState(tab, net::CERT_STATUS_DATE_INVALID,
                                    AuthState::SHOWING_INTERSTITIAL);
 
     std::unique_ptr<SSLCertReporter> ssl_cert_reporter =
         certificate_reporting_test_utils::SetUpMockSSLCertReporter(
             &run_loop, expect_report);
 
@@ skipping 13 matching lines @@
       // Click "Take me back"
       InterstitialPage* interstitial_page = tab->GetInterstitialPage();
       ASSERT_TRUE(interstitial_page);
       interstitial_page->DontProceed();
     }
 
     if (expect_report ==
         certificate_reporting_test_utils::CERT_REPORT_EXPECTED) {
       // Check that the mock reporter received a request to send a report.
       run_loop.Run();
-      EXPECT_EQ(https_server_expired_.GetURL("/").host(),
+      EXPECT_EQ(https_server_expired_.GetURL("/title1.html").host(),
                 GetLatestHostnameReported());
     } else {
       base::RunLoop().RunUntilIdle();
       EXPECT_EQ(std::string(), GetLatestHostnameReported());
     }
   }
 
   // Helper function for testing invalid certificate chain reporting with the
   // bad clock interstitial.
   void TestBadClockReporting(
       certificate_reporting_test_utils::OptIn opt_in,
       certificate_reporting_test_utils::ExpectReport expect_report,
       Browser* browser) {
     base::RunLoop run_loop;
     ASSERT_TRUE(https_server_expired_.Start());
     ASSERT_NO_FATAL_FAILURE(SetUpMockReporter());
 
     // Set network time back ten minutes, which is sufficient to
     // trigger the reporting.
     g_browser_process->network_time_tracker()->UpdateNetworkTime(
         base::Time::Now() - base::TimeDelta::FromMinutes(10),
         base::TimeDelta::FromMilliseconds(1),   /* resolution */
         base::TimeDelta::FromMilliseconds(500), /* latency */
         base::TimeTicks::Now() /* posting time of this update */);
 
     // Opt in to sending reports for invalid certificate chains.
     certificate_reporting_test_utils::SetCertReportingOptIn(browser, opt_in);
 
-    ui_test_utils::NavigateToURL(browser, https_server_expired_.GetURL("/"));
+    ui_test_utils::NavigateToURL(browser,
+                                 https_server_expired_.GetURL("/title1.html"));
 
     WebContents* tab = browser->tab_strip_model()->GetActiveWebContents();
     CheckAuthenticationBrokenState(tab, net::CERT_STATUS_DATE_INVALID,
                                    AuthState::SHOWING_INTERSTITIAL);
 
     std::unique_ptr<SSLCertReporter> ssl_cert_reporter =
         certificate_reporting_test_utils::SetUpMockSSLCertReporter(
             &run_loop, expect_report);
 
     InterstitialPage* interstitial_page = tab->GetInterstitialPage();
     ASSERT_EQ(BadClockBlockingPage::kTypeForTesting,
               interstitial_page->GetDelegateForTesting()->GetTypeForTesting());
     BadClockBlockingPage* clock_page = static_cast<BadClockBlockingPage*>(
         tab->GetInterstitialPage()->GetDelegateForTesting());
     clock_page->SetSSLCertReporterForTesting(std::move(ssl_cert_reporter));
 
     EXPECT_EQ(std::string(), GetLatestHostnameReported());
 
     interstitial_page->DontProceed();
 
     if (expect_report ==
         certificate_reporting_test_utils::CERT_REPORT_EXPECTED) {
       // Check that the mock reporter received a request to send a report.
       run_loop.Run();
-      EXPECT_EQ(https_server_expired_.GetURL("/").host(),
+      EXPECT_EQ(https_server_expired_.GetURL("/title1.html").host(),
                 GetLatestHostnameReported());
     } else {
       base::RunLoop().RunUntilIdle();
       EXPECT_EQ(std::string(), GetLatestHostnameReported());
     }
   }
 
   net::EmbeddedTestServer https_server_;
   net::EmbeddedTestServer https_server_expired_;
   net::EmbeddedTestServer https_server_mismatched_;
@@ skipping 132 matching lines @@
   const std::string decision_histogram =
       "interstitial.ssl_overridable.decision";
   const std::string interaction_histogram =
       "interstitial.ssl_overridable.interaction";
 
   // Histograms should start off empty.
   histograms.ExpectTotalCount(decision_histogram, 0);
   histograms.ExpectTotalCount(interaction_histogram, 0);
 
   // After navigating to the page, the totals should be set.
-  ui_test_utils::NavigateToURL(browser(), https_server_expired_.GetURL("/"));
+  ui_test_utils::NavigateToURL(browser(),
+                               https_server_expired_.GetURL("/title1.html"));
   content::WaitForInterstitialAttach(
       browser()->tab_strip_model()->GetActiveWebContents());
   histograms.ExpectTotalCount(decision_histogram, 1);
   histograms.ExpectBucketCount(decision_histogram,
                                security_interstitials::MetricsHelper::SHOW, 1);
   histograms.ExpectTotalCount(interaction_histogram, 1);
   histograms.ExpectBucketCount(
       interaction_histogram,
       security_interstitials::MetricsHelper::TOTAL_VISITS, 1);
 
@@ skipping 16 matching lines @@
   const std::string decision_histogram =
       "interstitial.ssl_overridable.decision";
   const std::string interaction_histogram =
       "interstitial.ssl_overridable.interaction";
 
   // Histograms should start off empty.
   histograms.ExpectTotalCount(decision_histogram, 0);
   histograms.ExpectTotalCount(interaction_histogram, 0);
 
   // After navigating to the page, the totals should be set.
-  ui_test_utils::NavigateToURL(browser(), https_server_expired_.GetURL("/"));
+  ui_test_utils::NavigateToURL(browser(),
+                               https_server_expired_.GetURL("/title1.html"));
   content::WaitForInterstitialAttach(
       browser()->tab_strip_model()->GetActiveWebContents());
   histograms.ExpectTotalCount(decision_histogram, 1);
   histograms.ExpectBucketCount(decision_histogram,
                                security_interstitials::MetricsHelper::SHOW, 1);
   histograms.ExpectTotalCount(interaction_histogram, 1);
   histograms.ExpectBucketCount(
       interaction_histogram,
       security_interstitials::MetricsHelper::TOTAL_VISITS, 1);
 
@@ skipping 129 matching lines @@
   ASSERT_TRUE(https_server_expired_.Start());
 
   // Set up the build and current clock times to be more than a year apart.
   std::unique_ptr<base::SimpleTestClock> mock_clock(
       new base::SimpleTestClock());
   mock_clock->SetNow(base::Time::NowFromSystemTime());
   mock_clock->Advance(base::TimeDelta::FromDays(367));
   SSLErrorHandler::SetClockForTest(mock_clock.get());
   ssl_errors::SetBuildTimeForTesting(base::Time::NowFromSystemTime());
 
-  ui_test_utils::NavigateToURL(browser(), https_server_expired_.GetURL("/"));
+  ui_test_utils::NavigateToURL(browser(),
+                               https_server_expired_.GetURL("/title1.html"));
   WebContents* clock_tab = browser()->tab_strip_model()->GetActiveWebContents();
   content::WaitForInterstitialAttach(clock_tab);
   InterstitialPage* clock_interstitial = clock_tab->GetInterstitialPage();
   ASSERT_TRUE(clock_interstitial);
   EXPECT_EQ(BadClockBlockingPage::kTypeForTesting,
             clock_interstitial->GetDelegateForTesting()->GetTypeForTesting());
 }
 
 IN_PROC_BROWSER_TEST_F(SSLUITest, TestHTTPSErrorCausedByClockUsingNetwork) {
   ASSERT_TRUE(https_server_expired_.Start());
 
   // Set network forward ten minutes, which is sufficient to trigger
   // the interstitial.
   g_browser_process->network_time_tracker()->UpdateNetworkTime(
       base::Time::Now() + base::TimeDelta::FromMinutes(10),
       base::TimeDelta::FromMilliseconds(1),   /* resolution */
       base::TimeDelta::FromMilliseconds(500), /* latency */
       base::TimeTicks::Now() /* posting time of this update */);
 
-  ui_test_utils::NavigateToURL(browser(), https_server_expired_.GetURL("/"));
+  ui_test_utils::NavigateToURL(browser(),
+                               https_server_expired_.GetURL("/title1.html"));
   WebContents* clock_tab = browser()->tab_strip_model()->GetActiveWebContents();
   content::WaitForInterstitialAttach(clock_tab);
   InterstitialPage* clock_interstitial = clock_tab->GetInterstitialPage();
   ASSERT_TRUE(clock_interstitial);
   EXPECT_EQ(BadClockBlockingPage::kTypeForTesting,
             clock_interstitial->GetDelegateForTesting()->GetTypeForTesting());
 }
 
 // Visits a page with https error and then goes back using Browser::GoBack.
 IN_PROC_BROWSER_TEST_F(SSLUITest,
@@ skipping 380 matching lines @@
   // We should have an interstitial page showing.
   ASSERT_TRUE(tab2->GetInterstitialPage());
   ASSERT_EQ(SSLBlockingPage::kTypeForTesting, tab2->GetInterstitialPage()
                                                   ->GetDelegateForTesting()
                                                   ->GetTypeForTesting());
 }
 
 IN_PROC_BROWSER_TEST_F(SSLUITest, TestBadHTTPSDownload) {
   ASSERT_TRUE(embedded_test_server()->Start());
   ASSERT_TRUE(https_server_expired_.Start());
-  GURL url_non_dangerous = embedded_test_server()->GetURL("/");
+  GURL url_non_dangerous = embedded_test_server()->GetURL("/title1.html");
   GURL url_dangerous =
       https_server_expired_.GetURL("/downloads/dangerous/dangerous.exe");
   base::ScopedTempDir downloads_directory_;
 
   // Need empty temp dir to avoid having Chrome ask us for a new filename
   // when we've downloaded dangerous.exe one hundred times.
   ASSERT_TRUE(downloads_directory_.CreateUniqueTempDir());
 
   browser()->profile()->GetPrefs()->SetFilePath(
       prefs::kDownloadDefaultDirectory,
@@ skipping 274 matching lines @@
 #else
 #define MAYBE_TestDisplaysInsecureContentLoadedFromJS \
     TestDisplaysInsecureContentLoadedFromJS
 #endif
 IN_PROC_BROWSER_TEST_F(SSLUITest,
                        MAYBE_TestDisplaysInsecureContentLoadedFromJS) {
   ASSERT_TRUE(embedded_test_server()->Start());
   ASSERT_TRUE(https_server_.Start());
 
   host_resolver()->AddRule("example.test",
-                           https_server_.GetURL("/").host());
+                           https_server_.GetURL("/title1.html").host());
 
   net::HostPortPair replacement_pair = embedded_test_server()->host_port_pair();
   replacement_pair.set_host("example.test");
 
   std::string replacement_path;
   GetFilePathWithHostAndPortReplacement(
       "/ssl/page_with_dynamic_insecure_content.html",
       replacement_pair, &replacement_path);
   ui_test_utils::NavigateToURL(browser(), https_server_.GetURL(
       replacement_path));
@@ skipping 959 matching lines @@
   WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents();
   ASSERT_TRUE(tab);
 
   // Set up the build and current clock times to be more than a year apart.
   base::SimpleTestClock mock_clock;
   mock_clock.SetNow(base::Time::NowFromSystemTime());
   mock_clock.Advance(base::TimeDelta::FromDays(367));
   SSLErrorHandler::SetClockForTest(&mock_clock);
   ssl_errors::SetBuildTimeForTesting(base::Time::NowFromSystemTime());
 
-  ui_test_utils::NavigateToURL(browser(), https_server_expired_.GetURL("/"));
+  ui_test_utils::NavigateToURL(browser(),
+                               https_server_expired_.GetURL("/title1.html"));
   content::WaitForInterstitialAttach(tab);
   InterstitialPage* clock_interstitial = tab->GetInterstitialPage();
   ASSERT_TRUE(clock_interstitial);
   EXPECT_EQ(BadClockBlockingPage::kTypeForTesting,
             clock_interstitial->GetDelegateForTesting()->GetTypeForTesting());
 
   // Grab the SSLStatus on the clock interstitial.
   content::NavigationEntry* entry = tab->GetController().GetActiveEntry();
   ASSERT_TRUE(entry);
   content::SSLStatus clock_interstitial_ssl_status = entry->GetSSL();
 
   // Put the clock back to normal, trigger a normal SSL interstitial,
   // and proceed through it.
   mock_clock.SetNow(base::Time::NowFromSystemTime());
-  ui_test_utils::NavigateToURL(browser(), https_server_expired_.GetURL("/"));
+  ui_test_utils::NavigateToURL(browser(),
+                               https_server_expired_.GetURL("/title1.html"));
   content::WaitForInterstitialAttach(tab);
   InterstitialPage* ssl_interstitial = tab->GetInterstitialPage();
   ASSERT_TRUE(ssl_interstitial);
   EXPECT_EQ(SSLBlockingPage::kTypeForTesting,
             ssl_interstitial->GetDelegateForTesting()->GetTypeForTesting());
   ProceedThroughInterstitial(tab);
   EXPECT_FALSE(tab->ShowingInterstitialPage());
 
   // Grab the SSLStatus from the page and check that it is the same as
   // on the clock interstitial.
@@ skipping 376 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.