Support Service Worker NavigationPreload with PlzNavigate.

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 47 matching lines @@
 #include "content/public/common/content_switches.h"
 #include "content/public/common/referrer.h"
 #include "content/public/common/resource_type.h"
 #include "content/public/common/web_preferences.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/content_browser_test.h"
 #include "content/public/test/content_browser_test_utils.h"
 #include "content/shell/browser/shell.h"
 #include "content/shell/browser/shell_content_browser_client.h"
 #include "content/test/test_content_browser_client.h"
+#include "net/dns/mock_host_resolver.h"
 #include "net/log/net_log_with_source.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "net/test/embedded_test_server/http_request.h"
 #include "net/test/embedded_test_server/http_response.h"
 #include "net/url_request/url_request_filter.h"
 #include "net/url_request/url_request_interceptor.h"
 #include "net/url_request/url_request_test_job.h"
 #include "storage/browser/blob/blob_data_handle.h"
 #include "storage/browser/blob/blob_data_snapshot.h"
 #include "storage/browser/blob/blob_reader.h"
@@ skipping 1329 matching lines @@
       base::Bind(&ExpectResultAndRun, true, run_loop.QuitClosure()));
   run_loop.Run();
 }
 
 class ServiceWorkerNavigationPreloadTest : public ServiceWorkerBrowserTest {
  public:
   using self = ServiceWorkerNavigationPreloadTest;
 
   ~ServiceWorkerNavigationPreloadTest() override {}
 
+  void SetUpOnMainThread() override {
+    host_resolver()->AddRule("*", "127.0.0.1");
+    ServiceWorkerBrowserTest::SetUpOnMainThread();
+  }
+
   void SetUpCommandLine(base::CommandLine* command_line) override {
     command_line->AppendSwitchASCII(
         switches::kEnableFeatures,
         features::kServiceWorkerNavigationPreload.name);
   }
 
  protected:
   void SetupForNavigationPreloadTest(const GURL& scope,
                                      const GURL& worker_url,
                                      bool enable_navigation_preload) {
     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 GURL& url,
+  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), url,
-                   content, content_type));
+        base::Bind(&self::StaticRequestHandler, base::Unretained(this),
+                   relative_url, content, content_type));
   }
 
-  void RegisterCustomResponse(const GURL& url, const std::string& response) {
-    embedded_test_server()->RegisterRequestHandler(base::Bind(
-        &self::CustomRequestHandler, base::Unretained(this), url, response));
+  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;
   }
@@ skipping 39 matching lines @@
       const base::Closure& continuation,
       ServiceWorkerStatusCode status,
       scoped_refptr<ServiceWorkerRegistration> registration) {
     EXPECT_EQ(SERVICE_WORKER_OK, status);
     ASSERT_TRUE(registration->active_version());
     registration->active_version()->set_navigation_preload_enabled(true);
     continuation.Run();
   }
 
   std::unique_ptr<net::test_server::HttpResponse> StaticRequestHandler(
-      const GURL& url,
+      const std::string& relative_url,
       const std::string& content,
       const std::string& content_type,
       const net::test_server::HttpRequest& request) const {
-    const GURL absolute_url =
-        embedded_test_server()->GetURL(request.relative_url);
-    if (absolute_url != url)
+    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>());
     http_response->set_code(net::HTTP_OK);
     http_response->set_content(content);
     http_response->set_content_type(content_type);
     return std::move(http_response);
   }
 
   std::unique_ptr<net::test_server::HttpResponse> CustomRequestHandler(
-      const GURL& url,
+      const std::string& relative_url,
       const std::string& response,
       const net::test_server::HttpRequest& request) const {
-    const GURL absolute_url =
-        embedded_test_server()->GetURL(request.relative_url);
-    if (absolute_url != url)
+    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>();
+    return base::MakeUnique<CustomResponse>(response);
+  }
 
-    return base::MakeUnique<CustomResponse>(response);
+  std::unique_ptr<net::test_server::HttpResponse> KeepSearchRedirectHandler(
+      const std::string& relative_url,
+      const std::string& redirect_location,
+      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> response(
+        new net::test_server::BasicHttpResponse());
+    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);
   }
 
   std::vector<std::string> request_log_;
 };
 
 const char ServiceWorkerNavigationPreloadTest::kPreloadResponseTestScript[] =
