service worker: Clarify the navigation preload network error message.

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 397 matching lines @@
   net::HttpResponseInfo info;
   const char data[] =
       "HTTP/1.1 200 OK\0"
       "Content-Type: application/javascript\0"
       "\0";
   info.headers =
       new net::HttpResponseHeaders(std::string(data, arraysize(data)));
   return info;
 }
 
+const std::string kNavigationPreloadAbortError =
+    "The service worker navigation preload request was cancelled before "
+    "'preloadResponse' settled. If you intend to use 'preloadResponse', use "
+    "waitUntil() or respondWith() to wait for the promise to settle.";
+const std::string kNavigationPreloadNetworkError =
+    "The service worker navigation preload request failed with a network "
+    "error.";
+
 }  // namespace
 
 class ServiceWorkerBrowserTest : public ContentBrowserTest {
  protected:
   using self = ServiceWorkerBrowserTest;
 
   void SetUpOnMainThread() override {
     ASSERT_TRUE(embedded_test_server()->InitializeAndListen());
     StoragePartition* partition = BrowserContext::GetDefaultStoragePartition(
         shell()->web_contents()->GetBrowserContext());
@@ skipping 75 matching lines @@
     if (!quit_.is_null() && messages_.size() == expected_message_count_)
       quit_.Run();
   }
 
   // These parameters must be accessed on the UI thread.
   std::vector<base::string16> messages_;
   size_t expected_message_count_ = 0;
   base::Closure quit_;
 };
 
+// Listens to console messages on ServiceWorkerContextWrapper.
+class ConsoleMessageContextObserver
+    : public ServiceWorkerContextObserver,
+      public base::RefCountedThreadSafe<ConsoleMessageContextObserver> {
+ public:
+  explicit ConsoleMessageContextObserver(ServiceWorkerContextWrapper* context)
+      : context_(context) {}
+  void Init() { context_->AddObserver(this); }
+
+  // ServiceWorkerContextObserver overrides.
+  void OnReportConsoleMessage(int64_t version_id,
+                              int process_id,
+                              int thread_id,
+                              const ConsoleMessage& console_message) override {
+    messages_.push_back(console_message.message);
+    if (messages_.size() == expected_message_count_) {
+      run_loop_.Quit();
+    }
+  }
+
+  void WaitForConsoleMessages(size_t expected_message_count) {
+    if (messages_.size() >= expected_message_count) {
+      context_->RemoveObserver(this);
+      return;
+    }
+
+    expected_message_count_ = expected_message_count;
+    run_loop_.Run();
+    ASSERT_EQ(messages_.size(), expected_message_count);
+    context_->RemoveObserver(this);
+  }
+
+  const std::vector<base::string16>& messages() const { return messages_; }
+
+ private:
+  friend class base::RefCountedThreadSafe<ConsoleMessageContextObserver>;
+  ~ConsoleMessageContextObserver() override {}
+
+  std::vector<base::string16> messages_;
+  size_t expected_message_count_ = 0;
+  base::RunLoop run_loop_;
+  ServiceWorkerContextWrapper* context_;
+
+  DISALLOW_COPY_AND_ASSIGN(ConsoleMessageContextObserver);
+};
+
 class ServiceWorkerVersionBrowserTest : public ServiceWorkerBrowserTest {
  public:
   using self = ServiceWorkerVersionBrowserTest;
 
   ~ServiceWorkerVersionBrowserTest() override {}
 
   void TearDownOnIOThread() override {
     registration_ = NULL;
     version_ = NULL;
   }
@@ skipping 1366 matching lines @@
   RegisterStaticFile(
       kWorkerUrl, kEnableNavigationPreloadScript + kPreloadResponseTestScript,
       "text/javascript");
 
   RegisterMonitorRequestHandler();
   StartServerAndNavigateToSetup();
   SetupForNavigationPreloadTest(page_url, worker_url);
 
   EXPECT_TRUE(embedded_test_server()->ShutdownAndWaitUntilComplete());
 
+  scoped_refptr<ConsoleMessageContextObserver> console_observer =
+      new ConsoleMessageContextObserver(wrapper());
+  console_observer->Init();
+
   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.",
+  EXPECT_EQ("NetworkError: " + kNavigationPreloadNetworkError,
             GetTextContent());
+
+  console_observer->WaitForConsoleMessages(1);
+  const base::string16 expected =
+      base::ASCIIToUTF16("net::ERR_CONNECTION_REFUSED");
+  std::vector<base::string16> messages = console_observer->messages();
+  EXPECT_NE(base::string16::npos, messages[0].find(expected));
 }
 
 IN_PROC_BROWSER_TEST_F(ServiceWorkerNavigationPreloadTest,
                        CanceledByInterceptor) {
   content::ResourceDispatcherHost::Get()->RegisterInterceptor(
       kNavigationPreloadHeaderName, "",
       base::Bind(&CancellingInterceptorCallback));
 
   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, kEnableNavigationPreloadScript + kPreloadResponseTestScript,
       "text/javascript");
 
