Add ServiceWorkerNavigationPreloadTest for resolving navigationPreload with null.

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 1404 matching lines @@
   ~ServiceWorkerNavigationPreloadTest() override {}
 
   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) {
+                                     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();
-
-    RunOnIOThread(base::Bind(&self::EnableNavigationPreloadOnIO,
-                             base::Unretained(this), scope));
+    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,
                           const std::string& content,
                           const std::string& content_type) {
     embedded_test_server()->RegisterRequestHandler(
         base::Bind(&self::StaticRequestHandler, base::Unretained(this), url,
@@ skipping 97 matching lines @@
 
   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.navigationPreload.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"
@@ skipping 27 matching lines @@
   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");
 
-  SetupForNavigationPreloadTest(page_url, worker_url);
+  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());
 
   // 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));
@@ skipping 14 matching lines @@
       "                       {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");
 
-  SetupForNavigationPreloadTest(page_url, worker_url);
+  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());
 
   // The page request must be sent only once, since the worker responded with
   // the navigation preload response
@@ skipping 14 matching lines @@
       "          .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");
 
-  SetupForNavigationPreloadTest(page_url, worker_url);
+  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());
 
   // The page request must be sent only once, since the worker responded with
   // "Hello world".
   EXPECT_EQ(1, GetRequestCount(kPageUrl));
@@ skipping 35 matching lines @@
       "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");
 
-  SetupForNavigationPreloadTest(page_url, worker_url);
+  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");
 
-  SetupForNavigationPreloadTest(page_url, worker_url);
+  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");
 
-  SetupForNavigationPreloadTest(page_url, worker_url);
+  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());
 
   // The page request must be sent only once, since the worker responded with
   // a generated Response.
   EXPECT_EQ(1, GetRequestCount(kPageUrl));
   std::unique_ptr<base::Value> result =
       base::JSONReader::Read(GetTextContent());
   base::DictionaryValue* dict = nullptr;
   ASSERT_TRUE(result->GetAsDictionary(&dict));
   EXPECT_EQ("basic", GetString(*dict, "type"));
   EXPECT_EQ(page_url, GURL(GetString(*dict, "url")));
   EXPECT_EQ(200, GetInt(*dict, "status"));
   EXPECT_EQ(true, GetBoolean(*dict, "ok"));
   EXPECT_EQ("OK", GetString(*dict, "statusText"));
   EXPECT_TRUE(CheckHeader(*dict, "content-type", "text/html"));
   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");
+
+  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());
+
+  // The page request must not be sent, since the worker responded with a
+  // generated Response and the navigation preload isn't enabled.
+  EXPECT_EQ(0, GetRequestCount(kPageUrl));
+  EXPECT_EQ("Resolved with null.", GetTextContent());
+}
+
 IN_PROC_BROWSER_TEST_P(ServiceWorkerNavigationPreloadTest,
                        PreloadHeadersCustom) {
   const char kPageUrl[] = "/service_worker/navigation_preload.html";
   const char kWorkerUrl[] = "/service_worker/navigation_preload.js";
   const char kPageResponse[] =
       "HTTP/1.1 201 HELLOWORLD\r\n"
       "Connection: close\r\n"
       "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");
 
-  SetupForNavigationPreloadTest(page_url, worker_url);
+  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());
 
   // The page request must be sent only once, since the worker responded with
   // a generated Response.
@@ skipping 27 matching lines @@
       "\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");
 
-  SetupForNavigationPreloadTest(page_url, worker_url);
+  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));
@@ skipping 716 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