@@ skipping 44 matching lines @@
 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 GURL page_url = embedded_test_server()->GetURL(kPageUrl);
   const GURL worker_url = embedded_test_server()->GetURL(kWorkerUrl);
-  RegisterStaticFile(page_url, kPage, "text/html");
-  RegisterStaticFile(worker_url, kScript, "text/javascript");
+  RegisterStaticFile(kPageUrl, kPage, "text/html");
+  RegisterStaticFile(kWorkerUrl, kScript, "text/javascript");
 
   SetupForNavigationPreloadTest(page_url, worker_url,
                                 true /* enable_navigation_preload */);
 
   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());
 
@@ skipping 14 matching lines @@
       "    if (!event.navigationPreload) {\n"
       "      event.respondWith(\n"
       "          new Response('<title>ERROR</title>',"
       "                       {headers: [['content-type', 'text/html']]}));\n"
       "      return;\n"
       "    }\n"
       "    event.respondWith(event.navigationPreload);\n"
       "  });";
   const GURL page_url = embedded_test_server()->GetURL(kPageUrl);
   const GURL worker_url = embedded_test_server()->GetURL(kWorkerUrl);
-  RegisterStaticFile(page_url, kPage, "text/html");
-  RegisterStaticFile(worker_url, kScript, "text/javascript");
+  RegisterStaticFile(kPageUrl, kPage, "text/html");
+  RegisterStaticFile(kWorkerUrl, kScript, "text/javascript");
 
   SetupForNavigationPreloadTest(page_url, worker_url,
                                 true /* enable_navigation_preload */);
 
   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());
@@ skipping 14 matching lines @@
       "    event.respondWith(\n"
       "        event.navigationPreload\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(page_url, kPage, "text/html");
-  RegisterStaticFile(worker_url, kScript, "text/javascript");
+  RegisterStaticFile(kPageUrl, kPage, "text/html");
+  RegisterStaticFile(kWorkerUrl, kScript, "text/javascript");
 
   SetupForNavigationPreloadTest(page_url, worker_url,
                                 true /* enable_navigation_preload */);
 
   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());
 
@@ skipping 35 matching lines @@
       "            '</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 GURL page_url = embedded_test_server()->GetURL(kPageUrl);
   const GURL worker_url = embedded_test_server()->GetURL(kWorkerUrl);
-  RegisterStaticFile(page_url, kPage, "text/html");
-  RegisterStaticFile(worker_url, kScript, "text/javascript");
+  RegisterStaticFile(kPageUrl, kPage, "text/html");
+  RegisterStaticFile(kWorkerUrl, kScript, "text/javascript");
 
   SetupForNavigationPreloadTest(page_url, worker_url,
                                 true /* enable_navigation_preload */);
 
   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(worker_url, kPreloadResponseTestScript, "text/javascript");
+  RegisterStaticFile(kWorkerUrl, kPreloadResponseTestScript, "text/javascript");
 
   SetupForNavigationPreloadTest(page_url, worker_url,
                                 true /* enable_navigation_preload */);
 
   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(page_url, kPage, "text/html");
-  RegisterStaticFile(worker_url, kPreloadResponseTestScript, "text/javascript");
+  RegisterStaticFile(kPageUrl, kPage, "text/html");
+  RegisterStaticFile(kWorkerUrl, kPreloadResponseTestScript, "text/javascript");
 
   SetupForNavigationPreloadTest(page_url, worker_url,
                                 true /* enable_navigation_preload */);
 
   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());
@@ skipping 14 matching lines @@
   EXPECT_TRUE(CheckHeader(*dict, "content-length",
                           base::IntToString(sizeof(kPage) - 1)));
 }
 
 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(page_url, kPage, "text/html");
-  RegisterStaticFile(worker_url, kPreloadResponseTestScript, "text/javascript");
+  RegisterStaticFile(kPageUrl, kPage, "text/html");
+  RegisterStaticFile(kWorkerUrl, kPreloadResponseTestScript, "text/javascript");
 
   SetupForNavigationPreloadTest(page_url, worker_url,
                                 false /* enable_navigation_preload */);
 
   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());
@@ skipping 14 matching lines @@
       "Content-Length: 32\r\n"
       "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(page_url, kPageResponse);
-  RegisterStaticFile(worker_url, kPreloadResponseTestScript, "text/javascript");
+  RegisterCustomResponse(kPageUrl, kPageResponse);
+  RegisterStaticFile(kWorkerUrl, kPreloadResponseTestScript, "text/javascript");
 
   SetupForNavigationPreloadTest(page_url, worker_url,
                                 true /* enable_navigation_preload */);
 
   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());