-  EXPECT_EQ("NetworkError: Service Worker navigation preload network error.",
+  EXPECT_EQ("NetworkError: " + kNavigationPreloadAbortError,
             LoadNavigationPreloadTestPage(page_url, worker_url, "REJECTED"));
 }
 
 IN_PROC_BROWSER_TEST_F(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);
@@ skipping 96 matching lines @@
       "\r\n";
   const char kRedirectedPage[] = "<title>ERROR</title>Redirected page.";
   const GURL page_url = embedded_test_server()->GetURL(kPageUrl);
   const GURL worker_url = embedded_test_server()->GetURL(kWorkerUrl);
   RegisterCustomResponse(kPageUrl, kPageResponse);
   RegisterStaticFile(
       kWorkerUrl, kEnableNavigationPreloadScript + kPreloadResponseTestScript,
       "text/javascript");
   RegisterStaticFile(kRedirectedPageUrl1, kRedirectedPage, "text/html");
 
+  scoped_refptr<ConsoleMessageContextObserver> console_observer =
+      new ConsoleMessageContextObserver(wrapper());
+  console_observer->Init();
+
   // According to the spec, multiple Location headers is not an error. So the
   // preloadResponse must be resolved with an opaque redirect response.
   // But Chrome treats multiple Location headers as an error (crbug.com/98895).
-  EXPECT_EQ("NetworkError: Service Worker navigation preload network error.",
+  EXPECT_EQ("NetworkError: " + kNavigationPreloadNetworkError,
             LoadNavigationPreloadTestPage(page_url, worker_url, "REJECTED"));
 
+  console_observer->WaitForConsoleMessages(1);
+  const base::string16 expected =
+      base::ASCIIToUTF16("ERR_RESPONSE_HEADERS_MULTIPLE_LOCATION");
+  std::vector<base::string16> messages = console_observer->messages();
+  EXPECT_NE(base::string16::npos, messages[0].find(expected));
+
   // 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(kRedirectedPageUrl1));
   EXPECT_EQ(0, GetRequestCount(kRedirectedPageUrl2));
 }
 
 IN_PROC_BROWSER_TEST_F(ServiceWorkerNavigationPreloadTest,
                        InvalidRedirect_InvalidLocation) {
   const char kPageUrl[] = "/service_worker/navigation_preload.html";
   const char kWorkerUrl[] = "/service_worker/navigation_preload.js";
   const char kPageResponse[] =
       "HTTP/1.1 302 Found\r\n"
       "Connection: close\r\n"
       "Location: http://\r\n"
       "\r\n";
   const GURL page_url = embedded_test_server()->GetURL(kPageUrl);
   const GURL worker_url = embedded_test_server()->GetURL(kWorkerUrl);
   RegisterCustomResponse(kPageUrl, kPageResponse);
   RegisterStaticFile(
       kWorkerUrl, kEnableNavigationPreloadScript + kPreloadResponseTestScript,
       "text/javascript");
 
   // TODO(horo): According to the spec, even if the location URL is invalid, the
   // preloadResponse must be resolve with an opaque redirect response. But
   // currently Chrome handles the invalid location URL in the browser process as
   // an error. crbug.com/707185
-  EXPECT_EQ("NetworkError: Service Worker navigation preload network error.",
+  EXPECT_EQ("NetworkError: " + kNavigationPreloadAbortError,
             LoadNavigationPreloadTestPage(page_url, worker_url, "REJECTED"));
 
   // The page request must be sent only once, since the worker responded with
   // a generated Response.
   EXPECT_EQ(1, GetRequestCount(kPageUrl));
 }
 
 // Tests responding with the navigation preload response when the navigation
 // occurred after a redirect.
 IN_PROC_BROWSER_TEST_F(ServiceWorkerNavigationPreloadTest,
@@ skipping 850 matching lines @@
   // effect in CanSuspendRenderer().
   shell()->web_contents()->WasHidden();
   EXPECT_TRUE(rph->IsProcessBackgrounded());
 
   // The process which has service worker thread shouldn't be suspended.
   EXPECT_FALSE(memory_coordinator->CanSuspendRenderer(render_process_id));
 }
 #endif
 
 }  // namespace content