All SSL UI tests work with ephemeral ports.

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_command_ids.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());
+  static bool GetFilePathWithHostAndPortReplacement(
+      const std::string& original_file_path,
+      const net::HostPortPair& host_port_pair,
+      std::string* replacement_path) {
+    std::vector<net::TestServer::StringPair> replacement_text;
+    replacement_text.push_back(
+        make_pair("REPLACE_WITH_HOST_AND_PORT", host_port_pair.ToString()));
+    return net::TestServer::GetFilePathWithReplacements(
+        original_file_path, replacement_text, replacement_path);
+  }
+
+  static bool GetTopFramePath(const net::TestServer& http_server,
+                              const net::TestServer& good_https_server,
+                              const net::TestServer& bad_https_server,
+                              std::string* top_frame_path) {
+    // The "frame_left.html" page contained in the top_frame.html page contains
+    // <a href>'s to three different servers. This sets up all of the
+    // replacement text to work with test servers which listen on ephemeral
+    // ports.
+    GURL http_url = http_server.GetURL("files/ssl/google.html");
+    GURL good_https_url = good_https_server.GetURL("files/ssl/google.html");
+    GURL bad_https_url = bad_https_server.GetURL(
+        "files/ssl/bad_iframe.html");
+
+    std::vector<net::TestServer::StringPair> replacement_text_frame_left;
+    replacement_text_frame_left.push_back(
+        make_pair("REPLACE_WITH_HTTP_PAGE", http_url.spec()));
+    replacement_text_frame_left.push_back(
+        make_pair("REPLACE_WITH_GOOD_HTTPS_PAGE", good_https_url.spec()));
+    replacement_text_frame_left.push_back(
+        make_pair("REPLACE_WITH_BAD_HTTPS_PAGE", bad_https_url.spec()));
+    std::string frame_left_path;
+    if (!net::TestServer::GetFilePathWithReplacements(
+            "frame_left.html",
+            replacement_text_frame_left,
+            &frame_left_path))
+      return false;
+
+    // Substitute the generated frame_left URL into the top_frame page.
+    std::vector<net::TestServer::StringPair> replacement_text_top_frame;
+    replacement_text_top_frame.push_back(
+        make_pair("REPLACE_WITH_FRAME_LEFT_PATH", frame_left_path));
+    return net::TestServer::GetFilePathWithReplacements(
+        "files/ssl/top_frame.html",
+        replacement_text_top_frame,
+        top_frame_path);
   }
 
   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());
 
-  std::string replacement_path = GetFileWithHostAndPortReplacement(
+  std::string replacement_path;
+  ASSERT_TRUE(GetFilePathWithHostAndPortReplacement(
       "files/ssl/page_with_unsafe_contents.html",
-      https_server_expired_.host_port_pair());
+      https_server_expired_.host_port_pair(),
+      &replacement_path));
 
   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());
@@ skipping 202 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(
+  std::string replacement_path;
+  ASSERT_TRUE(GetFilePathWithHostAndPortReplacement(
       "files/ssl/page_displays_insecure_content.html",
-      test_server()->host_port_pair());
+      test_server()->host_port_pair(),
+      &replacement_path));
 
   // Load a page that displays insecure content.
   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.
@@ skipping 12 matching lines @@
 }
 
 // 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());
 
-  std::string replacement_path = GetFileWithHostAndPortReplacement(
+  std::string replacement_path;
+  ASSERT_TRUE(GetFilePathWithHostAndPortReplacement(
       "files/ssl/page_with_unsafe_contents.html",
-      https_server_expired_.host_port_pair());
+      https_server_expired_.host_port_pair(),
+      &replacement_path));
   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
@@ skipping 17 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(
+  std::string replacement_path;
+  ASSERT_TRUE(GetFilePathWithHostAndPortReplacement(
       "files/ssl/page_with_dynamic_insecure_content.html",
-      test_server()->host_port_pair());
+      test_server()->host_port_pair(),
+      &replacement_path));
   ui_test_utils::NavigateToURL(browser(), https_server_.GetURL(
       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));
@@ skipping 12 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.
-  std::string replacement_path = GetFileWithHostAndPortReplacement(
+  std::string replacement_path;
+  ASSERT_TRUE(GetFilePathWithHostAndPortReplacement(
       "files/ssl/page_displays_insecure_content.html",
-      test_server()->host_port_pair());
+      test_server()->host_port_pair(),
+      &replacement_path));
 
   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()));
 
@@ skipping 12 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(
+  std::string replacement_path;
+  ASSERT_TRUE(GetFilePathWithHostAndPortReplacement(
       "files/ssl/page_runs_insecure_content.html",
-      test_server()->host_port_pair());
+      test_server()->host_port_pair(),
+      &replacement_path));
 
   // Create a new tab.
   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());
 
-  std::string replacement_path = GetFileWithHostAndPortReplacement(
+  std::string replacement_path;
+  ASSERT_TRUE(GetFilePathWithHostAndPortReplacement(
       "files/ssl/page_displays_insecure_content.html",
-      test_server()->host_port_pair());
+      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);
   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).
   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());
 
