Service Worker: Improve error messages from register().

content/browser/service_worker/service_worker_register_job.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_register_job.h"
 
 #include <vector>
 
 #include "base/message_loop/message_loop.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_job_coordinator.h"
 #include "content/browser/service_worker/service_worker_registration.h"
 #include "content/browser/service_worker/service_worker_storage.h"
 #include "content/browser/service_worker/service_worker_utils.h"
+#include "content/common/service_worker/service_worker_types.h"
 #include "net/base/net_errors.h"
 
 namespace content {
 
 namespace {
 
 void RunSoon(const base::Closure& closure) {
   base::MessageLoop::current()->PostTask(FROM_HERE, closure);
 }
 
@@ skipping 39 matching lines @@
 
 void ServiceWorkerRegisterJob::AddCallback(
     const RegistrationCallback& callback,
     ServiceWorkerProviderHost* provider_host) {
   if (!is_promise_resolved_) {
     callbacks_.push_back(callback);
     if (provider_host)
       provider_host->AddScopedProcessReferenceToPattern(pattern_);
     return;
   }
-  RunSoon(base::Bind(
-      callback, promise_resolved_status_, promise_resolved_registration_));
+  RunSoon(base::Bind(callback, promise_resolved_status_,
+                     promise_resolved_status_message_,
+                     promise_resolved_registration_));
 }
 
 void ServiceWorkerRegisterJob::Start() {
   SetPhase(START);
   ServiceWorkerStorage::FindRegistrationCallback next_step;
   if (job_type_ == REGISTRATION_JOB) {
     next_step = base::Bind(
         &ServiceWorkerRegisterJob::ContinueWithRegistration,
         weak_factory_.GetWeakPtr());
   } else {
     next_step = base::Bind(
         &ServiceWorkerRegisterJob::ContinueWithUpdate,
         weak_factory_.GetWeakPtr());
   }
 
   scoped_refptr<ServiceWorkerRegistration> registration =
       context_->storage()->GetUninstallingRegistration(pattern_);
   if (registration.get())
     RunSoon(base::Bind(next_step, SERVICE_WORKER_OK, registration));
   else
     context_->storage()->FindRegistrationForPattern(pattern_, next_step);
 }
 
 void ServiceWorkerRegisterJob::Abort() {
   SetPhase(ABORT);
-  CompleteInternal(SERVICE_WORKER_ERROR_ABORT);
+  CompleteInternal(SERVICE_WORKER_ERROR_ABORT, std::string());
   // Don't have to call FinishJob() because the caller takes care of removing
   // the jobs from the queue.
 }
 
 bool ServiceWorkerRegisterJob::Equals(ServiceWorkerRegisterJobBase* job) const {
   if (job->GetType() != GetType())
     return false;
   ServiceWorkerRegisterJob* register_job =
       static_cast<ServiceWorkerRegisterJob*>(job);
   return register_job->pattern_ == pattern_ &&
          register_job->script_url_ == script_url_;
 }
 
 RegistrationJobType ServiceWorkerRegisterJob::GetType() const {
   return job_type_;
 }
 
 void ServiceWorkerRegisterJob::DoomInstallingWorker() {
   doom_installing_worker_ = true;
   if (phase_ == INSTALL)
-    Complete(SERVICE_WORKER_ERROR_INSTALL_WORKER_FAILED);
+    Complete(SERVICE_WORKER_ERROR_INSTALL_WORKER_FAILED, std::string());
 }
 
 ServiceWorkerRegisterJob::Internal::Internal() {}
 
 ServiceWorkerRegisterJob::Internal::~Internal() {}
 
 void ServiceWorkerRegisterJob::set_registration(
     const scoped_refptr<ServiceWorkerRegistration>& registration) {
   DCHECK(phase_ == START || phase_ == REGISTER) << phase_;
   DCHECK(!internal_.registration.get());
@@ skipping 133 matching lines @@
   // may be able to complete the update job right here.
 
   UpdateAndContinue();
 }
 
 // Creates a new ServiceWorkerRegistration.
 void ServiceWorkerRegisterJob::RegisterAndContinue(
     ServiceWorkerStatusCode status) {
   SetPhase(REGISTER);
   if (status != SERVICE_WORKER_OK) {
-    // Abort this registration job.
     Complete(status);
     return;
   }
 
   set_registration(new ServiceWorkerRegistration(
       pattern_, context_->storage()->NewRegistrationId(), context_));
   AssociateProviderHostsToRegistration(registration());
   UpdateAndContinue();
 }
 
@@ skipping 15 matching lines @@
 
   // "If newestWorker is not null, and scriptURL is equal to
   // newestWorker.scriptURL, then:
   // Return a promise resolved with registration."
   // We resolve only if there's an active version. If there's not,
   // then there is either no version or only a waiting version from
   // the last browser session; it makes sense to proceed with registration in
   // either case.
   DCHECK(!existing_registration->installing_version());
   if (existing_registration->active_version()) {
-    ResolvePromise(status, existing_registration.get());
+    ResolvePromise(status, std::string(), existing_registration.get());
     Complete(SERVICE_WORKER_OK);
     return;
   }
 
   // "Return the result of running the [[Update]] algorithm, or its equivalent,
   // passing registration as the argument."
   UpdateAndContinue();
 }
 
 // This function corresponds to the spec's [[Update]] algorithm.
@@ skipping 22 matching lines @@
   if (status == SERVICE_WORKER_OK) {
     InstallAndContinue();
     return;
   }
 
   // "If serviceWorker fails to start up..." then reject the promise with an
   // error and abort. When there is a main script network error, the status will
   // be updated to a more specific one.
   const net::URLRequestStatus& main_script_status =
       new_version()->script_cache_map()->main_script_status();
+  std::string message;
   if (main_script_status.status() != net::URLRequestStatus::SUCCESS) {
     switch (main_script_status.error()) {
       case net::ERR_INSECURE_RESPONSE:
       case net::ERR_UNSAFE_REDIRECT:
         status = SERVICE_WORKER_ERROR_SECURITY;
         break;
       case net::ERR_ABORTED:
         status = SERVICE_WORKER_ERROR_ABORT;
         break;
       default:
         status = SERVICE_WORKER_ERROR_NETWORK;
     }
+    message = new_version()->script_cache_map()->main_script_status_message();
+    if (message.empty())
+      message = kFetchScriptError;
   }
-  Complete(status);
+  Complete(status, message);
 }
 
 // This function corresponds to the spec's [[Install]] algorithm.
 void ServiceWorkerRegisterJob::InstallAndContinue() {
   SetPhase(INSTALL);
 
   // "Set registration.installingWorker to worker."
   DCHECK(!registration()->installing_version());
   registration()->SetInstallingVersion(new_version());
 
   // "Run the Update State algorithm passing registration's installing worker
   // and installing as the arguments."
   new_version()->SetStatus(ServiceWorkerVersion::INSTALLING);
 
   // "Resolve registrationPromise with registration."
-  ResolvePromise(SERVICE_WORKER_OK, registration());
+  ResolvePromise(SERVICE_WORKER_OK, std::string(), registration());
 
   // "Fire a simple event named updatefound..."
   registration()->NotifyUpdateFound();
 
   // "Fire an event named install..."
   new_version()->DispatchInstallEvent(
       -1,
       base::Bind(&ServiceWorkerRegisterJob::OnInstallFinished,
                  weak_factory_.GetWeakPtr()));
 
@@ skipping 48 matching lines @@
 
   // "If registration's waiting worker's skip waiting flag is set:" then
   // activate the worker immediately otherwise "wait until no service worker
   // client is using registration as their service worker registration."
   registration()->ActivateWaitingVersionWhenReady();
 
   Complete(SERVICE_WORKER_OK);
 }
 
 void ServiceWorkerRegisterJob::Complete(ServiceWorkerStatusCode status) {
-  CompleteInternal(status);
+  Complete(status, std::string());
+}
+
+void ServiceWorkerRegisterJob::Complete(ServiceWorkerStatusCode status,
+                                        const std::string& status_message) {
+  CompleteInternal(status, status_message);
   context_->job_coordinator()->FinishJob(pattern_, this);
 }
 
 void ServiceWorkerRegisterJob::CompleteInternal(
-    ServiceWorkerStatusCode status) {
+    ServiceWorkerStatusCode status,
+    const std::string& status_message) {
   SetPhase(COMPLETE);
   if (status != SERVICE_WORKER_OK) {
     if (registration()) {
       if (new_version()) {
         registration()->UnsetVersion(new_version());
         new_version()->Doom();
       }
       if (!registration()->waiting_version() &&
           !registration()->active_version()) {
         registration()->NotifyRegistrationFailed();
         context_->storage()->DeleteRegistration(
             registration()->id(),
             registration()->pattern().GetOrigin(),
             base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
       }
     }
     if (!is_promise_resolved_)
-      ResolvePromise(status, NULL);
+      ResolvePromise(status, status_message, NULL);
   }
   DCHECK(callbacks_.empty());
   if (registration()) {
     context_->storage()->NotifyDoneInstallingRegistration(
         registration(), new_version(), status);
   }
   if (new_version())
     new_version()->embedded_worker()->RemoveListener(this);
 }
 
 void ServiceWorkerRegisterJob::ResolvePromise(
     ServiceWorkerStatusCode status,
+    const std::string& status_message,
     ServiceWorkerRegistration* registration) {
   DCHECK(!is_promise_resolved_);
 
   is_promise_resolved_ = true;
   promise_resolved_status_ = status;
+  promise_resolved_status_message_ = status_message,
   promise_resolved_registration_ = registration;
   for (std::vector<RegistrationCallback>::iterator it = callbacks_.begin();
        it != callbacks_.end();
        ++it) {
-    it->Run(status, registration);
+    it->Run(status, status_message, registration);
   }
   callbacks_.clear();
 }
 
 void ServiceWorkerRegisterJob::OnPausedAfterDownload() {
   // This happens prior to OnStartWorkerFinished time.
   scoped_refptr<ServiceWorkerVersion> most_recent_version =
       registration()->waiting_version() ?
           registration()->waiting_version() :
           registration()->active_version();
@@ skipping 31 matching lines @@
     bool are_equal) {
   if (are_equal) {
     // Only bump the last check time when we've bypassed the browser cache.
     base::TimeDelta time_since_last_check =
         base::Time::Now() - registration()->last_update_check();
     if (time_since_last_check > base::TimeDelta::FromHours(24)) {
       registration()->set_last_update_check(base::Time::Now());
       context_->storage()->UpdateLastUpdateCheckTime(registration());
     }
 
-    ResolvePromise(SERVICE_WORKER_OK, registration());
+    ResolvePromise(SERVICE_WORKER_OK, std::string(), registration());
     Complete(SERVICE_WORKER_ERROR_EXISTS);
     return;
   }
 
   // Proceed with really starting the worker.
   new_version()->embedded_worker()->ResumeAfterDownload();
   new_version()->embedded_worker()->RemoveListener(this);
 }
 
 void ServiceWorkerRegisterJob::AssociateProviderHostsToRegistration(
     ServiceWorkerRegistration* registration) {
   DCHECK(registration);
   for (scoped_ptr<ServiceWorkerContextCore::ProviderHostIterator> it =
            context_->GetProviderHostIterator();
        !it->IsAtEnd(); it->Advance()) {
     ServiceWorkerProviderHost* host = it->GetProviderHost();
     if (ServiceWorkerUtils::ScopeMatches(registration->pattern(),
                                          host->document_url())) {
       if (host->CanAssociateRegistration(registration))
         host->AssociateRegistration(registration);
     }
   }
 }
 
 }  // namespace content