predictors: Use several hosts in resource_prefetch_predictor tests.

chrome/browser/predictors/resource_prefetch_predictor_browsertest.cc

 // Copyright 2016 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 <stddef.h>
 
+#include <algorithm>
 #include <set>
 
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_util.h"
 #include "base/test/histogram_tester.h"
 #include "chrome/browser/browsing_data/browsing_data_helper.h"
 #include "chrome/browser/browsing_data/browsing_data_remover.h"
 #include "chrome/browser/browsing_data/browsing_data_remover_factory.h"
 #include "chrome/browser/browsing_data/chrome_browsing_data_remover_delegate.h"
 #include "chrome/browser/predictors/resource_prefetch_predictor.h"
 #include "chrome/browser/predictors/resource_prefetch_predictor_factory.h"
 #include "chrome/browser/predictors/resource_prefetch_predictor_test_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "net/base/host_port_pair.h"
+#include "net/base/url_util.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/test/embedded_test_server/http_request.h"
 #include "net/test/embedded_test_server/http_response.h"
+#include "net/test/embedded_test_server/request_handler_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace predictors {
 
 namespace {
 
+const char kLocalHost[] = "127.0.0.1";
 const char kFooHost[] = "foo.com";
 const char kBarHost[] = "bar.com";
 const char kBazHost[] = "baz.com";
 
 const char kImageMime[] = "image/png";
 const char kStyleMime[] = "text/css";
 const char kJavascriptMime[] = "application/javascript";
 
 // Paths to resources handled by a custom request handler. They return empty
 // responses with controllable response headers.
@@ skipping 15 matching lines @@
 const char kHtmlAppendChildPath[] = "/predictors/append_child.html";
 const char kScriptAppendChildPath[] = "/predictors/append_child.js";
 const char kHtmlInnerHtmlPath[] = "/predictors/inner_html.html";
 const char kScriptInnerHtmlPath[] = "/predictors/inner_html.js";
 const char kHtmlXHRPath[] = "/predictors/xhr.html";
 const char kScriptXHRPath[] = "/predictors/xhr.js";
 const char kHtmlIframePath[] = "/predictors/html_iframe.html";
 const char kHtmlJavascriptRedirectPath[] =
     "/predictors/javascript_redirect.html";
 
+// Host, path.
+const char* kScript[2] = {kFooHost, kScriptPath};
+const char* kImage[2] = {kBarHost, kImagePath};
+const char* kFont[2] = {kFooHost, kFontPath};
+const char* kStyle[2] = {kBazHost, kStylePath};
+
 struct ResourceSummary {
   ResourceSummary()
       : version(0),
         is_no_store(false),
         is_external(false),
         is_observable(true),
         is_prohibited(false) {}
 
   ResourcePrefetchPredictor::URLRequestSummary request;
   // Allows to update HTTP ETag.
@@ skipping 229 matching lines @@
     command_line->AppendSwitchASCII("force-fieldtrial-params", parameter);
     std::string enabled_feature = base::StringPrintf(
         "%s<trial", kSpeculativeResourcePrefetchingFeatureName);
     command_line->AppendSwitchASCII("enable-features", enabled_feature);
   }
 
   void SetUpOnMainThread() override {
     // Resolving all hosts to local allows us to have
     // cross domains navigations (matching url_visit_count_, etc).
     host_resolver()->AddRule("*", "127.0.0.1");
-    embedded_test_server()->RegisterRequestHandler(
-        base::Bind(&ResourcePrefetchPredictorBrowserTest::HandleRedirectRequest,
-                   base::Unretained(this)));
-    embedded_test_server()->RegisterRequestHandler(
-        base::Bind(&ResourcePrefetchPredictorBrowserTest::HandleResourceRequest,
-                   base::Unretained(this)));
-    embedded_test_server()->RegisterRequestMonitor(base::Bind(
-        &ResourcePrefetchPredictorBrowserTest::MonitorResourceRequest,
-        base::Unretained(this)));
-    ASSERT_TRUE(embedded_test_server()->Start());
+
+    https_server_ = base::MakeUnique<net::EmbeddedTestServer>(
+        net::EmbeddedTestServer::TYPE_HTTPS);
+
+    for (auto* server : {embedded_test_server(), https_server()}) {
+      server->AddDefaultHandlers(
+          base::FilePath(FILE_PATH_LITERAL("chrome/test/data")));
+      server->RegisterRequestHandler(base::Bind(
+          &ResourcePrefetchPredictorBrowserTest::HandleRedirectRequest,
+          base::Unretained(this)));
+      server->RegisterRequestHandler(base::Bind(
+          &ResourcePrefetchPredictorBrowserTest::HandleResourceRequest,
+          base::Unretained(this)));
+      server->RegisterRequestMonitor(base::Bind(
+          &ResourcePrefetchPredictorBrowserTest::MonitorResourceRequest,
+          base::Unretained(this)));
+      ASSERT_TRUE(server->Start());
+    }
+
     predictor_ =
         ResourcePrefetchPredictorFactory::GetForProfile(browser()->profile());
     ASSERT_TRUE(predictor_);
     // URLs from the test server contain a port number.
     ResourcePrefetchPredictor::SetAllowPortInUrlsForTesting(true);
     EnsurePredictorInitialized();
     histogram_tester_.reset(new base::HistogramTester());
   }
 
   void TearDownOnMainThread() override {
@@ skipping 136 matching lines @@
     BrowsingDataRemoverObserver observer(remover);
     remover->RemoveAndReply(
         base::Time(), base::Time::Max(), BrowsingDataRemover::DATA_TYPE_CACHE,
         BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB, &observer);
     observer.Wait();
 
     for (auto& kv : resources_)
       kv.second.request.was_cached = false;
   }
 
-  // Shortcut for convenience.
+  // Shortcuts for convenience.
   GURL GetURL(const std::string& path) const {
     return embedded_test_server()->GetURL(path);
   }
 
-  void EnableHttpsServer() {
-    ASSERT_FALSE(https_server_);
-    https_server_ = base::MakeUnique<net::EmbeddedTestServer>(
-        net::EmbeddedTestServer::TYPE_HTTPS);
-    https_server()->AddDefaultHandlers(
-        base::FilePath(FILE_PATH_LITERAL("chrome/test/data")));
-    https_server()->RegisterRequestHandler(
-        base::Bind(&ResourcePrefetchPredictorBrowserTest::HandleRedirectRequest,
-                   base::Unretained(this)));
-    https_server()->RegisterRequestHandler(
-        base::Bind(&ResourcePrefetchPredictorBrowserTest::HandleResourceRequest,
-                   base::Unretained(this)));
-    https_server()->RegisterRequestMonitor(base::Bind(
-        &ResourcePrefetchPredictorBrowserTest::MonitorResourceRequest,
-        base::Unretained(this)));
-    ASSERT_TRUE(https_server()->Start());
+  GURL GetURLWithHost(const std::string& host,
+                      const std::string& path,
+                      bool https = false) const {
+    auto* server = https ? https_server() : embedded_test_server();
+    return server->GetURL(host, path);
   }
 
-  // Returns the embedded test server working over HTTPS. Must be enabled by
-  // calling EnableHttpsServer() before use.
+  // Only works if the resulting URL is served from a file.
+  std::string GetPathWithReplacements(const std::string& path) const {
+    std::string port = base::StringPrintf("%d", embedded_test_server()->port());
+    std::string path_with_replacements;
+    net::test_server::GetFilePathWithReplacements(
+        path, {{"REPLACE_WITH_PORT", port}}, &path_with_replacements);
+    return path_with_replacements;
+  }
+
+  GURL GetPageURLWithReplacements(const std::string& host,
+                                  const std::string& path,
+                                  bool https = false) const {
+    std::string path_with_replacements = GetPathWithReplacements(path);
+    return GetURLWithHost(host, path_with_replacements, https);
+  }
+
+  // Returns the embedded test server working over HTTPS.
   const net::EmbeddedTestServer* https_server() const {
     return https_server_.get();
   }
 
   net::EmbeddedTestServer* https_server() { return https_server_.get(); }
 
   size_t navigation_ids_history_size() const {
     return navigation_id_history_.size();
   }
 
+  // Expects the resources from kHtmlSubresourcesPath.
+  std::vector<ResourceSummary*> AddResourcesFromSubresourceHtml() {
+    // These resources have default priorities that correspond to
+    // blink::TypeToPriority().
+    return {AddResource(GetURLWithHost(kImage[0], kImage[1]),
+                        content::RESOURCE_TYPE_IMAGE, net::LOWEST),
+            AddResource(GetURLWithHost(kStyle[0], kStyle[1]),
+                        content::RESOURCE_TYPE_STYLESHEET, net::HIGHEST),
+            AddResource(GetURLWithHost(kScript[0], kScript[1]),
+                        content::RESOURCE_TYPE_SCRIPT, net::MEDIUM),
+            AddResource(GetURLWithHost(kFont[0], kFont[1]),
+                        content::RESOURCE_TYPE_FONT_RESOURCE, net::HIGHEST)};
+  }
+
   std::unique_ptr<base::HistogramTester> histogram_tester_;
 
  private:
   // ResourcePrefetchPredictor needs to be initialized before the navigation
   // happens otherwise this navigation will be ignored by predictor.
   void EnsurePredictorInitialized() {
     if (predictor_->initialization_state_ ==
         ResourcePrefetchPredictor::INITIALIZED) {
       return;
     }
@@ skipping 145 matching lines @@
     std::string parameter = base::StringPrintf(
         "trial.group:%s/%s", kModeParamName, kPrefetchingMode);
     command_line->AppendSwitchASCII("force-fieldtrial-params", parameter);
     std::string enabled_feature = base::StringPrintf(
         "%s<trial", kSpeculativeResourcePrefetchingFeatureName);
     command_line->AppendSwitchASCII("enable-features", enabled_feature);
   }
 };
 
 IN_PROC_BROWSER_TEST_F(ResourcePrefetchPredictorBrowserTest, Simple) {
-  // These resources have default priorities that correspond to
-  // blink::typeToPriority function.
-  AddResource(GetURL(kImagePath), content::RESOURCE_TYPE_IMAGE, net::LOWEST);
-  AddResource(GetURL(kStylePath), content::RESOURCE_TYPE_STYLESHEET,
-              net::HIGHEST);
-  AddResource(GetURL(kScriptPath), content::RESOURCE_TYPE_SCRIPT, net::MEDIUM);
-  AddResource(GetURL(kFontPath), content::RESOURCE_TYPE_FONT_RESOURCE,
-              net::HIGHEST);
-  TestLearningAndPrefetching(GetURL(kHtmlSubresourcesPath));
+  AddResourcesFromSubresourceHtml();
+  GURL url = GetPageURLWithReplacements(kFooHost, kHtmlSubresourcesPath);
+  TestLearningAndPrefetching(url);
 
   // The local cache is cleared.
   histogram_tester_->ExpectBucketCount(
       internal::kResourcePrefetchPredictorPrefetchMissesCountCached, 0, 1);
   histogram_tester_->ExpectBucketCount(
       internal::kResourcePrefetchPredictorPrefetchMissesCountNotCached, 0, 1);
   histogram_tester_->ExpectBucketCount(
       internal::kResourcePrefetchPredictorPrefetchHitsCountCached, 0, 1);
   histogram_tester_->ExpectBucketCount(
       internal::kResourcePrefetchPredictorPrefetchHitsCountNotCached, 4, 1);
 
   histogram_tester_->ExpectBucketCount(
       internal::kResourcePrefetchPredictorPrefetchMissesSize, 0, 1);
   // Each request is ~1k, see HandleResourceRequest() above.
   histogram_tester_->ExpectBucketCount(
       internal::kResourcePrefetchPredictorPrefetchHitsSize, 4, 1);
 }
 
 IN_PROC_BROWSER_TEST_F(ResourcePrefetchPredictorBrowserTest, Redirect) {
-  GURL initial_url = embedded_test_server()->GetURL(kFooHost, kRedirectPath);
-  AddRedirectChain(initial_url, {{net::HTTP_MOVED_PERMANENTLY,
-                                  GetURL(kHtmlSubresourcesPath)}});
-  AddResource(GetURL(kImagePath), content::RESOURCE_TYPE_IMAGE, net::LOWEST);
-  AddResource(GetURL(kStylePath), content::RESOURCE_TYPE_STYLESHEET,
-              net::HIGHEST);
-  AddResource(GetURL(kScriptPath), content::RESOURCE_TYPE_SCRIPT, net::MEDIUM);
-  AddResource(GetURL(kFontPath), content::RESOURCE_TYPE_FONT_RESOURCE,
-              net::HIGHEST);
+  GURL initial_url = GetURLWithHost(kFooHost, kRedirectPath);
+  GURL redirected_url =
+      GetPageURLWithReplacements(kBarHost, kHtmlSubresourcesPath);
+  AddRedirectChain(initial_url,
+                   {{net::HTTP_MOVED_PERMANENTLY, redirected_url}});
+  AddResourcesFromSubresourceHtml();
   TestLearningAndPrefetching(initial_url);
 }
 
 IN_PROC_BROWSER_TEST_F(ResourcePrefetchPredictorBrowserTest, RedirectChain) {
-  GURL initial_url = embedded_test_server()->GetURL(kFooHost, kRedirectPath);
-  AddRedirectChain(initial_url,
-                   {{net::HTTP_FOUND,
-                     embedded_test_server()->GetURL(kBarHost, kRedirectPath2)},
-                    {net::HTTP_MOVED_PERMANENTLY,
-                     embedded_test_server()->GetURL(kBazHost, kRedirectPath3)},
-                    {net::HTTP_FOUND, GetURL(kHtmlSubresourcesPath)}});
-  AddResource(GetURL(kImagePath), content::RESOURCE_TYPE_IMAGE, net::LOWEST);
-  AddResource(GetURL(kStylePath), content::RESOURCE_TYPE_STYLESHEET,
-              net::HIGHEST);
-  AddResource(GetURL(kScriptPath), content::RESOURCE_TYPE_SCRIPT, net::MEDIUM);
-  AddResource(GetURL(kFontPath), content::RESOURCE_TYPE_FONT_RESOURCE,
-              net::HIGHEST);
+  GURL initial_url = GetURLWithHost(kFooHost, kRedirectPath);
+  GURL redirected_url =
+      GetPageURLWithReplacements(kFooHost, kHtmlSubresourcesPath);
+  AddRedirectChain(
+      initial_url,
+      {{net::HTTP_FOUND, GetURLWithHost(kBarHost, kRedirectPath2)},
+       {net::HTTP_MOVED_PERMANENTLY, GetURLWithHost(kBazHost, kRedirectPath3)},
+       {net::HTTP_FOUND, redirected_url}});
+  AddResourcesFromSubresourceHtml();
   TestLearningAndPrefetching(initial_url);
 }
 
 IN_PROC_BROWSER_TEST_F(ResourcePrefetchPredictorBrowserTest,
                        HttpToHttpsRedirect) {
-  EnableHttpsServer();
-  GURL initial_url = embedded_test_server()->GetURL(kFooHost, kRedirectPath);
+  GURL initial_url = GetURLWithHost(kFooHost, kRedirectPath);
+  GURL redirected_url =
+      GetPageURLWithReplacements(kLocalHost, kHtmlSubresourcesPath, true);
+
+  // Only one resource, as HTTP images in HTTPS pages are only a warning, not
+  // an error.
+  AddResource(GetURLWithHost(kImage[0], kImage[1]),
+              content::RESOURCE_TYPE_IMAGE, net::LOWEST);
+
   AddRedirectChain(initial_url,
-                   {{net::HTTP_MOVED_PERMANENTLY,
-                     https_server()->GetURL(kHtmlSubresourcesPath)}});
-  AddResource(https_server()->GetURL(kImagePath), content::RESOURCE_TYPE_IMAGE,
-              net::LOWEST);
-  AddResource(https_server()->GetURL(kStylePath),
-              content::RESOURCE_TYPE_STYLESHEET, net::HIGHEST);
-  AddResource(https_server()->GetURL(kScriptPath),
-              content::RESOURCE_TYPE_SCRIPT, net::MEDIUM);
-  AddResource(https_server()->GetURL(kFontPath),
-              content::RESOURCE_TYPE_FONT_RESOURCE, net::HIGHEST);
+                   {{net::HTTP_MOVED_PERMANENTLY, redirected_url}});
   TestLearningAndPrefetching(initial_url);
 }
 
 IN_PROC_BROWSER_TEST_F(ResourcePrefetchPredictorBrowserTest,
                        JavascriptDocumentWrite) {
   auto* externalScript =
       AddExternalResource(GetURL(kScriptDocumentWritePath),
                           content::RESOURCE_TYPE_SCRIPT, net::MEDIUM);
   externalScript->request.mime_type = kJavascriptMime;
   AddResource(GetURL(kImagePath), content::RESOURCE_TYPE_IMAGE, net::LOWEST);
@@ skipping 59 matching lines @@
   AddResource(GetURL(kScriptPath2), content::RESOURCE_TYPE_SCRIPT, net::MEDIUM);
   // Included from <iframe src="html_subresources.html"> and shouldn't be
   // observed.
   AddUnobservableResources({GetURL(kImagePath), GetURL(kStylePath),
                             GetURL(kScriptPath), GetURL(kFontPath)});
   TestLearningAndPrefetching(GetURL(kHtmlIframePath));
 }
 
 IN_PROC_BROWSER_TEST_F(ResourcePrefetchPredictorBrowserTest,
                        CrossSiteNavigation) {
-  AddResource(embedded_test_server()->GetURL(kFooHost, kImagePath),
-              content::RESOURCE_TYPE_IMAGE, net::LOWEST);
-  AddResource(embedded_test_server()->GetURL(kFooHost, kStylePath),
-              content::RESOURCE_TYPE_STYLESHEET, net::HIGHEST);
-  AddResource(embedded_test_server()->GetURL(kFooHost, kScriptPath),
-              content::RESOURCE_TYPE_SCRIPT, net::MEDIUM);
-  AddResource(embedded_test_server()->GetURL(kFooHost, kFontPath),
-              content::RESOURCE_TYPE_FONT_RESOURCE, net::HIGHEST);
-  TestLearningAndPrefetching(
-      embedded_test_server()->GetURL(kFooHost, kHtmlSubresourcesPath));
+  AddResourcesFromSubresourceHtml();
+  GURL url = GetPageURLWithReplacements(kFooHost, kHtmlSubresourcesPath);
+  TestLearningAndPrefetching(url);
+
   ClearResources();
-
-  AddResource(embedded_test_server()->GetURL(kBarHost, kImagePath),
-              content::RESOURCE_TYPE_IMAGE, net::LOWEST);
-  AddResource(embedded_test_server()->GetURL(kBarHost, kStylePath),
-              content::RESOURCE_TYPE_STYLESHEET, net::HIGHEST);
-  AddResource(embedded_test_server()->GetURL(kBarHost, kScriptPath),
-              content::RESOURCE_TYPE_SCRIPT, net::MEDIUM);
-  AddResource(embedded_test_server()->GetURL(kBarHost, kFontPath),
-              content::RESOURCE_TYPE_FONT_RESOURCE, net::HIGHEST);
+  ClearCache();
+  AddResourcesFromSubresourceHtml();
   // Navigating to kBarHost, although done in the same tab, will generate a new
   // process.
-  TestLearningAndPrefetching(
-      embedded_test_server()->GetURL(kBarHost, kHtmlSubresourcesPath));
+  url = GetPageURLWithReplacements(kBarHost, kHtmlSubresourcesPath);
+  TestLearningAndPrefetching(url);
 }
 
 // In this test we are trying to assess if :
 // - Reloading in the same tab is using the same NavigationID.
 // - Navigation into a new tab, window or popup yields different NavigationID's.
 // - Navigating twice to a new browser/popup yields different NavigationID's.
 IN_PROC_BROWSER_TEST_F(ResourcePrefetchPredictorBrowserTest,
                        TabIdBehavingAsExpected) {
-  AddResource(GetURL(kImagePath), content::RESOURCE_TYPE_IMAGE, net::LOWEST);
-  AddResource(GetURL(kStylePath), content::RESOURCE_TYPE_STYLESHEET,
-              net::HIGHEST);
-  AddResource(GetURL(kScriptPath), content::RESOURCE_TYPE_SCRIPT, net::MEDIUM);
-  AddResource(GetURL(kFontPath), content::RESOURCE_TYPE_FONT_RESOURCE,
-              net::HIGHEST);
-  NavigateToURLAndCheckSubresources(GetURL(kHtmlSubresourcesPath));
+  AddResourcesFromSubresourceHtml();
+  GURL url = GetPageURLWithReplacements(kFooHost, kHtmlSubresourcesPath);
+  NavigateToURLAndCheckSubresources(url);
   EXPECT_EQ(navigation_ids_history_size(), 1U);
   ClearCache();
-  NavigateToURLAndCheckSubresources(GetURL(kHtmlSubresourcesPath));
+  NavigateToURLAndCheckSubresources(url);
   EXPECT_EQ(navigation_ids_history_size(), 1U);
   ClearCache();
-  NavigateToURLAndCheckSubresources(GetURL(kHtmlSubresourcesPath),
+  NavigateToURLAndCheckSubresources(url,
                                     WindowOpenDisposition::NEW_BACKGROUND_TAB);
   EXPECT_EQ(navigation_ids_history_size(), 2U);
   ClearCache();
-  NavigateToURLAndCheckSubresources(GetURL(kHtmlSubresourcesPath),
-                                    WindowOpenDisposition::NEW_WINDOW);
+  NavigateToURLAndCheckSubresources(url, WindowOpenDisposition::NEW_WINDOW);
   EXPECT_EQ(navigation_ids_history_size(), 3U);
   ClearCache();
-  NavigateToURLAndCheckSubresources(GetURL(kHtmlSubresourcesPath),
-                                    WindowOpenDisposition::NEW_POPUP);
+  NavigateToURLAndCheckSubresources(url, WindowOpenDisposition::NEW_POPUP);
   EXPECT_EQ(navigation_ids_history_size(), 4U);
 }
 
 IN_PROC_BROWSER_TEST_F(ResourcePrefetchPredictorBrowserTest, AlwaysRevalidate) {
-  std::vector<ResourceSummary*> resources = {
-      AddResource(GetURL(kImagePath), content::RESOURCE_TYPE_IMAGE,
-                  net::LOWEST),
-      AddResource(GetURL(kStylePath), content::RESOURCE_TYPE_STYLESHEET,
-                  net::HIGHEST),
-      AddResource(GetURL(kScriptPath), content::RESOURCE_TYPE_SCRIPT,
-                  net::MEDIUM),
-      AddResource(GetURL(kFontPath), content::RESOURCE_TYPE_FONT_RESOURCE,
-                  net::HIGHEST),
-  };
+  auto resources = AddResourcesFromSubresourceHtml();
+  GURL url = GetPageURLWithReplacements(kFooHost, kHtmlSubresourcesPath);
   for (auto* resource : resources)
     resource->request.always_revalidate = true;
-  TestLearningAndPrefetching(GetURL(kHtmlSubresourcesPath));
+  TestLearningAndPrefetching(url);
 }
 
 // Client-side redirects currently aren't tracked by ResourcePrefetchPredictor.
 // A client-side redirect initiates a new navigation to the redirect destination
 // URL and aborts the current navigation so that the OnLoad event is not fired.
 IN_PROC_BROWSER_TEST_F(ResourcePrefetchPredictorBrowserTest,
                        JavascriptRedirectsAreNotHandled) {
-  std::string redirect_path_with_query =
-      std::string(kHtmlJavascriptRedirectPath) + "?url=" +
-      GetURL(kHtmlSubresourcesPath).spec();
-  GURL initial_url =
-      embedded_test_server()->GetURL(kBarHost, redirect_path_with_query);
-  AddRedirectChain(initial_url, {{net::HTTP_TEMPORARY_REDIRECT,
-                                  GetURL(kHtmlSubresourcesPath), true}});
-  AddResource(GetURL(kImagePath), content::RESOURCE_TYPE_IMAGE, net::LOWEST);
-  AddResource(GetURL(kStylePath), content::RESOURCE_TYPE_STYLESHEET,
-              net::HIGHEST);
-  AddResource(GetURL(kScriptPath), content::RESOURCE_TYPE_SCRIPT, net::MEDIUM);
-  AddResource(GetURL(kFontPath), content::RESOURCE_TYPE_FONT_RESOURCE,
-              net::HIGHEST);
+  GURL redirected_url =
+      GetPageURLWithReplacements(kFooHost, kHtmlSubresourcesPath);
+  GURL initial_url = GetURLWithHost(kBarHost, kHtmlJavascriptRedirectPath);
+  initial_url =
+      net::AppendQueryParameter(initial_url, "url", redirected_url.spec());
+
+  AddRedirectChain(initial_url,
+                   {{net::HTTP_TEMPORARY_REDIRECT, redirected_url, true}});
+  AddResourcesFromSubresourceHtml();
 
   // Two navigations will occur. LearningObserver will get events only for the
   // second navigation because the first one will be aborted.
   NavigateToURLAndCheckSubresources(initial_url);
   ClearCache();
   // It is needed to have at least two resource hits to trigger prefetch.
   NavigateToURLAndCheckSubresources(initial_url);
   ClearCache();
   // Prefetching of |initial_url| has no effect because there is no entry in
   // the predictor database corresponding the client-side redirect.
   TryToPrefetchURL(initial_url);
   NavigateToURLAndCheckSubresources(initial_url);
   ClearCache();
   // But the predictor database contains all subresources for the endpoint url
   // so this prefetch works.
-  PrefetchURL(GetURL(kHtmlSubresourcesPath));
-  NavigateToURLAndCheckSubresourcesAllCached(GetURL(kHtmlSubresourcesPath));
+  PrefetchURL(redirected_url);
+  NavigateToURLAndCheckSubresourcesAllCached(redirected_url);
 }
 
 // Makes sure that {Stop,Start}Prefetching are called with the same argument.
 IN_PROC_BROWSER_TEST_F(ResourcePrefetchPredictorPrefetchingBrowserTest,
                        Simple) {
-  AddResource(GetURL(kImagePath), content::RESOURCE_TYPE_IMAGE, net::LOWEST);
-  AddResource(GetURL(kStylePath), content::RESOURCE_TYPE_STYLESHEET,
-              net::HIGHEST);
-  AddResource(GetURL(kScriptPath), content::RESOURCE_TYPE_SCRIPT, net::MEDIUM);
-  AddResource(GetURL(kFontPath), content::RESOURCE_TYPE_FONT_RESOURCE,
-              net::HIGHEST);
+  AddResourcesFromSubresourceHtml();
 
-  GURL main_frame_url = GetURL(kHtmlSubresourcesPath);
+  GURL main_frame_url =
+      GetPageURLWithReplacements(kFooHost, kHtmlSubresourcesPath);
   NavigateToURLAndCheckSubresources(main_frame_url);
   ClearCache();
   NavigateToURLAndCheckSubresources(main_frame_url);
   ClearCache();
   NavigateToURLAndCheckPrefetching(main_frame_url);
 }
 
 // Makes sure that {Stop,Start}Prefetching are called with the same argument in
 // presence of redirect.
 IN_PROC_BROWSER_TEST_F(ResourcePrefetchPredictorPrefetchingBrowserTest,
                        Redirect) {
-  GURL initial_url = embedded_test_server()->GetURL(kFooHost, kRedirectPath);
-  AddRedirectChain(initial_url, {{net::HTTP_MOVED_PERMANENTLY,
-                                  GetURL(kHtmlSubresourcesPath)}});
-  AddResource(GetURL(kImagePath), content::RESOURCE_TYPE_IMAGE, net::LOWEST);
-  AddResource(GetURL(kStylePath), content::RESOURCE_TYPE_STYLESHEET,
-              net::HIGHEST);
-  AddResource(GetURL(kScriptPath), content::RESOURCE_TYPE_SCRIPT, net::MEDIUM);
-  AddResource(GetURL(kFontPath), content::RESOURCE_TYPE_FONT_RESOURCE,
-              net::HIGHEST);
+  GURL initial_url = GetURLWithHost(kFooHost, kRedirectPath);
+  GURL redirected_url =
+      GetPageURLWithReplacements(kBarHost, kHtmlSubresourcesPath);
+  AddRedirectChain(initial_url,
+                   {{net::HTTP_MOVED_PERMANENTLY, redirected_url}});
+  AddResourcesFromSubresourceHtml();
 
   NavigateToURLAndCheckSubresources(initial_url);
   ClearCache();
   NavigateToURLAndCheckSubresources(initial_url);
   ClearCache();
   NavigateToURLAndCheckPrefetching(initial_url);
 }
 
 }  // namespace predictors