ServiceWorker: Implement ServiceWorkerRegistration.update() (2)

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 50 matching lines @@
                               const GURL& script_url) {
   DCHECK(document_url.is_valid());
   DCHECK(pattern.is_valid());
   DCHECK(script_url.is_valid());
   return AllOriginsMatch(document_url, pattern, script_url) &&
          OriginCanAccessServiceWorkers(document_url) &&
          OriginCanAccessServiceWorkers(pattern) &&
          OriginCanAccessServiceWorkers(script_url);
 }
 
+bool CanUpdateServiceWorker(const GURL& document_url, const GURL& pattern) {
+  DCHECK(document_url.is_valid());
+  DCHECK(pattern.is_valid());
+  return document_url.GetOrigin() == pattern.GetOrigin() &&
+         OriginCanAccessServiceWorkers(document_url) &&
+         OriginCanAccessServiceWorkers(pattern);
+}
+
 bool CanUnregisterServiceWorker(const GURL& document_url,
                                 const GURL& pattern) {
   DCHECK(document_url.is_valid());
   DCHECK(pattern.is_valid());
   return document_url.GetOrigin() == pattern.GetOrigin() &&
          OriginCanAccessServiceWorkers(document_url) &&
          OriginCanAccessServiceWorkers(pattern);
 }
 
 bool CanGetRegistration(const GURL& document_url,
@@ skipping 70 matching lines @@
 void ServiceWorkerDispatcherHost::OnDestruct() const {
   BrowserThread::DeleteOnIOThread::Destruct(this);
 }
 
 bool ServiceWorkerDispatcherHost::OnMessageReceived(
     const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ServiceWorkerDispatcherHost, message)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_RegisterServiceWorker,
                         OnRegisterServiceWorker)
+    IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_UpdateServiceWorker,
+                        OnUpdateServiceWorker)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_UnregisterServiceWorker,
                         OnUnregisterServiceWorker)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_GetRegistration,
                         OnGetRegistration)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_GetRegistrationForReady,
                         OnGetRegistrationForReady)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_ProviderCreated,
                         OnProviderCreated)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_ProviderDestroyed,
                         OnProviderDestroyed)
@@ skipping 180 matching lines @@
       pattern,
       script_url,
       provider_host,
       base::Bind(&ServiceWorkerDispatcherHost::RegistrationComplete,
                  this,
                  thread_id,
                  provider_id,
                  request_id));
 }
 
+void ServiceWorkerDispatcherHost::OnUpdateServiceWorker(int provider_id,
+                                                        const GURL& pattern) {
+  TRACE_EVENT0("ServiceWorker",
+               "ServiceWorkerDispatcherHost::OnUpdateServiceWorker");
+  if (!GetContext())
+    return;
+  if (!pattern.is_valid()) {
+    bad_message::ReceivedBadMessage(this, bad_message::SWDH_UPDATE_BAD_URL);
+    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())
+    return;
+
+  // TODO(ksakamoto): This check can be removed once crbug.com/439697 is fixed.
+  if (provider_host->document_url().is_empty())
+    return;
+
+  if (!CanUpdateServiceWorker(provider_host->document_url(), pattern)) {
+    bad_message::ReceivedBadMessage(this, bad_message::SWDH_UPDATE_CANNOT);
+    return;
+  }
+
+  if (!GetContentClient()->browser()->AllowServiceWorker(
+          pattern, provider_host->topmost_frame_url(), resource_context_,
+          render_process_id_, provider_host->frame_id())) {
+    return;
+  }
+
+  GetContext()->storage()->FindRegistrationForPattern(
+      pattern,
+      base::Bind(&ServiceWorkerDispatcherHost::DidFindRegistrationForUpdate,
+                 this));
+}
+
 void ServiceWorkerDispatcherHost::OnUnregisterServiceWorker(
     int thread_id,
     int request_id,
     int provider_id,
     const GURL& pattern) {
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerDispatcherHost::OnUnregisterServiceWorker");
   if (!GetContext()) {
     Send(new ServiceWorkerMsg_ServiceWorkerUnregistrationError(
         thread_id,
@@ skipping 270 matching lines @@
 
   ServiceWorkerRegistrationObjectInfo info;
   ServiceWorkerVersionAttributes attrs;
   GetRegistrationObjectInfoAndVersionAttributes(
       provider_host->AsWeakPtr(), registration, &info, &attrs);
 
   Send(new ServiceWorkerMsg_AssociateRegistrationWithServiceWorker(
       kDocumentMainThreadId, provider_id, info, attrs));
 }
 
+void ServiceWorkerDispatcherHost::DidFindRegistrationForUpdate(
+    ServiceWorkerStatusCode status,
+    const scoped_refptr<ServiceWorkerRegistration>& registration) {
+  if (status != SERVICE_WORKER_OK)
+    return;
+  if (!GetContext())
+    return;
+  if (!registration->GetNewestVersion()) {
+    // This can happen if update() is called during the script evaluation. Abort

[falken, 2015/06/10 04:04:40]

nit: during initial script evaluation

[nhiroki, 2015/06/10 06:36:32]

Done.

+    // the following steps according to the spec.
+    return;
+  }
+  GetContext()->UpdateServiceWorker(registration.get(),
+                                    false /* force_bypass_cache */);

[falken, 2015/06/10 04:08:48]

Ah this should be true, as per spec's non-normative note: "update() pings the
server for an updated version of this script without consulting caches. This is
conceptually the same operation that UA does maximum once per every 24 hours."

It'd be nice to have test coverage for busting the cache on update() too.

[nhiroki, 2015/06/10 06:36:32]

Good catch! Fixed.
serviceworker/update.html to be added by the CL(3) will cover the case.

+}
+
 ServiceWorkerRegistrationHandle*
 ServiceWorkerDispatcherHost::FindRegistrationHandle(int provider_id,
                                                     int64 registration_id) {
   for (IDMap<ServiceWorkerRegistrationHandle, IDMapOwnPointer>::iterator
            iter(&registration_handles_);
        !iter.IsAtEnd();
        iter.Advance()) {
     ServiceWorkerRegistrationHandle* handle = iter.GetCurrentValue();
     DCHECK(handle);
     DCHECK(handle->registration());
@@ skipping 387 matching lines @@
   if (!handle) {
     bad_message::ReceivedBadMessage(this,
                                     bad_message::SWDH_TERMINATE_BAD_HANDLE);
     return;
   }
   handle->version()->StopWorker(
       base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
 }
 
 }  // namespace content