ServiceWorker: Send state change events via SWProviderHost

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 103 matching lines @@
     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(),
-      dispatcher_host_->CreateAndRegisterServiceWorkerHandle(version),
+      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.
 
   ServiceWorkerVersion* live_version = context_->GetLiveVersion(version_id);
@@ skipping 62 matching lines @@
                                                   request_mode,
                                                   credentials_mode,
                                                   resource_type,
                                                   request_context_type,
                                                   frame_type,
                                                   body));
   }
   return scoped_ptr<ServiceWorkerRequestHandler>();
 }
 
+ServiceWorkerObjectInfo
+ServiceWorkerProviderHost::CreateAndRegisterServiceWorkerHandle(
+    ServiceWorkerVersion* version) {
+  DCHECK(dispatcher_host_);
+  ServiceWorkerObjectInfo info;
+  if (context_ && version) {
+    scoped_ptr<ServiceWorkerHandle> handle =
+        ServiceWorkerHandle::Create(context_, AsWeakPtr(), version);
+    info = handle->GetObjectInfo();
+    dispatcher_host_->RegisterServiceWorkerHandle(handle.Pass());
+  }
+  return info;
+}
+
 bool ServiceWorkerProviderHost::CanAssociateRegistration(
     ServiceWorkerRegistration* registration) {
   if (!context_)
     return false;
   if (running_hosted_version_.get())
     return false;
   if (!registration || associated_registration_.get() || !allow_association_)
     return false;
   return true;
 }
@@ skipping 74 matching lines @@
 
   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(),
-          dispatcher_host_->CreateAndRegisterServiceWorkerHandle(
+          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));
+}
+
+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;
+
+  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,
+      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));
+}
+
 void ServiceWorkerProviderHost::SendAssociateRegistrationMessage() {
   if (!dispatcher_host_)
     return;
 
   ServiceWorkerRegistrationHandle* handle =
       dispatcher_host_->GetOrCreateRegistrationHandle(
-          provider_id(), associated_registration_.get());
+          AsWeakPtr(), associated_registration_.get());
 
   ServiceWorkerVersionAttributes attrs;
-  attrs.installing = dispatcher_host_->CreateAndRegisterServiceWorkerHandle(
+  attrs.installing = CreateAndRegisterServiceWorkerHandle(
       associated_registration_->installing_version());
-  attrs.waiting = dispatcher_host_->CreateAndRegisterServiceWorkerHandle(
+  attrs.waiting = CreateAndRegisterServiceWorkerHandle(
       associated_registration_->waiting_version());
-  attrs.active = dispatcher_host_->CreateAndRegisterServiceWorkerHandle(
+  attrs.active = CreateAndRegisterServiceWorkerHandle(
       associated_registration_->active_version());
 
   dispatcher_host_->Send(new ServiceWorkerMsg_AssociateRegistration(
       kDocumentMainThreadId, 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::IsContextAlive() {
   return context_ != NULL;
 }
 
 }  // namespace content