Set "Service-Worker-Navigation-Preload" header

content/browser/service_worker/service_worker_browsertest.cc

 // Copyright 2014 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 <stdint.h>
 
 #include <map>
 #include <memory>
 #include <utility>
@@ skipping 1398 matching lines @@
     ServiceWorkerBrowserTest::SetUpOnMainThread();
   }
 
   void SetUpCommandLine(base::CommandLine* command_line) override {
     command_line->AppendSwitchASCII(
         switches::kEnableFeatures,
         features::kServiceWorkerNavigationPreload.name);
   }
 
  protected:
+  static const std::string kNavigationPreloadHeaderName;
+  static const std::string kEnableNavigationPreloadScript;
+  static const std::string kPreloadResponseTestScript;
+
+  static bool HasNavigationPreloadHeader(
+      const net::test_server::HttpRequest& request) {
+    return request.headers.find(kNavigationPreloadHeaderName) !=
+           request.headers.end();
+  }
+
+  static std::string GetNavigationPreloadHeader(
+      const net::test_server::HttpRequest& request) {
+    DCHECK(HasNavigationPreloadHeader(request));
+    return request.headers.find(kNavigationPreloadHeaderName)->second;
+  }
+
   void SetupForNavigationPreloadTest(const GURL& scope,
-                                     const GURL& worker_url,
-                                     bool enable_navigation_preload) {
+                                     const GURL& worker_url) {
     scoped_refptr<WorkerActivatedObserver> observer =
         new WorkerActivatedObserver(wrapper());
     observer->Init();
     public_context()->RegisterServiceWorker(
         scope, worker_url,
         base::Bind(&ExpectResultAndRun, true, base::Bind(&base::DoNothing)));
     observer->Wait();
-    if (enable_navigation_preload) {
-      RunOnIOThread(base::Bind(&self::EnableNavigationPreloadOnIO,
-                               base::Unretained(this), scope));
-    }
 
     embedded_test_server()->RegisterRequestMonitor(
         base::Bind(&self::MonitorRequestHandler, base::Unretained(this)));
   }
 
   void RegisterStaticFile(const std::string& relative_url,
                           const std::string& content,
                           const std::string& content_type) {
     embedded_test_server()->RegisterRequestHandler(
         base::Bind(&self::StaticRequestHandler, base::Unretained(this),
                    relative_url, content, content_type));
   }
 
   void RegisterCustomResponse(const std::string& relative_url,
                               const std::string& response) {
     embedded_test_server()->RegisterRequestHandler(
         base::Bind(&self::CustomRequestHandler, base::Unretained(this),
                    relative_url, response));
   }
 
   void RegisterKeepSearchRedirect(const std::string& relative_url,
                                   const std::string& redirect_location) {
     embedded_test_server()->RegisterRequestHandler(
         base::Bind(&self::KeepSearchRedirectHandler, base::Unretained(this),
                    relative_url, redirect_location));
   }
 
   int GetRequestCount(const std::string& relative_url) const {
-    int count = 0;
-    for (const auto& request : request_log_) {
-      if (request == relative_url)
-        ++count;
-    }
-    return count;
+    const auto& it = request_log_.find(relative_url);
+    if (it == request_log_.end())
+      return 0;
+    return it->second.size();
   }
 
   std::string GetTextContent() {
     base::RunLoop run_loop;
     std::string text_content;
     shell()->web_contents()->GetMainFrame()->ExecuteJavaScriptForTests(
         base::ASCIIToUTF16("document.body.textContent;"),
         base::Bind(&StoreString, &text_content, run_loop.QuitClosure()));
     run_loop.Run();
     return text_content;
   }
 
-  static const char kPreloadResponseTestScript[];
+  std::map<std::string, std::vector<net::test_server::HttpRequest>>
+      request_log_;
 
  private:
   class CustomResponse : public net::test_server::HttpResponse {
    public:
     CustomResponse(const std::string& response) : response_(response) {}
     ~CustomResponse() override {}
 
     void SendResponse(
         const net::test_server::SendBytesCallback& send,
         const net::test_server::SendCompleteCallback& done) override {
       send.Run(response_, done);
     }
 
    private:
     const std::string response_;
 
     DISALLOW_COPY_AND_ASSIGN(CustomResponse);
   };
 
