ServiceWorker: Send state change events via SWProviderHost

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/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/message_port_message_filter.h"
@@ skipping 197 matching lines @@
   if (channel_ready_) {
     BrowserMessageFilter::Send(message);
     // Don't bother passing through Send()'s result: it's not reliable.
     return true;
   }
 
   pending_messages_.push_back(message);
   return true;
 }
 
+void ServiceWorkerDispatcherHost::RegisterServiceWorkerHandle(
+    scoped_ptr<ServiceWorkerHandle> handle) {
+  int handle_id = handle->handle_id();
+  handles_.AddWithID(handle.release(), handle_id);
+}
+
+void ServiceWorkerDispatcherHost::RegisterServiceWorkerRegistrationHandle(
+    scoped_ptr<ServiceWorkerRegistrationHandle> handle) {
+  int handle_id = handle->handle_id();
+  registration_handles_.AddWithID(handle.release(), handle_id);
+}
+
 ServiceWorkerRegistrationHandle*
 ServiceWorkerDispatcherHost::GetOrCreateRegistrationHandle(
-    int provider_id,
+    base::WeakPtr<ServiceWorkerProviderHost> provider_host,
     ServiceWorkerRegistration* registration) {
+  DCHECK(provider_host);
   ServiceWorkerRegistrationHandle* handle =
-      FindRegistrationHandle(provider_id, registration->id());
+      FindRegistrationHandle(provider_host->provider_id(), registration->id());
   if (handle) {
     handle->IncrementRefCount();
     return handle;
   }
 
   scoped_ptr<ServiceWorkerRegistrationHandle> new_handle(
       new ServiceWorkerRegistrationHandle(
-          GetContext()->AsWeakPtr(), this, provider_id, registration));
+          GetContext()->AsWeakPtr(), provider_host, registration));
   handle = new_handle.get();
   RegisterServiceWorkerRegistrationHandle(new_handle.Pass());
   return handle;
 }
 
-ServiceWorkerObjectInfo
-ServiceWorkerDispatcherHost::CreateAndRegisterServiceWorkerHandle(
-    ServiceWorkerVersion* version) {
-  ServiceWorkerObjectInfo info;
-  if (GetContext() && version) {
-    scoped_ptr<ServiceWorkerHandle> handle =
-        ServiceWorkerHandle::Create(GetContext()->AsWeakPtr(), this, version);
-    info = handle->GetObjectInfo();
-    RegisterServiceWorkerHandle(handle.Pass());
-  }
-  return info;
-}
-
 void ServiceWorkerDispatcherHost::OnRegisterServiceWorker(
     int thread_id,
     int request_id,
     int provider_id,
     const GURL& pattern,
     const GURL& script_url) {
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerDispatcherHost::OnRegisterServiceWorker");
   if (!GetContext()) {
     Send(new ServiceWorkerMsg_ServiceWorkerRegistrationError(
@@ skipping 305 matching lines @@
     DCHECK(handle);
     if (handle->provider_id() == provider_id && handle->registration() &&
         handle->registration()->id() == registration_id) {
       return handle;
     }
   }
   return NULL;
 }
 
 void ServiceWorkerDispatcherHost::GetRegistrationObjectInfoAndVersionAttributes(
-    int provider_id,
+    base::WeakPtr<ServiceWorkerProviderHost> provider_host,
     ServiceWorkerRegistration* registration,
     ServiceWorkerRegistrationObjectInfo* info,
     ServiceWorkerVersionAttributes* attrs) {
   ServiceWorkerRegistrationHandle* handle =
-    GetOrCreateRegistrationHandle(provider_id, registration);
+    GetOrCreateRegistrationHandle(provider_host, registration);
   *info = handle->GetObjectInfo();
 
-  attrs->installing = CreateAndRegisterServiceWorkerHandle(
-      registration->installing_version());
-  attrs->waiting = CreateAndRegisterServiceWorkerHandle(
-      registration->waiting_version());
-  attrs->active = CreateAndRegisterServiceWorkerHandle(
-      registration->active_version());
+  attrs->installing =
+      provider_host->CreateAndRegisterServiceWorkerHandle(
+          registration->installing_version());
+  attrs->waiting =
+      provider_host->CreateAndRegisterServiceWorkerHandle(
+          registration->waiting_version());
+  attrs->active =
+      provider_host->CreateAndRegisterServiceWorkerHandle(
+          registration->active_version());
 }
 
 void ServiceWorkerDispatcherHost::RegistrationComplete(
     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 (!provider_host->IsContextAlive()) {
+    Send(new ServiceWorkerMsg_ServiceWorkerRegistrationError(
+        thread_id, request_id, WebServiceWorkerError::ErrorTypeAbort,
+        base::ASCIIToUTF16(kServiceWorkerRegisterErrorPrefix) +
+            base::ASCIIToUTF16(kShutdownErrorMessage)));

[kinuko, 2015/01/21 10:11:00]

Why do you add this error message? (It doesn't look really related to this
change, and when provider host's gone the receiver document's probably not there
either?)

[nhiroki, 2015/01/22 03:34:14]

|provider_host->IsContextAlive()| may return false due to
|SWContextWrapper::DeleteAndStartOver()|, that is, transient system shutdown. In
this case, |provider_host| (receiver document) is still valid but the associated
context is not, so the provider_host should not work with it anymore. This is
the reason why I added the error message here.

Now I'm wondering if we can just ignore the case because the registration itself
was successfully completed at this point. But in this case an empty registration
info will be created based on the invalid context at line 627 and will be
sent... hmmm...
This case just return without sending a message at line 606.

[nhiroki, 2015/01/22 04:12:50]

If |DeleteAndStartOver()| happens between OnRegisterServiceWorker() and
RegistrationCompeltion(), probably |status| might not be OK and handled by line
616. So we could skip the IsContextAlive() check and don't take care of the
empty registration info case I mentioned.

Okay, I'll remove the check and the message.

[nhiroki, 2015/01/22 04:33:42]

Done.

+    return;
+  }
+
   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_id, registration, &info, &attrs);
+      provider_host->AsWeakPtr(), registration, &info, &attrs);
 
   Send(new ServiceWorkerMsg_ServiceWorkerRegistered(
       thread_id, request_id, info, attrs));
   TRACE_EVENT_ASYNC_END1("ServiceWorker",
                          "ServiceWorkerDispatcherHost::RegisterServiceWorker",
                          request_id,
                          "Registration ID",
                          registration_id);
 }
 
