ServiceWorker: Confirm the liveness of the associated context before handling message

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/strings/utf_string_conversions.h"
 #include "content/browser/message_port_message_filter.h"
 #include "content/browser/message_port_service.h"
 #include "content/browser/service_worker/embedded_worker_registry.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
 #include "content/browser/service_worker/service_worker_handle.h"
+#include "content/browser/service_worker/service_worker_provider_host_registry.h"
 #include "content/browser/service_worker/service_worker_registration.h"
 #include "content/browser/service_worker/service_worker_utils.h"
 #include "content/common/service_worker/embedded_worker_messages.h"
 #include "content/common/service_worker/service_worker_messages.h"
 #include "ipc/ipc_message_macros.h"
 #include "third_party/WebKit/public/platform/WebServiceWorkerError.h"
 #include "url/gurl.h"
 
 using blink::WebServiceWorkerError;
 
@@ skipping 17 matching lines @@
     int render_process_id,
     MessagePortMessageFilter* message_port_message_filter)
     : BrowserMessageFilter(kFilteredMessageClasses,
                            arraysize(kFilteredMessageClasses)),
       render_process_id_(render_process_id),
       message_port_message_filter_(message_port_message_filter),
       channel_ready_(false) {
 }
 
 ServiceWorkerDispatcherHost::~ServiceWorkerDispatcherHost() {
+  GetProviderRegistry()->RemoveAllProviderHostsForProcess(render_process_id_);
   if (GetContext()) {
-    GetContext()->RemoveAllProviderHostsForProcess(render_process_id_);
     GetContext()->embedded_worker_registry()->RemoveChildProcessSender(
         render_process_id_);
   }
 }
 
 void ServiceWorkerDispatcherHost::Init(
     ServiceWorkerContextWrapper* context_wrapper) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
@@ skipping 102 matching lines @@
   // ChildProcessSecurityImpl. See http://crbug.com/311631.
   if (pattern.GetOrigin() != script_url.GetOrigin()) {
     Send(new ServiceWorkerMsg_ServiceWorkerRegistrationError(
         thread_id,
         request_id,
         WebServiceWorkerError::ErrorTypeSecurity,
         base::ASCIIToUTF16(kDomainMismatchErrorMessage)));
     return;
   }
 
-  ServiceWorkerProviderHost* provider_host = GetContext()->GetProviderHost(
-      render_process_id_, provider_id);
+  ServiceWorkerProviderHost* provider_host =
+      GetProviderRegistry()->GetProviderHost(render_process_id_, provider_id);
   if (!provider_host) {
     BadMessageReceived();
     return;
   }
