Service Worker: Make ServiceWorkerRegistration.update() return a promise. (Chromium 2/3)

content/browser/service_worker/service_worker_dispatcher_host.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_dispatcher_host.h"
 
 #include "base/logging.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/trace_event/trace_event.h"
@@ skipping 23 matching lines @@
 namespace content {
 
 namespace {
 
 const char kNoDocumentURLErrorMessage[] =
     "No URL is associated with the caller's document.";
 const char kShutdownErrorMessage[] =
     "The Service Worker system has shutdown.";
 const char kUserDeniedPermissionMessage[] =
     "The user denied permission to use Service Worker.";
+const char kInvalidStateErrorMessage[] = "The object is in an invalid state.";
 
 const uint32 kFilteredMessageClasses[] = {
   ServiceWorkerMsgStart,
   EmbeddedWorkerMsgStart,
 };
 
 bool AllOriginsMatch(const GURL& url_a, const GURL& url_b, const GURL& url_c) {
   return url_a.GetOrigin() == url_b.GetOrigin() &&
          url_a.GetOrigin() == url_c.GetOrigin();
 }
@@ skipping 303 matching lines @@
       pattern,
       script_url,
       provider_host,
       base::Bind(&ServiceWorkerDispatcherHost::RegistrationComplete,
                  this,
                  thread_id,
                  provider_id,
                  request_id));
 }
 