@@ skipping 201 matching lines @@
   TRACE_EVENT_ASYNC_END1("ServiceWorker",
                          "ServiceWorkerDispatcherHost::GetRegistration",
                          request_id,
                          "Registration ID",
                          registration.get() ? registration->id()
                              : kInvalidServiceWorkerRegistrationId);
 
   if (!GetContext())
     return;
 
+  ServiceWorkerProviderHost* provider_host =
+      GetContext()->GetProviderHost(render_process_id_, provider_id);
+  if (!provider_host)
+    return;  // The provider has already been destroyed.
+  if (!provider_host->IsContextAlive()) {
+    Send(new ServiceWorkerMsg_ServiceWorkerGetRegistrationError(
+        thread_id, request_id, blink::WebServiceWorkerError::ErrorTypeAbort,
+        base::ASCIIToUTF16(kServiceWorkerGetRegistrationErrorPrefix) +
+            base::ASCIIToUTF16(kShutdownErrorMessage)));
+    return;
+  }
+
   if (status != SERVICE_WORKER_OK && status != SERVICE_WORKER_ERROR_NOT_FOUND) {
     SendGetRegistrationError(thread_id, request_id, status);
     return;
   }
 
   ServiceWorkerRegistrationObjectInfo info;
   ServiceWorkerVersionAttributes attrs;
   if (status == SERVICE_WORKER_OK) {
     DCHECK(registration.get());
     if (!registration->is_uninstalling()) {
       GetRegistrationObjectInfoAndVersionAttributes(
-          provider_id, registration.get(), &info, &attrs);
+          provider_host->AsWeakPtr(), registration.get(), &info, &attrs);
     }
   }
 
   Send(new ServiceWorkerMsg_DidGetRegistration(
       thread_id, request_id, info, attrs));
 }
 
 void ServiceWorkerDispatcherHost::SendRegistrationError(
     int thread_id,
     int request_id,
@@ skipping 44 matching lines @@
 void ServiceWorkerDispatcherHost::OnTerminateWorker(int handle_id) {
   ServiceWorkerHandle* handle = handles_.Lookup(handle_id);
   if (!handle) {
     BadMessageReceived();
     return;
   }
   handle->version()->StopWorker(
       base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
 }
 
-void ServiceWorkerDispatcherHost::RegisterServiceWorkerHandle(
-    scoped_ptr<ServiceWorkerHandle> handle) {
-  int handle_id = handle->handle_id();
-  handles_.AddWithID(handle.release(), handle_id);
-}
-
-void ServiceWorkerDispatcherHost::RegisterServiceWorkerRegistrationHandle(
-    scoped_ptr<ServiceWorkerRegistrationHandle> handle) {
-  int handle_id = handle->handle_id();
-  registration_handles_.AddWithID(handle.release(), handle_id);
-}
-
 }  // namespace content