[Not for review] provide more specific error message of navigation preload redirect

content/renderer/service_worker/service_worker_context_client.cc

 // Copyright 2015 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 "content/renderer/service_worker/service_worker_context_client.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/lazy_instance.h"
@@ skipping 262 matching lines @@
     response_->setResponseType(blink::WebServiceWorkerResponseTypeBasic);
     size_t iter = 0;
     std::string header_name;
     std::string header_value;
     while (response_head.headers->EnumerateHeaderLines(&iter, &header_name,
                                                        &header_value)) {
       response_->appendHeader(blink::WebString::fromUTF8(header_name),
                               blink::WebString::fromUTF8(header_value));
     }
     response_->setResponseTime(response_head.response_time.ToInternalValue());
-    MaybeReportToClient();
+    MaybeReportResponseToClient();
   }
 
   void OnReceiveRedirect(const net::RedirectInfo& redirect_info,
                          const ResourceResponseHead& response_head) override {
     // Cancel the request.
     url_loader_ = nullptr;
+    ReportErrorToClient(
+        "Service Worker navigation preload doesn't suport redirect.");
   }
 
   void OnDataDownloaded(int64_t data_length,
                         int64_t encoded_data_length) override {
     NOTREACHED();
   }
 
   void OnStartLoadingResponseBody(
       mojo::ScopedDataPipeConsumerHandle body) override {
     DCHECK(!body_.is_valid());
     body_ = std::move(body);
-    MaybeReportToClient();
+    MaybeReportResponseToClient();
   }
 
   void OnComplete(const ResourceRequestCompletionStatus& status) override {
     // We don't report to |client| if OnStartLoadingResponseBody() has already
     // called OnNavigationPreloadResponse().
     if (result_reported_)
       return;
     DCHECK_NE(0, status.error_code);
-    ServiceWorkerContextClient* client =
-        ServiceWorkerContextClient::ThreadSpecificInstance();
-    if (!client)
-      return;
-    client->OnNavigationPreloadError(
-        fetch_event_id_,
-        base::MakeUnique<blink::WebServiceWorkerError>(
-            blink::WebServiceWorkerError::ErrorTypeNetwork,
-            blink::WebString::fromUTF8(
-                "Service Worker navigation preload network error.")));
-    result_reported_ = true;
+    ReportErrorToClient("Service Worker navigation preload network error.");
   }
 
  private:
-  void MaybeReportToClient() {
+  void MaybeReportResponseToClient() {
     DCHECK(!result_reported_);
     if (!response_ || !body_.is_valid())
       return;
     ServiceWorkerContextClient* client =
         ServiceWorkerContextClient::ThreadSpecificInstance();
     if (!client)
       return;
 
     client->OnNavigationPreloadResponse(
         fetch_event_id_, std::move(response_),
         base::MakeUnique<WebDataConsumerHandleImpl>(std::move(body_)));
     result_reported_ = true;
   }
 
+  void ReportErrorToClient(const char* error_message) {
+    ServiceWorkerContextClient* client =
+        ServiceWorkerContextClient::ThreadSpecificInstance();
+    if (!client)
+      return;
+    client->OnNavigationPreloadError(
+        fetch_event_id_, base::MakeUnique<blink::WebServiceWorkerError>(
+                             blink::WebServiceWorkerError::ErrorTypeNetwork,
+                             blink::WebString::fromUTF8(error_message)));
+    result_reported_ = true;
+  }
+
   const int fetch_event_id_;
   const GURL url_;
   mojom::URLLoaderPtr url_loader_;
   mojo::Binding<mojom::URLLoaderClient> binding_;
 
   std::unique_ptr<blink::WebServiceWorkerResponse> response_;
   mojo::ScopedDataPipeConsumerHandle body_;
   bool result_reported_ = false;
 };
 
@@ skipping 953 matching lines @@
 }
 
 base::WeakPtr<ServiceWorkerContextClient>
 ServiceWorkerContextClient::GetWeakPtr() {
   DCHECK(worker_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(context_);
   return context_->weak_factory.GetWeakPtr();
 }
 
 }  // namespace content