@@ skipping 26 matching lines @@
   const char kPageResponse[] =
       "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(page_url, kPageResponse);
-  RegisterStaticFile(worker_url, kPreloadResponseTestScript, "text/javascript");
-  RegisterStaticFile(redirecred_page_url, kRedirectedPage, "text/html");
+  RegisterCustomResponse(kPageUrl, kPageResponse);
+  RegisterStaticFile(kWorkerUrl, kPreloadResponseTestScript, "text/javascript");
+  RegisterStaticFile(kRedirectedPageUrl, kRedirectedPage, "text/html");
 
   SetupForNavigationPreloadTest(page_url, worker_url,
                                 true /* enable_navigation_preload */);
 
   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());
 }
 

[falken, 2016/11/02 14:15:29]

This seems sufficiently complex that some comments would be useful.

// "Tests responding with the navigation preload response when the navigation
occurred after a redirect."

[horo, 2016/11/03 02:30:43]

Done.

+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[] =
+      "self.addEventListener('fetch', event => {\n"
+      "    if (event.request.url.indexOf('navigation_preload.html') == -1)\n"
+      "      return; // For in scope redirection.\n"
+      "    event.respondWith(event.navigationPreload);\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");
+
+  const char kRedirectPageUrl[] = "/redirect";
+  const char kInScopeRedirectPageUrl[] = "/service_worker/redirect";

[falken, 2016/11/02 14:15:29]

// Register redirects to the target URL. The service worker responds to the
target URL with the navigation preload response.

[horo, 2016/11/03 02:30:43]

Done.

+  RegisterKeepSearchRedirect(kRedirectPageUrl, page_url.spec());
+  RegisterKeepSearchRedirect(kInScopeRedirectPageUrl, page_url.spec());
+
+  SetupForNavigationPreloadTest(
+      embedded_test_server()->GetURL("/service_worker/"), worker_url,
+      true /* enable_navigation_preload */);
+
+  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");
+

[falken, 2016/11/02 14:15:28]

// 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 target URL.

[horo, 2016/11/03 02:30:43]

Done.

+  TitleWatcher title_watcher1(shell()->web_contents(),
+                              base::ASCIIToUTF16("?1"));
+  NavigateToURL(shell(), redirect_page_url);
+  EXPECT_EQ(1, GetRequestCount(kPageUrl + "?1"));
+

[falken, 2016/11/02 14:15:28]

// Navigate to a same-origin, in-scope URL that redirects to the target URL. The
navigation preload request should be the single request to the target URL.

[horo, 2016/11/03 02:30:43]

Done.

+  TitleWatcher title_watcher2(shell()->web_contents(),
+                              base::ASCIIToUTF16("?2"));
+  NavigateToURL(shell(), in_scope_redirect_page_url);
+  EXPECT_EQ(1, GetRequestCount(kPageUrl + "?2"));
+

[falken, 2016/11/02 14:15:29]

// Navigate to a cross-origin URL that redirects to the target URL. The
navigation preload request should be the single request to the target URL.

[horo, 2016/11/03 02:30:43]

Done.

+  TitleWatcher title_watcher3(shell()->web_contents(),
+                              base::ASCIIToUTF16("?3"));
+  NavigateToURL(shell(), cross_origin_redirect_page_url);
+  EXPECT_EQ(1, GetRequestCount(kPageUrl + "?3"));
+}
+
 // Flaky on Win/Mac: http://crbug.com/533631
 #if defined(OS_WIN) || defined(OS_MACOSX)
 #define MAYBE_ResponseFromHTTPSServiceWorkerIsMarkedAsSecure DISABLED_ResponseFromHTTPSServiceWorkerIsMarkedAsSecure
 #else
 #define MAYBE_ResponseFromHTTPSServiceWorkerIsMarkedAsSecure ResponseFromHTTPSServiceWorkerIsMarkedAsSecure
 #endif
 IN_PROC_BROWSER_TEST_P(ServiceWorkerBrowserTest,
                        MAYBE_ResponseFromHTTPSServiceWorkerIsMarkedAsSecure) {
   const char kPageUrl[] = "/service_worker/fetch_event_blob.html";
   const char kWorkerUrl[] = "/service_worker/fetch_event_blob.js";
@@ skipping 698 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