-  std::string replacement_path = GetFileWithHostAndPortReplacement(
+  std::string replacement_path;
+  ASSERT_TRUE(GetFilePathWithHostAndPortReplacement(
       "files/ssl/page_runs_insecure_content.html",
-      test_server()->host_port_pair());
+      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);
   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).
   const GURL url_https = https_server_.GetURL(replacement_path);
@@ skipping 69 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(
+  std::string replacement_path;
+  ASSERT_TRUE(GetFilePathWithHostAndPortReplacement(
       "files/ssl/page_with_unsafe_popup.html",
-      https_server_expired_.host_port_pair());
+      https_server_expired_.host_port_pair(),
+      &replacement_path));
 
   ui_test_utils::NavigateToURL(browser(),
                                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;
@@ skipping 128 matching lines @@
 // - navigate to an OK HTTPS frame
 // - navigate to a bad HTTPS (expect unsafe content and filtered frame), then
 //   back
 // - navigate to HTTP (expect insecure content), then back
 // Disabled, http://crbug.com/18626.
 IN_PROC_BROWSER_TEST_F(SSLUITest, DISABLED_TestGoodFrameNavigation) {
   ASSERT_TRUE(test_server()->Start());
   ASSERT_TRUE(https_server_.Start());
   ASSERT_TRUE(https_server_expired_.Start());
 
+  std::string top_frame_path;
+  ASSERT_TRUE(GetTopFramePath(*test_server(),
+                              https_server_,
+                              https_server_expired_,
+                              &top_frame_path));
+
   TabContents* tab = browser()->GetSelectedTabContents();
   ui_test_utils::NavigateToURL(browser(),
-      https_server_.GetURL("files/ssl/top_frame.html"));
+                               https_server_.GetURL(top_frame_path));
 
   CheckAuthenticatedState(tab, false);
 
   bool success = false;
   // Now navigate inside the frame.
   EXPECT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractBool(
       tab->render_view_host(), std::wstring(),
       L"window.domAutomationController.send(clickLink('goodHTTPSLink'));",
       &success));
   EXPECT_TRUE(success);
@@ skipping 45 matching lines @@
   CheckAuthenticatedState(tab, true);
 }
 
 // From a bad HTTPS top frame:
 // - navigate to an OK HTTPS frame (expected to be still authentication broken).
 // Marked as flaky, see bug 40932.
 IN_PROC_BROWSER_TEST_F(SSLUITest, FLAKY_TestBadFrameNavigation) {
   ASSERT_TRUE(https_server_.Start());
   ASSERT_TRUE(https_server_expired_.Start());
 
+  std::string top_frame_path;
+  ASSERT_TRUE(GetTopFramePath(*test_server(),
+                              https_server_,
+                              https_server_expired_,
+                              &top_frame_path));
+
   TabContents* tab = browser()->GetSelectedTabContents();
   ui_test_utils::NavigateToURL(browser(),
-      https_server_expired_.GetURL("files/ssl/top_frame.html"));
+                               https_server_expired_.GetURL(top_frame_path));
   CheckAuthenticationBrokenState(tab, net::CERT_STATUS_DATE_INVALID, false,
                                  true);  // Interstitial showing
 
   ProceedThroughInterstitial(tab);
 
   // Navigate to a good frame.
   bool success = false;
   EXPECT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractBool(
       tab->render_view_host(), std::wstring(),
       L"window.domAutomationController.send(clickLink('goodHTTPSLink'));",
@@ skipping 15 matching lines @@
 #else
 // Marked as flaky, see bug 40932.
 #define MAYBE_TestUnauthenticatedFrameNavigation \
       FLAKY_TestUnauthenticatedFrameNavigation
 #endif
 IN_PROC_BROWSER_TEST_F(SSLUITest, MAYBE_TestUnauthenticatedFrameNavigation) {
   ASSERT_TRUE(test_server()->Start());
   ASSERT_TRUE(https_server_.Start());
   ASSERT_TRUE(https_server_expired_.Start());
 
+  std::string top_frame_path;
+  ASSERT_TRUE(GetTopFramePath(*test_server(),
+                              https_server_,
+                              https_server_expired_,
+                              &top_frame_path));
+
   TabContents* tab = browser()->GetSelectedTabContents();
   ui_test_utils::NavigateToURL(browser(),
-      test_server()->GetURL("files/ssl/top_frame.html"));
+                               test_server()->GetURL(top_frame_path));
   CheckUnauthenticatedState(tab);
 
   // Now navigate inside the frame to a secure HTTPS frame.
   bool success = false;
   EXPECT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractBool(
       tab->render_view_host(), std::wstring(),
       L"window.domAutomationController.send(clickLink('goodHTTPSLink'));",
       &success));
   EXPECT_TRUE(success);
   ui_test_utils::WaitForNavigation(&tab->controller());
@@ skipping 68 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.