-  void EnableNavigationPreloadOnIO(const GURL& scope,
-                                   const base::Closure& continuation) {
-    wrapper()->FindReadyRegistrationForDocument(
-        scope, base::Bind(&self::DidFindRegistrationForEnableNavigationPreload,
-                          base::Unretained(this), continuation));
-  }
-
-  void DidFindRegistrationForEnableNavigationPreload(
-      const base::Closure& continuation,
-      ServiceWorkerStatusCode status,
-      scoped_refptr<ServiceWorkerRegistration> registration) {
-    EXPECT_EQ(SERVICE_WORKER_OK, status);
-    ASSERT_TRUE(registration->active_version());
-    registration->EnableNavigationPreload(true);
-    continuation.Run();
-  }
-
   std::unique_ptr<net::test_server::HttpResponse> StaticRequestHandler(
       const std::string& relative_url,
       const std::string& content,
       const std::string& content_type,
       const net::test_server::HttpRequest& request) const {
     const size_t query_position = request.relative_url.find('?');
     if (request.relative_url.substr(0, query_position) != relative_url)
       return std::unique_ptr<net::test_server::HttpResponse>();
     std::unique_ptr<net::test_server::BasicHttpResponse> http_response(
         base::MakeUnique<net::test_server::BasicHttpResponse>());
@@ skipping 25 matching lines @@
     response->set_code(net::HTTP_PERMANENT_REDIRECT);
     response->AddCustomHeader(
         "Location",
         query_position == std::string::npos
             ? redirect_location
             : redirect_location + request.relative_url.substr(query_position));
     return std::move(response);
   }
 
   void MonitorRequestHandler(const net::test_server::HttpRequest& request) {
-    request_log_.push_back(request.relative_url);
+    request_log_[request.relative_url].push_back(request);
   }
-
-  std::vector<std::string> request_log_;
 };
 
