SSLUITest's work with ephemeral port testserver.

chrome/browser/ssl/ssl_browser_tests.cc

 // Copyright (c) 2010 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/stringprintf.h"
 #include "base/time.h"
 #include "chrome/app/chrome_dll_resource.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_navigator.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/tab_contents/interstitial_page.h"
 #include "chrome/browser/tab_contents/navigation_entry.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/browser/tabs/tab_strip_model.h"
@@ skipping 94 matching lines @@
   }
 
   void ProceedThroughInterstitial(TabContents* tab) {
     InterstitialPage* interstitial_page = tab->interstitial_page();
     ASSERT_TRUE(interstitial_page);
     interstitial_page->Proceed();
     // Wait for the navigation to be done.
     ui_test_utils::WaitForNavigation(&(tab->controller()));
   }
 
+  std::string GetFileWithHostAndPortReplacement(
+      const std::string& original_path,
+      const net::HostPortPair& host_port_pair) const {
+    return StringPrintf("%s?replace_orig=%s&replace_new=%s",
+                        original_path.c_str(),
+                        kReplaceText_,
+                        host_port_pair.ToString().c_str());
+  }
+
   net::TestServer https_server_;
   net::TestServer https_server_expired_;
   net::TestServer https_server_mismatched_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SSLUITest);
+
+  static const char* const kReplaceText_;
 };
 
+// static
+const char* const SSLUITest::kReplaceText_ = "REPLACE_WITH_HOST_AND_PORT";
+
 // 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()->GetSelectedTabContents());
 }
 
 // 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());
 
-  ui_test_utils::NavigateToURL(browser(),
-      test_server()->GetURL("files/ssl/page_with_unsafe_contents.html"));
+  std::string replacement_path = GetFileWithHostAndPortReplacement(
+      "files/ssl/page_with_unsafe_contents.html",
+      https_server_expired_.host_port_pair());
+
+  ui_test_utils::NavigateToURL(
+      browser(), test_server()->GetURL(replacement_path));
 
   CheckUnauthenticatedState(browser()->GetSelectedTabContents());
 }
 
 // Visits a page over OK https:
 IN_PROC_BROWSER_TEST_F(SSLUITest, TestOKHTTPS) {
   ASSERT_TRUE(https_server_.Start());
 
   ui_test_utils::NavigateToURL(browser(),
                                https_server_.GetURL("files/ssl/google.html"));
@@ skipping 199 matching lines @@
 
 //
 // Insecure content
 //
 
 // Visits a page that displays insecure content.
 IN_PROC_BROWSER_TEST_F(SSLUITest, TestDisplaysInsecureContent) {
   ASSERT_TRUE(test_server()->Start());
   ASSERT_TRUE(https_server_.Start());
 
+  std::string replacement_path = GetFileWithHostAndPortReplacement(
+      "files/ssl/page_displays_insecure_content.html",
+      test_server()->host_port_pair());
+
   // Load a page that displays insecure content.
-  ui_test_utils::NavigateToURL(browser(), https_server_.GetURL(
-      "files/ssl/page_displays_insecure_content.html"));
+  ui_test_utils::NavigateToURL(browser(),
+                               https_server_.GetURL(replacement_path));
 
   CheckAuthenticatedState(browser()->GetSelectedTabContents(), true);
 }
 
 // Visits a page that runs insecure content and tries to suppress the insecure
 // content warnings by randomizing location.hash.
 // Based on http://crbug.com/8706
 // Fails to terminate on all platforms.  See bug http://crbug.com/58230
 IN_PROC_BROWSER_TEST_F(SSLUITest,
     DISABLED_TestRunsInsecuredContentRandomizeHash) {
   ASSERT_TRUE(test_server()->Start());
   ASSERT_TRUE(https_server_.Start());
 
   ui_test_utils::NavigateToURL(browser(), https_server_.GetURL(
       "files/ssl/page_runs_insecure_content.html"));
 
   CheckAuthenticationBrokenState(browser()->GetSelectedTabContents(), 0, true,
                                  false);
 }
 
 // Visits a page with unsafe content and make sure that:
 // - frames content is replaced with warning
 // - images and scripts are filtered out entirely
 // Marked as flaky, see bug 40932.
 IN_PROC_BROWSER_TEST_F(SSLUITest, FLAKY_TestUnsafeContents) {
   ASSERT_TRUE(https_server_.Start());
   ASSERT_TRUE(https_server_expired_.Start());
 
-  ui_test_utils::NavigateToURL(browser(), https_server_.GetURL(
-      "files/ssl/page_with_unsafe_contents.html"));
+  std::string replacement_path = GetFileWithHostAndPortReplacement(
+      "files/ssl/page_with_unsafe_contents.html",
+      https_server_expired_.host_port_pair());
+  ui_test_utils::NavigateToURL(browser(),
+                               https_server_.GetURL(replacement_path));
 
   TabContents* tab = browser()->GetSelectedTabContents();
   // When the bad content is filtered, the state is expected to be
   // authenticated.
   CheckAuthenticatedState(tab, false);
 
   // Because of cross-frame scripting restrictions, we cannot access the iframe
   // content.  So to know if the frame was loaded, we just check if a popup was
   // opened (the iframe content opens one).
   // Note: because of bug 1115868, no constrained window is opened right now.
@@ skipping 15 matching lines @@
       L"window.domAutomationController.send(IsFooSet());", &js_result));
   EXPECT_FALSE(js_result);
 }
 
 // Visits a page with insecure content loaded by JS (after the initial page
 // load).
 IN_PROC_BROWSER_TEST_F(SSLUITest, TestDisplaysInsecureContentLoadedFromJS) {
   ASSERT_TRUE(test_server()->Start());
   ASSERT_TRUE(https_server_.Start());
 
+  std::string replacement_path = GetFileWithHostAndPortReplacement(
+      "files/ssl/page_with_dynamic_insecure_content.html",
+      test_server()->host_port_pair());
   ui_test_utils::NavigateToURL(browser(), https_server_.GetURL(
-      "files/ssl/page_with_dynamic_insecure_content.html"));
+      replacement_path));
 
   TabContents* tab = browser()->GetSelectedTabContents();
   CheckAuthenticatedState(tab, false);
 
   // Load the insecure image.
   bool js_result = false;
   EXPECT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractBool(
       tab->render_view_host(), std::wstring(), L"loadBadImage();", &js_result));
   EXPECT_TRUE(js_result);
 