+  if (!provider_host->IsAlive()) {
+    Send(new ServiceWorkerMsg_ServiceWorkerRegistrationError(
+        thread_id,
+        request_id,
+        WebServiceWorkerError::ErrorTypeDisabled,
+        base::ASCIIToUTF16(kDisabledErrorMessage)));
+    return;
+  }
 
   GetContext()->RegisterServiceWorker(
       pattern,
       script_url,
       render_process_id_,
       provider_host,
       base::Bind(&ServiceWorkerDispatcherHost::RegistrationComplete,
                  this,
                  thread_id,
                  request_id));
 }
 
 void ServiceWorkerDispatcherHost::OnUnregisterServiceWorker(
     int thread_id,
     int request_id,
     int provider_id,
     const GURL& pattern) {
   // TODO(alecflett): This check is insufficient for release. Add a
   // ServiceWorker-specific policy query in
   // ChildProcessSecurityImpl. See http://crbug.com/311631.
   if (!GetContext() || !ServiceWorkerUtils::IsFeatureEnabled()) {
     Send(new ServiceWorkerMsg_ServiceWorkerRegistrationError(
         thread_id,
         request_id,
         blink::WebServiceWorkerError::ErrorTypeDisabled,
         base::ASCIIToUTF16(kDisabledErrorMessage)));
     return;
   }
 
-  ServiceWorkerProviderHost* provider_host = GetContext()->GetProviderHost(
-      render_process_id_, provider_id);
+  ServiceWorkerProviderHost* provider_host =
+      GetProviderRegistry()->GetProviderHost(render_process_id_, provider_id);
   if (!provider_host) {
     BadMessageReceived();
     return;
   }
+  if (!provider_host->IsAlive()) {
+    Send(new ServiceWorkerMsg_ServiceWorkerRegistrationError(
+        thread_id,
+        request_id,
+        WebServiceWorkerError::ErrorTypeDisabled,
+        base::ASCIIToUTF16(kDisabledErrorMessage)));
+    return;
+  }
 
   GetContext()->UnregisterServiceWorker(
       pattern,
       base::Bind(&ServiceWorkerDispatcherHost::UnregistrationComplete,
                  this,
                  thread_id,
                  request_id));
 }
 
 void ServiceWorkerDispatcherHost::OnPostMessageToWorker(
@@ skipping 15 matching lines @@
   handle->version()->SendMessage(
       ServiceWorkerMsg_MessageToWorker(message,
                                        sent_message_port_ids,
                                        new_routing_ids),
       base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
 }
 
 void ServiceWorkerDispatcherHost::OnProviderCreated(int provider_id) {
   if (!GetContext())
     return;
-  if (GetContext()->GetProviderHost(render_process_id_, provider_id)) {
+  if (GetProviderRegistry()->GetProviderHost(render_process_id_, provider_id)) {
     BadMessageReceived();
     return;
   }
   scoped_ptr<ServiceWorkerProviderHost> provider_host(
       new ServiceWorkerProviderHost(
           render_process_id_, provider_id, GetContext()->AsWeakPtr(), this));
-  GetContext()->AddProviderHost(provider_host.Pass());
+  GetProviderRegistry()->AddProviderHost(provider_host.Pass());
 }
 
 void ServiceWorkerDispatcherHost::OnProviderDestroyed(int provider_id) {
   if (!GetContext())
     return;
-  if (!GetContext()->GetProviderHost(render_process_id_, provider_id)) {
+  if (!GetProviderRegistry()->GetProviderHost(render_process_id_,
+                                              provider_id)) {
     BadMessageReceived();
     return;
   }
-  GetContext()->RemoveProviderHost(render_process_id_, provider_id);
+  GetProviderRegistry()->RemoveProviderHost(render_process_id_, provider_id);
 }
 
 void ServiceWorkerDispatcherHost::OnSetHostedVersionId(
     int provider_id, int64 version_id) {
   if (!GetContext())
     return;
   ServiceWorkerProviderHost* provider_host =
-      GetContext()->GetProviderHost(render_process_id_, provider_id);
-  if (!provider_host || !provider_host->SetHostedVersionId(version_id)) {
+      GetProviderRegistry()->GetProviderHost(render_process_id_, provider_id);
+  if (!provider_host) {
     BadMessageReceived();
     return;
   }
+  if (!provider_host->IsAlive())
+    return;
+  if (!provider_host->SetHostedVersionId(version_id))
+    BadMessageReceived();
 }
 
 void ServiceWorkerDispatcherHost::RegistrationComplete(
     int thread_id,
     int request_id,
     ServiceWorkerStatusCode status,
     int64 registration_id,
     int64 version_id) {
   if (!GetContext())
     return;
 
   if (status != SERVICE_WORKER_OK) {
     SendRegistrationError(thread_id, request_id, status);
     return;
   }
 
   ServiceWorkerVersion* version = GetContext()->GetLiveVersion(version_id);
   DCHECK(version);
   DCHECK_EQ(registration_id, version->registration_id());
   scoped_ptr<ServiceWorkerHandle> handle =
       ServiceWorkerHandle::Create(GetContext()->AsWeakPtr(),
                                   this, thread_id, version);
   Send(new ServiceWorkerMsg_ServiceWorkerRegistered(
       thread_id, request_id, handle->GetObjectInfo()));
   RegisterServiceWorkerHandle(handle.Pass());
 }
 
+// TODO(nhiroki): These message handlers that take |embedded_worker_id| as an
+// input should check if the worker refers to the live context. If the context
+// was deleted, handle the messege gracefully (http://crbug.com/371675).
 void ServiceWorkerDispatcherHost::OnWorkerScriptLoaded(int embedded_worker_id) {
   if (!GetContext())
     return;
   GetContext()->embedded_worker_registry()->OnWorkerScriptLoaded(
       render_process_id_, embedded_worker_id);
 }
 
 void ServiceWorkerDispatcherHost::OnWorkerScriptLoadFailed(
     int embedded_worker_id) {
   if (!GetContext())
@@ skipping 90 matching lines @@
   GetServiceWorkerRegistrationStatusResponse(
       status, &error_type, &error_message);
   Send(new ServiceWorkerMsg_ServiceWorkerRegistrationError(
       thread_id, request_id, error_type, error_message));
 }
 
 ServiceWorkerContextCore* ServiceWorkerDispatcherHost::GetContext() {
   return context_wrapper_->context();
 }
 
+ServiceWorkerProviderHostRegistry*
+ServiceWorkerDispatcherHost::GetProviderRegistry() {
+  return context_wrapper_->provider_registry();
+}
+
 }  // namespace content