Fix SSLUITest.TestUnsafeContentsInWorker*.

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/time.h"
 #include "chrome/app/chrome_command_ids.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"
@@ skipping 146 matching lines @@
     // 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);
   }
 
+  static bool GetPageWithUnsafeWorkerPath(
+      const net::TestServer& expired_https_server,
+      std::string* page_with_unsafe_worker_path) {
+    // Get the "imported.js" URL from the expired https server and
+    // substitute it into the unsafe_worker.js file.
+    GURL imported_js_url = expired_https_server.GetURL("files/ssl/imported.js");
+    std::vector<net::TestServer::StringPair> replacement_text_for_unsafe_worker;
+    replacement_text_for_unsafe_worker.push_back(
+        make_pair("REPLACE_WITH_IMPORTED_JS_URL", imported_js_url.spec()));
+    std::string unsafe_worker_path;
+    if (!net::TestServer::GetFilePathWithReplacements(
+        "unsafe_worker.js",
+        replacement_text_for_unsafe_worker,
+        &unsafe_worker_path))
+      return false;
+
+    // Now, substitute this into the page with unsafe worker.
+    std::vector<net::TestServer::StringPair>
+        replacement_text_for_page_with_unsafe_worker;
+    replacement_text_for_page_with_unsafe_worker.push_back(
+        make_pair("REPLACE_WITH_UNSAFE_WORKER_PATH", unsafe_worker_path));
+    return net::TestServer::GetFilePathWithReplacements(
+        "files/ssl/page_with_unsafe_worker.html",
+        replacement_text_for_page_with_unsafe_worker,
+        page_with_unsafe_worker_path);
+  }
+
   net::TestServer https_server_;
   net::TestServer https_server_expired_;
   net::TestServer https_server_mismatched_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SSLUITest);
 };
 
 // Visits a regular page over http.
 IN_PROC_BROWSER_TEST_F(SSLUITest, TestHTTP) {
@@ skipping 847 matching lines @@
   EXPECT_FALSE(is_content_evil);
 }
 
 // Marked as flaky, see bug 40932.
 IN_PROC_BROWSER_TEST_F(SSLUITest, FLAKY_TestUnsafeContentsInWorkerFiltered) {
   ASSERT_TRUE(https_server_.Start());
   ASSERT_TRUE(https_server_expired_.Start());
 
   // This page will spawn a Worker which will try to load content from
   // BadCertServer.
+  std::string page_with_unsafe_worker_path;
+  ASSERT_TRUE(GetPageWithUnsafeWorkerPath(https_server_expired_,
+                                          &page_with_unsafe_worker_path));
   ui_test_utils::NavigateToURL(browser(), https_server_.GetURL(
-      "files/ssl/page_with_unsafe_worker.html"));
+      page_with_unsafe_worker_path));
   TabContents* tab = browser()->GetSelectedTabContents();
   // Expect Worker not to load insecure content.
   CheckWorkerLoadResult(tab, false);
   // The bad content is filtered, expect the state to be authenticated.
   CheckAuthenticatedState(tab, false);
 }
 
 // Marked as flaky, see bug 40932.
 IN_PROC_BROWSER_TEST_F(SSLUITest, FLAKY_TestUnsafeContentsInWorker) {
   ASSERT_TRUE(https_server_.Start());
   ASSERT_TRUE(https_server_expired_.Start());
 
   // Navigate to an unsafe site. Proceed with interstitial page to indicate
   // the user approves the bad certificate.
   ui_test_utils::NavigateToURL(browser(),
       https_server_expired_.GetURL("files/ssl/blank_page.html"));
   TabContents* tab = browser()->GetSelectedTabContents();
   CheckAuthenticationBrokenState(tab, net::CERT_STATUS_DATE_INVALID, false,
                                  true);  // Interstitial showing
   ProceedThroughInterstitial(tab);
   CheckAuthenticationBrokenState(tab, net::CERT_STATUS_DATE_INVALID, false,
                                  false);  // No Interstitial
 
   // Navigate to safe page that has Worker loading unsafe content.
   // Expect content to load but be marked as auth broken due to running insecure
   // content.
+  std::string page_with_unsafe_worker_path;
+  ASSERT_TRUE(GetPageWithUnsafeWorkerPath(https_server_expired_,
+                                          &page_with_unsafe_worker_path));
   ui_test_utils::NavigateToURL(browser(), https_server_.GetURL(
-      "files/ssl/page_with_unsafe_worker.html"));
+      page_with_unsafe_worker_path));
   CheckWorkerLoadResult(tab, true);  // Worker loads insecure content
   CheckAuthenticationBrokenState(tab, 0, true, false);
 }
 
 // TODO(jcampan): more tests to do below.
 
 // 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.