@@ skipping 10 matching lines @@
 
   ui_test_utils::NavigateToURL(browser(),
       https_server_.GetURL("files/ssl/blank_page.html"));
 
   TabContents* tab1 = browser()->GetSelectedTabContents();
 
   // This tab should be fine.
   CheckAuthenticatedState(tab1, false);
 
   // Create a new tab.
-  GURL url = https_server_.GetURL(
-      "files/ssl/page_displays_insecure_content.html");
+  std::string replacement_path = GetFileWithHostAndPortReplacement(
+      "files/ssl/page_displays_insecure_content.html",
+      test_server()->host_port_pair());
+
+  GURL url = https_server_.GetURL(replacement_path);
   browser::NavigateParams params(browser(), url, PageTransition::TYPED);
   params.disposition = NEW_FOREGROUND_TAB;
   params.tabstrip_index = 0;
   params.source_contents = tab1;
   browser::Navigate(&params);
   TabContents* tab2 = params.target_contents;
   ui_test_utils::WaitForNavigation(&(tab2->controller()));
 
   // The new tab has insecure content.
   CheckAuthenticatedState(tab2, true);
@@ skipping 10 matching lines @@
   ASSERT_TRUE(https_server_.Start());
 
   ui_test_utils::NavigateToURL(browser(),
       https_server_.GetURL("files/ssl/blank_page.html"));
 
   TabContents* tab1 = browser()->GetSelectedTabContents();
 
   // This tab should be fine.
   CheckAuthenticatedState(tab1, false);
 
+  std::string replacement_path = GetFileWithHostAndPortReplacement(
+      "files/ssl/page_runs_insecure_content.html",
+      test_server()->host_port_pair());
+
   // Create a new tab.