-void ServiceWorkerDispatcherHost::OnUpdateServiceWorker(int provider_id,
+void ServiceWorkerDispatcherHost::OnUpdateServiceWorker(int thread_id,
+                                                        int request_id,
+                                                        int provider_id,
                                                         int64 registration_id) {
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerDispatcherHost::OnUpdateServiceWorker");
-  if (!GetContext())
+  if (!GetContext()) {
+    Send(new ServiceWorkerMsg_ServiceWorkerUpdateError(
+        thread_id, request_id, WebServiceWorkerError::ErrorTypeAbort,
+        base::ASCIIToUTF16(kServiceWorkerUpdateErrorPrefix) +
+            base::ASCIIToUTF16(kShutdownErrorMessage)));
     return;
+  }
 
   ServiceWorkerProviderHost* provider_host =
       GetContext()->GetProviderHost(render_process_id_, provider_id);
   if (!provider_host) {
     bad_message::ReceivedBadMessage(this, bad_message::SWDH_UPDATE_NO_HOST);
     return;
   }
-  if (!provider_host->IsContextAlive())
+  if (!provider_host->IsContextAlive()) {
+    Send(new ServiceWorkerMsg_ServiceWorkerUpdateError(
+        thread_id, request_id, WebServiceWorkerError::ErrorTypeAbort,
+        base::ASCIIToUTF16(kServiceWorkerUpdateErrorPrefix) +
+            base::ASCIIToUTF16(kShutdownErrorMessage)));
     return;
+  }
 
-  // TODO(ksakamoto): This check can be removed once crbug.com/439697 is fixed.
-  if (provider_host->document_url().is_empty())
+  // TODO(jungkees): This check can be removed once crbug.com/439697 is fixed.
+  if (provider_host->document_url().is_empty()) {
+    Send(new ServiceWorkerMsg_ServiceWorkerUpdateError(
+        thread_id, request_id, WebServiceWorkerError::ErrorTypeSecurity,
+        base::ASCIIToUTF16(kServiceWorkerUpdateErrorPrefix) +
+            base::ASCIIToUTF16(kNoDocumentURLErrorMessage)));
     return;
+  }
 
   ServiceWorkerRegistration* registration =
       GetContext()->GetLiveRegistration(registration_id);
   if (!registration) {
     // |registration| must be alive because a renderer retains a registration
     // reference at this point.
     bad_message::ReceivedBadMessage(
         this, bad_message::SWDH_UPDATE_BAD_REGISTRATION_ID);
     return;
   }
 
   if (!CanUpdateServiceWorker(provider_host->document_url(),
                               registration->pattern())) {
     bad_message::ReceivedBadMessage(this, bad_message::SWDH_UPDATE_CANNOT);
     return;
   }
 
   if (!GetContentClient()->browser()->AllowServiceWorker(
           registration->pattern(), provider_host->topmost_frame_url(),
           resource_context_, render_process_id_, provider_host->frame_id())) {
+    Send(new ServiceWorkerMsg_ServiceWorkerUpdateError(
+        thread_id, request_id, WebServiceWorkerError::ErrorTypeUnknown,
+        base::ASCIIToUTF16(kServiceWorkerUpdateErrorPrefix) +
+            base::ASCIIToUTF16(kUserDeniedPermissionMessage)));
     return;
   }
 
   if (!registration->GetNewestVersion()) {
     // This can happen if update() is called during initial script evaluation.
     // Abort the following steps according to the spec.
+    Send(new ServiceWorkerMsg_ServiceWorkerUpdateError(
+        thread_id, request_id, WebServiceWorkerError::ErrorTypeState,
+        base::ASCIIToUTF16(kServiceWorkerUpdateErrorPrefix) +
+            base::ASCIIToUTF16(kInvalidStateErrorMessage)));

[nhiroki, 2015/07/31 06:49:11]

We might need to change the update() algorithm in the spec. The current spec[1]
("4. If newestWorker is null, abort these steps.") does not mention that a
promise is rejected with InvalidStateError.

[1]
https://slightlyoff.github.io/ServiceWorker/spec/service_worker/index.html#se...

[jungkees, 2015/07/31 07:09:58]

I noticed that and was gonna change this. ;-) I will address this in no time.
Thanks!

     return;
   }
 
   // The spec says, "update() pings the server for an updated version of this
   // script without consulting caches", so set |force_bypass_cache| to true.
-  GetContext()->UpdateServiceWorker(registration,
-                                    true /* force_bypass_cache */);
+  GetContext()->UpdateServiceWorker(
+      registration, true, /* force_bypass_cache */
+      provider_host, base::Bind(&ServiceWorkerDispatcherHost::UpdateComplete,
+                                this, thread_id, provider_id, request_id));
 }
 
 void ServiceWorkerDispatcherHost::OnUnregisterServiceWorker(
     int thread_id,
     int request_id,
     int provider_id,
     int64 registration_id) {
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerDispatcherHost::OnUnregisterServiceWorker");
   if (!GetContext()) {
@@ skipping 408 matching lines @@
 
   Send(new ServiceWorkerMsg_ServiceWorkerRegistered(
       thread_id, request_id, info, attrs));
   TRACE_EVENT_ASYNC_END1("ServiceWorker",
                          "ServiceWorkerDispatcherHost::RegisterServiceWorker",
                          request_id,
                          "Registration ID",
                          registration_id);
 }
 
+void ServiceWorkerDispatcherHost::UpdateComplete(
+    int thread_id,
+    int provider_id,
+    int request_id,
+    ServiceWorkerStatusCode status,
+    const std::string& status_message,
+    int64 registration_id) {
+  if (!GetContext())
+    return;
+
+  ServiceWorkerProviderHost* provider_host =
+      GetContext()->GetProviderHost(render_process_id_, provider_id);
+  if (!provider_host)
+    return;  // The provider has already been destroyed.
+
+  if (status != SERVICE_WORKER_OK) {
+    SendRegistrationError(thread_id, request_id, status, status_message);
+    return;
+  }
+
+  ServiceWorkerRegistration* registration =
+      GetContext()->GetLiveRegistration(registration_id);
+  DCHECK(registration);
+
+  ServiceWorkerRegistrationObjectInfo info;
+  ServiceWorkerVersionAttributes attrs;
+  GetRegistrationObjectInfoAndVersionAttributes(provider_host->AsWeakPtr(),
+                                                registration, &info, &attrs);
+
+  Send(new ServiceWorkerMsg_ServiceWorkerUpdated(thread_id, request_id));
+  TRACE_EVENT_ASYNC_END1("ServiceWorker",
+                         "ServiceWorkerDispatcherHost::UpdateServiceWorker",
+                         request_id, "Registration ID", registration_id);
+}
+
 void ServiceWorkerDispatcherHost::OnWorkerReadyForInspection(
     int embedded_worker_id) {
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerDispatcherHost::OnWorkerReadyForInspection");
   if (!GetContext())
     return;
   EmbeddedWorkerRegistry* registry = GetContext()->embedded_worker_registry();
   if (!registry->CanHandle(embedded_worker_id))
     return;
   registry->OnWorkerReadyForInspection(render_process_id_, embedded_worker_id);
@@ skipping 355 matching lines @@
   if (!handle) {
     bad_message::ReceivedBadMessage(this,
                                     bad_message::SWDH_TERMINATE_BAD_HANDLE);
     return;
   }
   handle->version()->StopWorker(
       base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
 }
 
 }  // namespace content