Service Worker: Use more specific errors when StartWorker fails

content/browser/service_worker/service_worker_version.cc

 // Copyright 2013 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/browser/service_worker/service_worker_version.h"
 
 #include "base/command_line.h"
 #include "base/memory/ref_counted.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/stl_util.h"
@@ skipping 434 matching lines @@
 }
 
 void ServiceWorkerVersion::StartWorker(const StatusCallback& callback) {
   StartWorker(false, callback);
 }
 
 void ServiceWorkerVersion::StartWorker(
     bool pause_after_download,
     const StatusCallback& callback) {
   if (!context_) {
-    RunSoon(base::Bind(callback, SERVICE_WORKER_ERROR_START_WORKER_FAILED));
+    RunSoon(base::Bind(callback, SERVICE_WORKER_ERROR_ABORT));
     return;
   }
 
   // Ensure the live registration during starting worker so that the worker can
   // get associated with it in SWDispatcherHost::OnSetHostedVersionId().
   context_->storage()->FindRegistrationForId(
       registration_id_,
       scope_.GetOrigin(),
       base::Bind(&ServiceWorkerVersion::DidEnsureLiveRegistrationForStartWorker,
                  weak_factory_.GetWeakPtr(),
@@ skipping 469 matching lines @@
   StopTimeoutTimer();
   if (ping_state_ == PING_TIMED_OUT)
     should_restart = false;
 
   // Fire all stop callbacks.
   RunCallbacks(this, &stop_callbacks_, SERVICE_WORKER_OK);
 
   if (!should_restart) {
     // Let all start callbacks fail.
     RunCallbacks(this, &start_callbacks_,
-                 SERVICE_WORKER_ERROR_START_WORKER_FAILED);
+                 DeduceStartWorkerFailureReason(
+                     SERVICE_WORKER_ERROR_START_WORKER_FAILED));
   }
 
   // Let all message callbacks fail (this will also fire and clear all
   // callbacks for events).
   // TODO(kinuko): Consider if we want to add queue+resend mechanism here.
   RunIDMapCallbacks(&activate_callbacks_,
                     SERVICE_WORKER_ERROR_ACTIVATE_WORKER_FAILED);
   RunIDMapCallbacks(&install_callbacks_,
                     SERVICE_WORKER_ERROR_INSTALL_WORKER_FAILED);
   RunIDMapCallbacks(&fetch_callbacks_,
@@ skipping 84 matching lines @@
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_ClaimClients,
                         OnClaimClients)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_Pong, OnPongFromWorker)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void ServiceWorkerVersion::OnStartSentAndScriptEvaluated(
     ServiceWorkerStatusCode status) {
-  if (status != SERVICE_WORKER_OK)
-    RunCallbacks(this, &start_callbacks_, status);
+  if (status != SERVICE_WORKER_OK) {
+    RunCallbacks(this, &start_callbacks_,
+                 DeduceStartWorkerFailureReason(status));
+  }
 }
 
 void ServiceWorkerVersion::DispatchInstallEventAfterStartWorker(
     const StatusCallback& callback) {
   DCHECK_EQ(RUNNING, running_status())
       << "Worker stopped too soon after it was started.";
 
   int request_id = AddRequest(callback, &install_callbacks_, REQUEST_INSTALL);
   ServiceWorkerStatusCode status = embedded_worker_->SendMessage(
       ServiceWorkerMsg_InstallEvent(request_id));
@@ skipping 793 matching lines @@
   std::queue<RequestInfo> new_requests;
   while (!requests_.empty()) {
     RequestInfo info = requests_.front();
     info.time = ticks;
     new_requests.push(info);
     requests_.pop();
   }
   requests_ = new_requests;
 }
 
+ServiceWorkerStatusCode ServiceWorkerVersion::DeduceStartWorkerFailureReason(
+    ServiceWorkerStatusCode default_code) {
+  if (ping_state_ == PING_TIMED_OUT)
+    return SERVICE_WORKER_ERROR_TIMEOUT;
+
+  const net::URLRequestStatus& main_script_status =
+      script_cache_map()->main_script_status();
+  if (main_script_status.status() != net::URLRequestStatus::SUCCESS) {
+    switch (main_script_status.error()) {
+      case net::ERR_INSECURE_RESPONSE:
+      case net::ERR_UNSAFE_REDIRECT:
+        return SERVICE_WORKER_ERROR_SECURITY;
+      case net::ERR_ABORTED:
+        return SERVICE_WORKER_ERROR_ABORT;
+      default:
+        return SERVICE_WORKER_ERROR_NETWORK;
+    }
+  }
+
+  return default_code;
+}
+
 }  // namespace content