ServiceWorker: Enqueue state change events until the worker thread gets ready

content/browser/service_worker/service_worker_provider_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_provider_host.h"
 
 #include "base/stl_util.h"
 #include "content/browser/message_port_message_filter.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_context_request_handler.h"
@@ skipping 28 matching lines @@
     web_contents->GetDelegate()->ActivateContents(web_contents);
   }
 
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                           base::Bind(callback, result));
 }
 
 }  // anonymous namespace
 
 ServiceWorkerProviderHost::ServiceWorkerProviderHost(
-    int render_process_id, int render_frame_id, int provider_id,
+    int render_process_id,
+    int render_frame_id,
+    int provider_id,
     base::WeakPtr<ServiceWorkerContextCore> context,
     ServiceWorkerDispatcherHost* dispatcher_host)
     : render_process_id_(render_process_id),
       render_frame_id_(render_frame_id),
+      render_thread_id_(kInvalidEmbeddedWorkerThreadId),
       provider_id_(provider_id),
       context_(context),
       dispatcher_host_(dispatcher_host),
       allow_association_(true) {
   DCHECK_NE(ChildProcessHost::kInvalidUniqueID, render_process_id_);
+
+  // If |render_frame_id| is not MSG_ROUTING_NONE, this provider host works for
+  // the document context and its thread in the child process should be the main
+  // thread. For the worker context, the corresponding thread is notified when
+  // the worker context gets started via SetReadyToSend().

[kinuko, 2015/01/28 07:13:11]

I think part of this comment should be probably in the header file?

[nhiroki, 2015/01/28 13:43:22]

Done.

+  if (render_frame_id != MSG_ROUTING_NONE)
+    render_thread_id_ = kDocumentMainThreadId;

[kinuko, 2015/01/28 07:13:11]

Doing the opposite might feel more natural /easier to understand (i.e.
initializing this with kDocumentMainThreadId, setting kInvalid if frame_id is
MSG_ROUTING_NONE)

[nhiroki, 2015/01/28 13:43:22]

Done.

 }
 
 ServiceWorkerProviderHost::~ServiceWorkerProviderHost() {
   // Clear docurl so the deferred activation of a waiting worker
   // won't associate the new version with a provider being destroyed.
   document_url_ = GURL();
   if (controlling_version_.get())
     controlling_version_->RemoveControllee(this);
   if (associated_registration_.get()) {
     DecreaseProcessReference(associated_registration_->pattern());
@@ skipping 43 matching lines @@
     version->AddControllee(this);
   if (previous_version.get())
     previous_version->RemoveControllee(this);
 
   if (!dispatcher_host_)
     return;  // Could be NULL in some tests.
 
   bool should_notify_controllerchange =
       previous_version && version && version->skip_waiting();
 
-  dispatcher_host_->Send(new ServiceWorkerMsg_SetControllerServiceWorker(
-      kDocumentMainThreadId, provider_id(),
+  // SetController message should be sent only for the document context.
+  DCHECK_EQ(kDocumentMainThreadId, render_thread_id_);
+  Send(new ServiceWorkerMsg_SetControllerServiceWorker(
+      render_thread_id_, provider_id(),
       CreateAndRegisterServiceWorkerHandle(version),
       should_notify_controllerchange));
 }
 
 bool ServiceWorkerProviderHost::SetHostedVersionId(int64 version_id) {
   if (!context_)
     return true;  // System is shutting down.
   if (active_version())
     return false;  // Unexpected bad message.
 
@@ skipping 20 matching lines @@
     DecreaseProcessReference(associated_registration_->pattern());
   IncreaseProcessReference(registration->pattern());
 
   associated_registration_ = registration;
   associated_registration_->AddListener(this);
   SendAssociateRegistrationMessage();
   SetControllerVersionAttribute(registration->active_version());
 }
 
 void ServiceWorkerProviderHost::DisassociateRegistration() {
+  queued_events_.clear();
   if (!associated_registration_.get())
     return;
   DecreaseProcessReference(associated_registration_->pattern());
   associated_registration_->RemoveListener(this);
   associated_registration_ = NULL;
   SetControllerVersionAttribute(NULL);
 
-  if (dispatcher_host_) {
-    dispatcher_host_->Send(new ServiceWorkerMsg_DisassociateRegistration(
-        kDocumentMainThreadId, provider_id()));
-  }
+  if (!dispatcher_host_)
+    return;
+
+  // Disassociation message should be sent only for the document context.
+  DCHECK_EQ(kDocumentMainThreadId, render_thread_id_);
+  Send(new ServiceWorkerMsg_DisassociateRegistration(
+      render_thread_id_, provider_id()));
 }
 
 scoped_ptr<ServiceWorkerRequestHandler>
 ServiceWorkerProviderHost::CreateRequestHandler(
     FetchRequestMode request_mode,
     FetchCredentialsMode credentials_mode,
     ResourceType resource_type,
     RequestContextType request_context_type,
     RequestContextFrameType frame_type,
     base::WeakPtr<storage::BlobStorageContext> blob_storage_context,
@@ skipping 48 matching lines @@
     const base::string16& message,
     const std::vector<int>& sent_message_port_ids) {
   if (!dispatcher_host_)
     return;  // Could be NULL in some tests.
 
   std::vector<int> new_routing_ids;
   dispatcher_host_->message_port_message_filter()->
       UpdateMessagePortsWithNewRoutes(sent_message_port_ids,
                                       &new_routing_ids);
 
-  dispatcher_host_->Send(
-      new ServiceWorkerMsg_MessageToDocument(
-          kDocumentMainThreadId, provider_id(),
-          message,
-          sent_message_port_ids,
-          new_routing_ids));
+  Send(new ServiceWorkerMsg_MessageToDocument(
+      kDocumentMainThreadId, provider_id(),
+      message,
+      sent_message_port_ids,
+      new_routing_ids));
 }
 
 void ServiceWorkerProviderHost::Focus(const FocusCallback& callback) {
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&FocusOnUIThread,
                  render_process_id_,
                  render_frame_id_,
                  callback));
 }
 
 void ServiceWorkerProviderHost::GetClientInfo(
     int embedded_worker_id,
     int request_id) {
-  dispatcher_host_->Send(new ServiceWorkerMsg_GetClientInfo(
+  Send(new ServiceWorkerMsg_GetClientInfo(
       kDocumentMainThreadId, embedded_worker_id, request_id, provider_id()));
 }
 
 void ServiceWorkerProviderHost::AddScopedProcessReferenceToPattern(
     const GURL& pattern) {
   associated_patterns_.push_back(pattern);
   IncreaseProcessReference(pattern);
 }
 
 void ServiceWorkerProviderHost::PrepareForCrossSiteTransfer() {
   DCHECK_NE(ChildProcessHost::kInvalidUniqueID, render_process_id_);
+  DCHECK_NE(MSG_ROUTING_NONE, render_frame_id_);
+  DCHECK_EQ(kDocumentMainThreadId, render_thread_id_);
 
   for (const GURL& pattern : associated_patterns_)
     DecreaseProcessReference(pattern);
 
   if (associated_registration_.get()) {
     DecreaseProcessReference(associated_registration_->pattern());
     if (dispatcher_host_) {
-      dispatcher_host_->Send(new ServiceWorkerMsg_DisassociateRegistration(
-          kDocumentMainThreadId, provider_id()));
+      Send(new ServiceWorkerMsg_DisassociateRegistration(
+          render_thread_id_, provider_id()));
     }
   }
 
   render_process_id_ = ChildProcessHost::kInvalidUniqueID;
   render_frame_id_ = MSG_ROUTING_NONE;
+  render_thread_id_ = kInvalidEmbeddedWorkerThreadId;
   provider_id_ = kInvalidServiceWorkerProviderId;
   dispatcher_host_ = nullptr;
 }
 
 void ServiceWorkerProviderHost::CompleteCrossSiteTransfer(
     int new_process_id,
     int new_frame_id,
     int new_provider_id,
     ServiceWorkerDispatcherHost* new_dispatcher_host) {
   DCHECK_EQ(ChildProcessHost::kInvalidUniqueID, render_process_id_);
   DCHECK_NE(ChildProcessHost::kInvalidUniqueID, new_process_id);
+  DCHECK_NE(MSG_ROUTING_NONE, new_frame_id);
 
   render_process_id_ = new_process_id;
   render_frame_id_ = new_frame_id;
+  render_thread_id_ = kDocumentMainThreadId;
   provider_id_ = new_provider_id;
   dispatcher_host_ = new_dispatcher_host;
 
   for (const GURL& pattern : associated_patterns_)
     IncreaseProcessReference(pattern);
 
   if (associated_registration_.get()) {
     IncreaseProcessReference(associated_registration_->pattern());
     SendAssociateRegistrationMessage();
     if (dispatcher_host_ && associated_registration_->active_version()) {
-      dispatcher_host_->Send(new ServiceWorkerMsg_SetControllerServiceWorker(
-          kDocumentMainThreadId, provider_id(),
+      Send(new ServiceWorkerMsg_SetControllerServiceWorker(
+          render_thread_id_, provider_id(),
           CreateAndRegisterServiceWorkerHandle(
               associated_registration_->active_version()),
           false /* shouldNotifyControllerChange */));
     }
   }
 }
 
 void ServiceWorkerProviderHost::SendUpdateFoundMessage(
     const ServiceWorkerRegistrationObjectInfo& object_info) {
   if (!dispatcher_host_)
     return;  // Could be nullptr in some tests.
 
-  // TODO(nhiroki): Queue the message if a receiver's thread is not ready yet
-  // (http://crbug.com/437677).
-  dispatcher_host_->Send(new ServiceWorkerMsg_UpdateFound(
-      kDocumentMainThreadId, object_info));
+  if (!IsReadyToSend()) {
+    queued_events_.push_back(
+        base::Bind(&self::SendUpdateFoundMessage, AsWeakPtr(), object_info));
+    return;
+  }
+
+  Send(new ServiceWorkerMsg_UpdateFound(render_thread_id_, object_info));
 }
 
 void ServiceWorkerProviderHost::SendSetVersionAttributesMessage(
     int registration_handle_id,
     ChangedVersionAttributesMask changed_mask,
     ServiceWorkerVersion* installing_version,
     ServiceWorkerVersion* waiting_version,
     ServiceWorkerVersion* active_version) {
   if (!dispatcher_host_)
     return;  // Could be nullptr in some tests.
   if (!changed_mask.changed())
     return;
 
+  if (!IsReadyToSend()) {
+    queued_events_.push_back(
+        base::Bind(&self::SendSetVersionAttributesMessage,
+                   AsWeakPtr(), registration_handle_id, changed_mask,
+                   make_scoped_refptr(installing_version),
+                   make_scoped_refptr(waiting_version),
+                   make_scoped_refptr(active_version)));
+    return;
+  }
+
   ServiceWorkerVersionAttributes attrs;
   if (changed_mask.installing_changed())
     attrs.installing = CreateAndRegisterServiceWorkerHandle(installing_version);
   if (changed_mask.waiting_changed())
     attrs.waiting = CreateAndRegisterServiceWorkerHandle(waiting_version);
   if (changed_mask.active_changed())
     attrs.active = CreateAndRegisterServiceWorkerHandle(active_version);
 
-  // TODO(nhiroki): Queue the message if a receiver's thread is not ready yet
-  // (http://crbug.com/437677).
-  dispatcher_host_->Send(new ServiceWorkerMsg_SetVersionAttributes(
-      kDocumentMainThreadId, provider_id_, registration_handle_id,
+  Send(new ServiceWorkerMsg_SetVersionAttributes(
+      render_thread_id_, provider_id_, registration_handle_id,
       changed_mask.changed(), attrs));
 }
 
 void ServiceWorkerProviderHost::SendServiceWorkerStateChangedMessage(
     int worker_handle_id,
     blink::WebServiceWorkerState state) {
   if (!dispatcher_host_)
     return;
 
-  // TODO(nhiroki): Queue the message if a receiver's thread is not ready yet
-  // (http://crbug.com/437677).
-  dispatcher_host_->Send(new ServiceWorkerMsg_ServiceWorkerStateChanged(
-      kDocumentMainThreadId, worker_handle_id, state));
+  if (!IsReadyToSend()) {
+    queued_events_.push_back(
+        base::Bind(&self::SendServiceWorkerStateChangedMessage,
+                   AsWeakPtr(), worker_handle_id, state));
+    return;
+  }
+
+  Send(new ServiceWorkerMsg_ServiceWorkerStateChanged(
+      render_thread_id_, worker_handle_id, state));
+}
+
+void ServiceWorkerProviderHost::SetReadyToSend(int render_thread_id) {
+  DCHECK(!IsReadyToSend());
+  render_thread_id_ = render_thread_id;
+
+  for (const auto& event : queued_events_)
+    event.Run();
+  queued_events_.clear();
 }
 
 void ServiceWorkerProviderHost::SendAssociateRegistrationMessage() {
   if (!dispatcher_host_)
     return;
 
   ServiceWorkerRegistrationHandle* handle =
       dispatcher_host_->GetOrCreateRegistrationHandle(
           AsWeakPtr(), associated_registration_.get());
 
   ServiceWorkerVersionAttributes attrs;
   attrs.installing = CreateAndRegisterServiceWorkerHandle(
       associated_registration_->installing_version());
   attrs.waiting = CreateAndRegisterServiceWorkerHandle(
       associated_registration_->waiting_version());
   attrs.active = CreateAndRegisterServiceWorkerHandle(
       associated_registration_->active_version());
 
+  // Association message should be sent only for the document context.
+  DCHECK_EQ(kDocumentMainThreadId, render_thread_id_);
   dispatcher_host_->Send(new ServiceWorkerMsg_AssociateRegistration(
-      kDocumentMainThreadId, provider_id(), handle->GetObjectInfo(), attrs));
+      render_thread_id_, provider_id(), handle->GetObjectInfo(), attrs));
 }
 
 void ServiceWorkerProviderHost::IncreaseProcessReference(
     const GURL& pattern) {
   if (context_ && context_->process_manager()) {
     context_->process_manager()->AddProcessReferenceToPattern(
         pattern, render_process_id_);
   }
 }
 
 void ServiceWorkerProviderHost::DecreaseProcessReference(
     const GURL& pattern) {
   if (context_ && context_->process_manager()) {
     context_->process_manager()->RemoveProcessReferenceFromPattern(
         pattern, render_process_id_);
   }
 }
 
+bool ServiceWorkerProviderHost::IsReadyToSend() const {
+  return render_thread_id_ != kInvalidEmbeddedWorkerThreadId;
+}
+
 bool ServiceWorkerProviderHost::IsContextAlive() {
   return context_ != NULL;
 }
 
+void ServiceWorkerProviderHost::Send(IPC::Message* message) const {
+  DCHECK(dispatcher_host_);
+  DCHECK(IsReadyToSend());
+  dispatcher_host_->Send(message);
+}
+
 }  // namespace content