-  GURL url =
-      https_server_.GetURL("files/ssl/page_runs_insecure_content.html");
+  GURL url = https_server_.GetURL(replacement_path);
   browser::NavigateParams params(browser(), url, PageTransition::TYPED);
   params.disposition = NEW_FOREGROUND_TAB;
   params.source_contents = tab1;
   browser::Navigate(&params);
   TabContents* tab2 = params.target_contents;
   ui_test_utils::WaitForNavigation(&(tab2->controller()));
 
   // The new tab has insecure content.
   CheckAuthenticationBrokenState(tab2, 0, true, false);
 
   // Which means the origin for the first tab has also been contaminated with
   // insecure content.
   CheckAuthenticationBrokenState(tab1, 0, true, false);
 }
 
 // Visits a page with an image over http.  Visits another page over https
 // referencing that same image over http (hoping it is coming from the webcore
 // memory cache).
 IN_PROC_BROWSER_TEST_F(SSLUITest, TestDisplaysCachedInsecureContent) {
   ASSERT_TRUE(test_server()->Start());
   ASSERT_TRUE(https_server_.Start());
 
-  ui_test_utils::NavigateToURL(browser(), test_server()->GetURL(
-      "files/ssl/page_displays_insecure_content.html"));
+  std::string replacement_path = GetFileWithHostAndPortReplacement(
+      "files/ssl/page_displays_insecure_content.html",
+      test_server()->host_port_pair());
+
+  // Load original page over HTTP.
+  const GURL url_http = test_server()->GetURL(replacement_path);
+  ui_test_utils::NavigateToURL(browser(), url_http);
   TabContents* tab = browser()->GetSelectedTabContents();
   CheckUnauthenticatedState(tab);
 
   // Load again but over SSL.  It should be marked as displaying insecure
   // content (even though the image comes from the WebCore memory cache).
-  ui_test_utils::NavigateToURL(browser(), https_server_.GetURL(
-      "files/ssl/page_displays_insecure_content.html"));
+  const GURL url_https = https_server_.GetURL(replacement_path);
+  ui_test_utils::NavigateToURL(browser(), url_https);
   CheckAuthenticatedState(tab, true);
 }
 
 // Visits a page with script over http.  Visits another page over https
 // referencing that same script over http (hoping it is coming from the webcore
 // memory cache).
 IN_PROC_BROWSER_TEST_F(SSLUITest, TestRunsCachedInsecureContent) {
   ASSERT_TRUE(test_server()->Start());
   ASSERT_TRUE(https_server_.Start());
 
-  ui_test_utils::NavigateToURL(browser(),
-      test_server()->GetURL("files/ssl/page_runs_insecure_content.html"));
+  std::string replacement_path = GetFileWithHostAndPortReplacement(
+      "files/ssl/page_runs_insecure_content.html",
+      test_server()->host_port_pair());
+
+  // Load original page over HTTP.
+  const GURL url_http = test_server()->GetURL(replacement_path);
+  ui_test_utils::NavigateToURL(browser(), url_http);
   TabContents* tab = browser()->GetSelectedTabContents();
   CheckUnauthenticatedState(tab);
 
   // Load again but over SSL.  It should be marked as displaying insecure
   // content (even though the image comes from the WebCore memory cache).
-  ui_test_utils::NavigateToURL(browser(), https_server_.GetURL(
-      "files/ssl/page_runs_insecure_content.html"));
+  const GURL url_https = https_server_.GetURL(replacement_path);
+  ui_test_utils::NavigateToURL(browser(), url_https);
   CheckAuthenticationBrokenState(tab, 0, true, false);
 }
 
 #if defined(OS_WIN)
 // See http://crbug.com/47170
 #define MAYBE_TestCNInvalidStickiness FLAKY_TestCNInvalidStickiness
 #else
 #define MAYBE_TestCNInvalidStickiness TestCNInvalidStickiness
 #endif
 
@@ skipping 58 matching lines @@
 }
 
 // Tests that closing a page that has a unsafe pop-up does not crash the
 // browser (bug #1966).
 // TODO(jcampan): http://crbug.com/2136 disabled because the popup is not
 //                opened as it is not initiated by a user gesture.
 IN_PROC_BROWSER_TEST_F(SSLUITest, DISABLED_TestCloseTabWithUnsafePopup) {
   ASSERT_TRUE(test_server()->Start());
   ASSERT_TRUE(https_server_expired_.Start());
 
+  std::string replacement_path = GetFileWithHostAndPortReplacement(
+      "files/ssl/page_with_unsafe_popup.html",
+      https_server_expired_.host_port_pair());
+
   ui_test_utils::NavigateToURL(browser(),
-      test_server()->GetURL("files/ssl/page_with_unsafe_popup.html"));
+                               test_server()->GetURL(replacement_path));
 
   TabContents* tab1 = browser()->GetSelectedTabContents();
   // It is probably overkill to add a notification for a popup-opening, let's
   // just poll.
   for (int i = 0; i < 10; i++) {
     if (static_cast<int>(tab1->constrained_window_count()) > 0)
       break;
     MessageLoop::current()->PostDelayedTask(FROM_HERE,
                                             new MessageLoop::QuitTask(), 1000);
     ui_test_utils::RunMessageLoop();
@@ skipping 322 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.