-const char ServiceWorkerNavigationPreloadTest::kPreloadResponseTestScript[] =
-    "var preload_resolve;\n"
-    "var preload_promise = new Promise(r => { preload_resolve = r; });\n"
-    "self.addEventListener('fetch', event => {\n"
-    "    event.waitUntil(event.preloadResponse.then(\n"
-    "        r => {\n"
-    "          if (!r) {\n"
-    "            preload_resolve(\n"
-    "                {result: 'RESOLVED', info: 'Resolved with ' + r + '.'});\n"
-    "            return;\n"
-    "          }\n"
-    "          var info = {};\n"
-    "          info.type = r.type;\n"
-    "          info.url = r.url;\n"
-    "          info.status = r.status;\n"
-    "          info.ok = r.ok;\n"
-    "          info.statusText = r.statusText;\n"
-    "          info.headers = [];\n"
-    "          r.headers.forEach((v, n) => { info.headers.push([n,v]); });\n"
-    "          preload_resolve({result: 'RESOLVED',\n"
-    "                           info: JSON.stringify(info)}); },\n"
-    "        e => { preload_resolve({result: 'REJECTED',\n"
-    "                                info: e.toString()}); }));\n"
-    "    event.respondWith(\n"
-    "        new Response(\n"
-    "            '<title>WAITING</title><script>\\n' +\n"
-    "            'var channel = new MessageChannel();\\n' +\n"
-    "            'channel.port1.onmessage = e => {\\n' +\n"
-    "            '    var div = document.createElement(\\'div\\');\\n' +\n"
-    "            '    div.appendChild(' +\n"
-    "            '        document.createTextNode(e.data.info));\\n' +\n"
-    "            '    document.body.appendChild(div);\\n' +\n"
-    "            '    document.title = e.data.result;\\n' +\n"
-    "            '  };\\n' +\n"
-    "            'navigator.serviceWorker.controller.postMessage(\\n' +\n"
-    "            '    {}, [channel.port2]);\\n' +\n"
-    "            '</script>',"
-    "            {headers: [['content-type', 'text/html']]}));\n"
-    "  });\n"
-    "self.addEventListener('message', event => {\n"
-    "    event.waitUntil(\n"
-    "        preload_promise.then(\n"
-    "            result => event.ports[0].postMessage(result)));\n"
-    "  });";
+const std::string
+    ServiceWorkerNavigationPreloadTest::kNavigationPreloadHeaderName(
+        "Service-Worker-Navigation-Preload");
+
+const std::string
+    ServiceWorkerNavigationPreloadTest::kEnableNavigationPreloadScript(
+        "self.addEventListener('install', event => {\n"
+        "    event.waitUntil(self.registration.navigationPreload.enable());\n"
+        "  });\n");
+
+const std::string
+    ServiceWorkerNavigationPreloadTest::kPreloadResponseTestScript =
+        "var preload_resolve;\n"
+        "var preload_promise = new Promise(r => { preload_resolve = r; });\n"
+        "self.addEventListener('fetch', event => {\n"
+        "    event.waitUntil(event.preloadResponse.then(\n"
+        "        r => {\n"
+        "          if (!r) {\n"
+        "            preload_resolve(\n"
+        "                {result: 'RESOLVED', \n"
+        "                 info: 'Resolved with ' + r + '.'});\n"
+        "            return;\n"
+        "          }\n"
+        "          var info = {};\n"
+        "          info.type = r.type;\n"
+        "          info.url = r.url;\n"
+        "          info.status = r.status;\n"
+        "          info.ok = r.ok;\n"
+        "          info.statusText = r.statusText;\n"
+        "          info.headers = [];\n"
+        "          r.headers.forEach(\n"
+        "              (v, n) => { info.headers.push([n,v]); });\n"
+        "          preload_resolve({result: 'RESOLVED',\n"
+        "                           info: JSON.stringify(info)}); },\n"
+        "        e => { preload_resolve({result: 'REJECTED',\n"
+        "                                info: e.toString()}); }));\n"
+        "    event.respondWith(\n"
+        "        new Response(\n"
+        "            '<title>WAITING</title><script>\\n' +\n"
+        "            'navigator.serviceWorker.onmessage = e => {\\n' +\n"
+        "            '    var div = document.createElement(\\'div\\');\\n' +\n"
+        "            '    div.appendChild(' +\n"
+        "            '        document.createTextNode(e.data.info));\\n' +\n"
+        "            '    document.body.appendChild(div);\\n' +\n"
+        "            '    document.title = e.data.result;\\n' +\n"
+        "            '  };\\n' +\n"
+        "            'navigator.serviceWorker.controller.postMessage(\\n' +\n"
+        "            '    null);\\n' +\n"
+        "            '</script>',"
+        "            {headers: [['content-type', 'text/html']]}));\n"
+        "  });\n"
+        "self.addEventListener('message', event => {\n"
+        "    event.waitUntil(\n"
+        "        preload_promise.then(\n"
+        "            result => event.source.postMessage(result)));\n"
+        "  });";
 
 IN_PROC_BROWSER_TEST_P(ServiceWorkerNavigationPreloadTest, NetworkFallback) {
   const char kPageUrl[] = "/service_worker/navigation_preload.html";
   const char kWorkerUrl[] = "/service_worker/navigation_preload.js";
   const char kPage[] = "<title>PASS</title>Hello world.";
-  const char kScript[] =
-      "self.addEventListener('fetch', event => {\n"
-      "    // Do nothing.\n"
-      "  });";
+  const std::string kScript = kEnableNavigationPreloadScript +
+                              "self.addEventListener('fetch', event => {\n"
+                              "    // Do nothing.\n"
+                              "  });";
   const GURL page_url = embedded_test_server()->GetURL(kPageUrl);
   const GURL worker_url = embedded_test_server()->GetURL(kWorkerUrl);
   RegisterStaticFile(kPageUrl, kPage, "text/html");
   RegisterStaticFile(kWorkerUrl, kScript, "text/javascript");
 
-  SetupForNavigationPreloadTest(page_url, worker_url,
-                                true /* enable_navigation_preload */);
+  SetupForNavigationPreloadTest(page_url, worker_url);
 
   const base::string16 title = base::ASCIIToUTF16("PASS");
   TitleWatcher title_watcher(shell()->web_contents(), title);
   NavigateToURL(shell(), page_url);
   EXPECT_EQ(title, title_watcher.WaitAndGetTitle());
   EXPECT_EQ("Hello world.", GetTextContent());
 
   // The page request must be sent twice. Once for navigation preload, and once
   // for fallback since respondWith wasn't used.
-  EXPECT_EQ(2, GetRequestCount(kPageUrl));
-  // TODO(horo): Check "Service-Worker-Navigation-Preload" header.
-  // See: https://github.com/w3c/ServiceWorker/issues/920#issuecomment-251150270
+  ASSERT_EQ(2, GetRequestCount(kPageUrl));
+  ASSERT_TRUE(HasNavigationPreloadHeader(request_log_[kPageUrl][0]));
+  EXPECT_EQ("true", GetNavigationPreloadHeader(request_log_[kPageUrl][0]));
+  EXPECT_FALSE(HasNavigationPreloadHeader(request_log_[kPageUrl][1]));
+}
+
+IN_PROC_BROWSER_TEST_P(ServiceWorkerNavigationPreloadTest, SetHeaderValue) {
+  const std::string kPageUrl = "/service_worker/navigation_preload.html";
+  const std::string kWorkerUrl = "/service_worker/navigation_preload.js";
+  const std::string kPage = "<title>FROM_SERVER</title>";
+  const std::string kScript =
+      "function createResponse(title, body) {\n"
+      "  return new Response('<title>' + title + '</title>' + body,\n"
+      "                      {headers: [['content-type', 'text/html']]})\n"
+      "}\n"
+      "self.addEventListener('fetch', event => {\n"
+      "    if (event.request.url.indexOf('?enable') != -1) {\n"
+      "      event.respondWith(\n"
+      "          self.registration.navigationPreload.enable()\n"
+      "            .then(_ => event.preloadResponse)\n"
+      "            .then(res => createResponse('ENABLED', res)));\n"
+      "    } else if (event.request.url.indexOf('?change') != -1) {\n"
+      "      event.respondWith(\n"
+      "          self.registration.navigationPreload.setHeaderValue('Hello')\n"
+      "            .then(_ => event.preloadResponse)\n"
+      "            .then(res => createResponse('CHANGED', res)));\n"
+      "    } else if (event.request.url.indexOf('?disable') != -1) {\n"
+      "      event.respondWith(\n"
+      "          self.registration.navigationPreload.disable()\n"
+      "            .then(_ => event.preloadResponse)\n"
+      "            .then(res => createResponse('DISABLED', res)));\n"
+      "    } else if (event.request.url.indexOf('?test') != -1) {\n"
+      "      event.respondWith(event.preloadResponse.then(res =>\n"
+      "          createResponse('TEST', res)));\n"
+      "    }\n"
+      "  });";
+  const GURL page_url = embedded_test_server()->GetURL(kPageUrl);
+  const GURL worker_url = embedded_test_server()->GetURL(kWorkerUrl);
+  RegisterStaticFile(kPageUrl, kPage, "text/html");
+  RegisterStaticFile(kWorkerUrl, kScript, "text/javascript");
+
+  SetupForNavigationPreloadTest(page_url, worker_url);
+
+  const std::string kPageUrl1 = kPageUrl + "?enable";
+  const base::string16 title1 = base::ASCIIToUTF16("ENABLED");
+  TitleWatcher title_watcher1(shell()->web_contents(), title1);
+  title_watcher1.AlsoWaitForTitle(base::ASCIIToUTF16("FROM_SERVER"));
+  NavigateToURL(shell(), embedded_test_server()->GetURL(kPageUrl1));
+  EXPECT_EQ(title1, title_watcher1.WaitAndGetTitle());
+  // When the navigation started, the navigation preload was not enabled yet.
+  EXPECT_EQ("null", GetTextContent());
+  ASSERT_EQ(0, GetRequestCount(kPageUrl1));
+
+  const std::string kPageUrl2 = kPageUrl + "?change";
+  const base::string16 title2 = base::ASCIIToUTF16("CHANGED");
+  TitleWatcher title_watcher2(shell()->web_contents(), title2);
+  title_watcher2.AlsoWaitForTitle(base::ASCIIToUTF16("FROM_SERVER"));
+  NavigateToURL(shell(), embedded_test_server()->GetURL(kPageUrl2));
+  EXPECT_EQ(title2, title_watcher2.WaitAndGetTitle());
+  // When the navigation started, the navigation preload was enabled, but the
+  // header was not changed yet.
+  EXPECT_EQ("[object Response]", GetTextContent());
+  ASSERT_EQ(1, GetRequestCount(kPageUrl2));
+  ASSERT_TRUE(HasNavigationPreloadHeader(request_log_[kPageUrl2][0]));
+  EXPECT_EQ("true", GetNavigationPreloadHeader(request_log_[kPageUrl2][0]));
+
+  const std::string kPageUrl3 = kPageUrl + "?disable";
+  const base::string16 title3 = base::ASCIIToUTF16("DISABLED");
+  TitleWatcher title_watcher3(shell()->web_contents(), title3);
+  title_watcher3.AlsoWaitForTitle(base::ASCIIToUTF16("FROM_SERVER"));
+  NavigateToURL(shell(), embedded_test_server()->GetURL(kPageUrl3));
+  EXPECT_EQ(title3, title_watcher3.WaitAndGetTitle());
+  // When the navigation started, the navigation preload was not disabled yet.
+  EXPECT_EQ("[object Response]", GetTextContent());
+  ASSERT_EQ(1, GetRequestCount(kPageUrl3));
+  ASSERT_TRUE(HasNavigationPreloadHeader(request_log_[kPageUrl3][0]));
+  EXPECT_EQ("Hello", GetNavigationPreloadHeader(request_log_[kPageUrl3][0]));
+
+  const std::string kPageUrl4 = kPageUrl + "?test";
+  const base::string16 title4 = base::ASCIIToUTF16("TEST");
+  TitleWatcher title_watcher4(shell()->web_contents(), title4);
+  title_watcher4.AlsoWaitForTitle(base::ASCIIToUTF16("FROM_SERVER"));
+  NavigateToURL(shell(), embedded_test_server()->GetURL(kPageUrl4));
+  EXPECT_EQ(title4, title_watcher4.WaitAndGetTitle());
+  // When the navigation started, the navigation preload must be disabled.
+  EXPECT_EQ("null", GetTextContent());
+  ASSERT_EQ(0, GetRequestCount(kPageUrl4));
 }
 
 IN_PROC_BROWSER_TEST_P(ServiceWorkerNavigationPreloadTest,
                        RespondWithNavigationPreload) {
   const char kPageUrl[] = "/service_worker/navigation_preload.html";
   const char kWorkerUrl[] = "/service_worker/navigation_preload.js";
   const char kPage[] = "<title>PASS</title>Hello world.";
-  const char kScript[] =
+  const std::string kScript =
+      kEnableNavigationPreloadScript +
       "self.addEventListener('fetch', event => {\n"
       "    if (!event.preloadResponse) {\n"
       "      event.respondWith(\n"
       "          new Response('<title>ERROR</title>',"
       "                       {headers: [['content-type', 'text/html']]}));\n"
       "      return;\n"
       "    }\n"
       "    event.respondWith(event.preloadResponse);\n"
       "  });";
   const GURL page_url = embedded_test_server()->GetURL(kPageUrl);
   const GURL worker_url = embedded_test_server()->GetURL(kWorkerUrl);
   RegisterStaticFile(kPageUrl, kPage, "text/html");
   RegisterStaticFile(kWorkerUrl, kScript, "text/javascript");
 
-  SetupForNavigationPreloadTest(page_url, worker_url,
-                                true /* enable_navigation_preload */);
+  SetupForNavigationPreloadTest(page_url, worker_url);
 
   const base::string16 title = base::ASCIIToUTF16("PASS");
   TitleWatcher title_watcher(shell()->web_contents(), title);
   title_watcher.AlsoWaitForTitle(base::ASCIIToUTF16("ERROR"));
   NavigateToURL(shell(), page_url);
   EXPECT_EQ(title, title_watcher.WaitAndGetTitle());
   EXPECT_EQ("Hello world.", GetTextContent());
 
   // The page request must be sent only once, since the worker responded with
   // the navigation preload response
-  EXPECT_EQ(1, GetRequestCount(kPageUrl));
-  // TODO(horo): Check "Service-Worker-Navigation-Preload" header.
-  // See: https://github.com/w3c/ServiceWorker/issues/920#issuecomment-251150270
+  ASSERT_EQ(1, GetRequestCount(kPageUrl));
+  EXPECT_EQ("true",
+            request_log_[kPageUrl][0].headers[kNavigationPreloadHeaderName]);
 }
 
 IN_PROC_BROWSER_TEST_P(ServiceWorkerNavigationPreloadTest, GetResponseText) {
   const char kPageUrl[] = "/service_worker/navigation_preload.html";
   const char kWorkerUrl[] = "/service_worker/navigation_preload.js";
   const char kPage[] = "<title>PASS</title>Hello world.";
-  const char kScript[] =
+  const std::string kScript =
+      kEnableNavigationPreloadScript +
       "self.addEventListener('fetch', event => {\n"
       "    event.respondWith(\n"
       "        event.preloadResponse\n"
       "          .then(response => response.text())\n"
       "          .then(text =>\n"
       "                  new Response(\n"
       "                      text,\n"
       "                      {headers: [['content-type', 'text/html']]})));\n"
       "  });";
   const GURL page_url = embedded_test_server()->GetURL(kPageUrl);
   const GURL worker_url = embedded_test_server()->GetURL(kWorkerUrl);
   RegisterStaticFile(kPageUrl, kPage, "text/html");
   RegisterStaticFile(kWorkerUrl, kScript, "text/javascript");
 
-  SetupForNavigationPreloadTest(page_url, worker_url,
-                                true /* enable_navigation_preload */);
+  SetupForNavigationPreloadTest(page_url, worker_url);
 
   const base::string16 title = base::ASCIIToUTF16("PASS");
   TitleWatcher title_watcher(shell()->web_contents(), title);
   NavigateToURL(shell(), page_url);
   EXPECT_EQ(title, title_watcher.WaitAndGetTitle());
   EXPECT_EQ("Hello world.", GetTextContent());
 
   // The page request must be sent only once, since the worker responded with
   // "Hello world".
   EXPECT_EQ(1, GetRequestCount(kPageUrl));
 }
 
 IN_PROC_BROWSER_TEST_P(ServiceWorkerNavigationPreloadTest,
                        AbortPreloadRequest) {
   const char kPageUrl[] = "/service_worker/navigation_preload.html";
   const char kWorkerUrl[] = "/service_worker/navigation_preload.js";
   const char kPage[] = "<title>ERROR</title>Hello world.";
   // In this script, event.preloadResponse is not guarded by event.waitUntil.
   // So the preload request should be canceled, when the fetch event handler
   // has been executed.
-  const char kScript[] =
+  const std::string kScript =
+      kEnableNavigationPreloadScript +
       "var preload_resolve;\n"
       "var preload_promise = new Promise(r => { preload_resolve = r; });\n"
       "self.addEventListener('fetch', event => {\n"
       "    event.preloadResponse.then(\n"
       "        _ => { preload_resolve({result: 'RESOLVED',\n"
       "                                info: 'Preload resolved.'}); },\n"
       "        e => { preload_resolve({result: 'REJECTED',\n"
       "                                info: e.toString()}); });\n"
       "    event.respondWith(\n"
       "        new Response(\n"
       "            '<title>WAITING</title><script>\\n' +\n"
-      "            'var channel = new MessageChannel();\\n' +\n"
-      "            'channel.port1.onmessage = e => {\\n' +\n"
+      "            'navigator.serviceWorker.onmessage = e => {\\n' +\n"
       "            '    var div = document.createElement(\\'div\\');\\n' +\n"
       "            '    div.appendChild(' +\n"
       "            '        document.createTextNode(e.data.info));\\n' +\n"
       "            '    document.body.appendChild(div);\\n' +\n"
       "            '    document.title = e.data.result;\\n' +\n"
       "            '  };\\n' +\n"
       "            'navigator.serviceWorker.controller.postMessage(\\n' +\n"
-      "            '    {}, [channel.port2]);\\n' +\n"
+      "            '    null);\\n' +\n"
       "            '</script>',"
       "            {headers: [['content-type', 'text/html']]}));\n"
       "  });\n"
       "self.addEventListener('message', event => {\n"
       "    event.waitUntil(\n"
       "        preload_promise.then(\n"
-      "            result => event.ports[0].postMessage(result)));\n"
+      "            result => event.source.postMessage(result)));\n"
       "  });";
   const GURL page_url = embedded_test_server()->GetURL(kPageUrl);
   const GURL worker_url = embedded_test_server()->GetURL(kWorkerUrl);
   RegisterStaticFile(kPageUrl, kPage, "text/html");
   RegisterStaticFile(kWorkerUrl, kScript, "text/javascript");
 
-  SetupForNavigationPreloadTest(page_url, worker_url,
-                                true /* enable_navigation_preload */);
+  SetupForNavigationPreloadTest(page_url, worker_url);
 
   const base::string16 title = base::ASCIIToUTF16("REJECTED");
   TitleWatcher title_watcher(shell()->web_contents(), title);
   title_watcher.AlsoWaitForTitle(base::ASCIIToUTF16("RESOLVED"));
   title_watcher.AlsoWaitForTitle(base::ASCIIToUTF16("ERROR"));
   NavigateToURL(shell(), page_url);
   EXPECT_EQ(title, title_watcher.WaitAndGetTitle());
 
   EXPECT_EQ(
       "AbortError: Service Worker navigation preload aborted. Need to guard "
       "with respondWith or waitUntil.",
       GetTextContent());
 }
 
 IN_PROC_BROWSER_TEST_P(ServiceWorkerNavigationPreloadTest, NetworkError) {
   const char kPageUrl[] = "/service_worker/navigation_preload.html";
   const char kWorkerUrl[] = "/service_worker/navigation_preload.js";
   const GURL page_url = embedded_test_server()->GetURL(kPageUrl);
   const GURL worker_url = embedded_test_server()->GetURL(kWorkerUrl);
-  RegisterStaticFile(kWorkerUrl, kPreloadResponseTestScript, "text/javascript");
+  RegisterStaticFile(
+      kWorkerUrl, kEnableNavigationPreloadScript + kPreloadResponseTestScript,
+      "text/javascript");
 
-  SetupForNavigationPreloadTest(page_url, worker_url,
-                                true /* enable_navigation_preload */);
+  SetupForNavigationPreloadTest(page_url, worker_url);
 
   EXPECT_TRUE(embedded_test_server()->ShutdownAndWaitUntilComplete());
 
   const base::string16 title = base::ASCIIToUTF16("REJECTED");
   TitleWatcher title_watcher(shell()->web_contents(), title);
   title_watcher.AlsoWaitForTitle(base::ASCIIToUTF16("RESOLVED"));
   NavigateToURL(shell(), page_url);
   EXPECT_EQ(title, title_watcher.WaitAndGetTitle());
   EXPECT_EQ("NetworkError: Service Worker navigation preload network error.",
             GetTextContent());
 }
 
 IN_PROC_BROWSER_TEST_P(ServiceWorkerNavigationPreloadTest,
                        PreloadHeadersSimple) {
   const char kPageUrl[] = "/service_worker/navigation_preload.html";
   const char kWorkerUrl[] = "/service_worker/navigation_preload.js";
   const char kPage[] = "<title>ERROR</title>Hello world.";
   const GURL page_url = embedded_test_server()->GetURL(kPageUrl);
   const GURL worker_url = embedded_test_server()->GetURL(kWorkerUrl);
   RegisterStaticFile(kPageUrl, kPage, "text/html");
-  RegisterStaticFile(kWorkerUrl, kPreloadResponseTestScript, "text/javascript");
+  RegisterStaticFile(
+      kWorkerUrl, kEnableNavigationPreloadScript + kPreloadResponseTestScript,
+      "text/javascript");
 
-  SetupForNavigationPreloadTest(page_url, worker_url,
-                                true /* enable_navigation_preload */);
+  SetupForNavigationPreloadTest(page_url, worker_url);
 
   const base::string16 title = base::ASCIIToUTF16("RESOLVED");
   TitleWatcher title_watcher(shell()->web_contents(), title);
   title_watcher.AlsoWaitForTitle(base::ASCIIToUTF16("REJECTED"));
   title_watcher.AlsoWaitForTitle(base::ASCIIToUTF16("ERROR"));
   NavigateToURL(shell(), page_url);
   EXPECT_EQ(title, title_watcher.WaitAndGetTitle());
 
   // The page request must be sent only once, since the worker responded with
   // a generated Response.
@@ skipping 14 matching lines @@
 
 IN_PROC_BROWSER_TEST_P(ServiceWorkerNavigationPreloadTest, NotEnabled) {
   const char kPageUrl[] = "/service_worker/navigation_preload.html";
   const char kWorkerUrl[] = "/service_worker/navigation_preload.js";
   const char kPage[] = "<title>ERROR</title>Hello world.";
   const GURL page_url = embedded_test_server()->GetURL(kPageUrl);
   const GURL worker_url = embedded_test_server()->GetURL(kWorkerUrl);
   RegisterStaticFile(kPageUrl, kPage, "text/html");
   RegisterStaticFile(kWorkerUrl, kPreloadResponseTestScript, "text/javascript");
 
-  SetupForNavigationPreloadTest(page_url, worker_url,
-                                false /* enable_navigation_preload */);
+  SetupForNavigationPreloadTest(page_url, worker_url);
 
   const base::string16 title = base::ASCIIToUTF16("RESOLVED");
   TitleWatcher title_watcher(shell()->web_contents(), title);
   title_watcher.AlsoWaitForTitle(base::ASCIIToUTF16("REJECTED"));
   title_watcher.AlsoWaitForTitle(base::ASCIIToUTF16("ERROR"));
   NavigateToURL(shell(), page_url);
   EXPECT_EQ(title, title_watcher.WaitAndGetTitle());
 
   // The page request must not be sent, since the worker responded with a
   // generated Response and the navigation preload isn't enabled.
@@ skipping 12 matching lines @@
       "Content-Type: text/html\r\n"
       "Custom-Header: pen pineapple\r\n"
       "Custom-Header: apple pen\r\n"
       "Set-Cookie: COOKIE1\r\n"
       "Set-Cookie2: COOKIE2\r\n"
       "\r\n"
       "<title>ERROR</title>Hello world.";
   const GURL page_url = embedded_test_server()->GetURL(kPageUrl);
   const GURL worker_url = embedded_test_server()->GetURL(kWorkerUrl);
   RegisterCustomResponse(kPageUrl, kPageResponse);
-  RegisterStaticFile(kWorkerUrl, kPreloadResponseTestScript, "text/javascript");
+  RegisterStaticFile(
+      kWorkerUrl, kEnableNavigationPreloadScript + kPreloadResponseTestScript,
+      "text/javascript");
 
-  SetupForNavigationPreloadTest(page_url, worker_url,
-                                true /* enable_navigation_preload */);
+  SetupForNavigationPreloadTest(page_url, worker_url);
 
   const base::string16 title = base::ASCIIToUTF16("RESOLVED");
   TitleWatcher title_watcher(shell()->web_contents(), title);
   title_watcher.AlsoWaitForTitle(base::ASCIIToUTF16("REJECTED"));
   title_watcher.AlsoWaitForTitle(base::ASCIIToUTF16("ERROR"));
   NavigateToURL(shell(), page_url);
   EXPECT_EQ(title, title_watcher.WaitAndGetTitle());
 
   // The page request must be sent only once, since the worker responded with
   // a generated Response.
@@ skipping 24 matching lines @@
       "HTTP/1.1 302 Found\r\n"
       "Connection: close\r\n"
       "Location: /service_worker/navigation_preload_redirected.html\r\n"
       "\r\n";
   const char kRedirectedPage[] = "<title>ERROR</title>Redirected page.";
   const GURL redirecred_page_url =
       embedded_test_server()->GetURL(kRedirectedPageUrl);
   const GURL page_url = embedded_test_server()->GetURL(kPageUrl);
   const GURL worker_url = embedded_test_server()->GetURL(kWorkerUrl);
   RegisterCustomResponse(kPageUrl, kPageResponse);
-  RegisterStaticFile(kWorkerUrl, kPreloadResponseTestScript, "text/javascript");
+  RegisterStaticFile(
+      kWorkerUrl, kEnableNavigationPreloadScript + kPreloadResponseTestScript,
+      "text/javascript");
   RegisterStaticFile(kRedirectedPageUrl, kRedirectedPage, "text/html");
 
-  SetupForNavigationPreloadTest(page_url, worker_url,
-                                true /* enable_navigation_preload */);
+  SetupForNavigationPreloadTest(page_url, worker_url);
 
   const base::string16 title = base::ASCIIToUTF16("REJECTED");
   TitleWatcher title_watcher(shell()->web_contents(), title);
   title_watcher.AlsoWaitForTitle(base::ASCIIToUTF16("RESOLVED"));
   NavigateToURL(shell(), page_url);
   EXPECT_EQ(title, title_watcher.WaitAndGetTitle());
 
   // The page request must be sent only once, since the worker responded with
   // a generated Response.
   EXPECT_EQ(1, GetRequestCount(kPageUrl));
   // The redirected request must not be sent.
   EXPECT_EQ(0, GetRequestCount(kRedirectedPageUrl));
   // TODO(horo): When MojoAsyncResourceHandler will support redirection, we
   // shold provide more specific error message.
   EXPECT_EQ("NetworkError: Service Worker navigation preload network error.",
             GetTextContent());
 }
 
 // Tests responding with the navigation preload response when the navigation
 // occurred after a redirect.
 IN_PROC_BROWSER_TEST_P(ServiceWorkerNavigationPreloadTest,
                        RedirectAndRespondWithNavigationPreload) {
   const std::string kPageUrl = "/service_worker/navigation_preload.html";
   const char kWorkerUrl[] = "/service_worker/navigation_preload.js";
   const char kPage[] =
       "<title></title>\n"
       "<script>document.title = document.location.search;</script>";
-  const char kScript[] =
+  const std::string kScript =
+      kEnableNavigationPreloadScript +
       "self.addEventListener('fetch', event => {\n"
       "    if (event.request.url.indexOf('navigation_preload.html') == -1)\n"
       "      return; // For in scope redirection.\n"
       "    event.respondWith(event.preloadResponse);\n"
       "  });";
   const GURL page_url = embedded_test_server()->GetURL(kPageUrl);
   const GURL worker_url = embedded_test_server()->GetURL(kWorkerUrl);
   RegisterStaticFile(kPageUrl, kPage, "text/html");
   RegisterStaticFile(kWorkerUrl, kScript, "text/javascript");
 
   // Register redirects to the target URL. The service worker responds to the
   // target URL with the navigation preload response.
   const char kRedirectPageUrl[] = "/redirect";
   const char kInScopeRedirectPageUrl[] = "/service_worker/redirect";
   RegisterKeepSearchRedirect(kRedirectPageUrl, page_url.spec());
   RegisterKeepSearchRedirect(kInScopeRedirectPageUrl, page_url.spec());
 
   SetupForNavigationPreloadTest(
-      embedded_test_server()->GetURL("/service_worker/"), worker_url,
-      true /* enable_navigation_preload */);
+      embedded_test_server()->GetURL("/service_worker/"), worker_url);
 
   const GURL redirect_page_url =
       embedded_test_server()->GetURL(kRedirectPageUrl).Resolve("?1");
   const GURL in_scope_redirect_page_url =
       embedded_test_server()->GetURL(kInScopeRedirectPageUrl).Resolve("?2");
   const GURL cross_origin_redirect_page_url =
       embedded_test_server()->GetURL("a.com", kRedirectPageUrl).Resolve("?3");
 
   // Navigate to a same-origin, out of scope URL that redirects to the target
   // URL. The navigation preload request should be the single request to the
@@ skipping 25 matching lines @@
 // When the content type of the page is not correctly set,
 // OnStartLoadingResponseBody() of mojom::URLLoaderClient is called before
 // OnReceiveResponse(). This behavior is caused by MimeSniffingResourceHandler.
 // This test checks that even if the MimeSniffingResourceHandler is triggered
 // navigation preload must be handled correctly.
 IN_PROC_BROWSER_TEST_P(ServiceWorkerNavigationPreloadTest,
                        RespondWithNavigationPreloadWithMimeSniffing) {
   const char kPageUrl[] = "/service_worker/navigation_preload.html";
   const char kWorkerUrl[] = "/service_worker/navigation_preload.js";
   const char kPage[] = "<title>PASS</title>Hello world.";
-  const char kScript[] =
-      "self.addEventListener('fetch', event => {\n"
-      "    event.respondWith(event.preloadResponse);\n"
-      "  });";
+  const std::string kScript = kEnableNavigationPreloadScript +
+                              "self.addEventListener('fetch', event => {\n"
+                              "    event.respondWith(event.preloadResponse);\n"
+                              "  });";
   const GURL page_url = embedded_test_server()->GetURL(kPageUrl);
   const GURL worker_url = embedded_test_server()->GetURL(kWorkerUrl);
 
   // Setting an empty content type to trigger MimeSniffingResourceHandler.
   RegisterStaticFile(kPageUrl, kPage, "");
   RegisterStaticFile(kWorkerUrl, kScript, "text/javascript");
 
-  SetupForNavigationPreloadTest(page_url, worker_url,
-                                true /* enable_navigation_preload */);
+  SetupForNavigationPreloadTest(page_url, worker_url);
 
   const base::string16 title = base::ASCIIToUTF16("PASS");
   TitleWatcher title_watcher(shell()->web_contents(), title);
   NavigateToURL(shell(), page_url);
   EXPECT_EQ(title, title_watcher.WaitAndGetTitle());
   EXPECT_EQ("Hello world.", GetTextContent());
 
   // The page request must be sent only once, since the worker responded with
   // the navigation preload response
   EXPECT_EQ(1, GetRequestCount(kPageUrl));
@@ skipping 710 matching lines @@
                         ServiceWorkerV8CacheStrategiesNormalTest,
                         ::testing::Values(true, false));
 INSTANTIATE_TEST_CASE_P(ServiceWorkerBrowserTest,
                         ServiceWorkerV8CacheStrategiesAggressiveTest,
                         ::testing::Values(true, false));
 INSTANTIATE_TEST_CASE_P(ServiceWorkerBrowserTest,
                         ServiceWorkerDisableWebSecurityTest,
                         ::testing::Values(true, false));
 
 }  // namespace content