ServiceWorker: Make '.ready' return a promise to be resolved with ServiceWorkerRegistration (2/3)

content/child/service_worker/service_worker_dispatcher.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/child/service_worker/service_worker_dispatcher.h"
 
 #include "base/debug/trace_event.h"
 #include "base/lazy_instance.h"
 #include "base/stl_util.h"
 #include "base/threading/thread_local.h"
@@ skipping 36 matching lines @@
   g_dispatcher_tls.Pointer()->Set(this);
 }
 
 ServiceWorkerDispatcher::~ServiceWorkerDispatcher() {
   g_dispatcher_tls.Pointer()->Set(kHasBeenDeleted);
 }
 
 void ServiceWorkerDispatcher::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ServiceWorkerDispatcher, msg)
+    IPC_MESSAGE_HANDLER(ServiceWorkerMsg_AssociateRegistration,
+                        OnAssociateRegistration)
+    IPC_MESSAGE_HANDLER(ServiceWorkerMsg_DisassociateRegistration,
+                        OnDisassociateRegistration)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_ServiceWorkerRegistered, OnRegistered)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_ServiceWorkerUnregistered,
                         OnUnregistered)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_ServiceWorkerRegistrationError,
                         OnRegistrationError)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_ServiceWorkerUnregistrationError,
                         OnUnregistrationError)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_ServiceWorkerStateChanged,
                         OnServiceWorkerStateChanged)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_SetVersionAttributes,
@@ skipping 145 matching lines @@
   scoped_ptr<ServiceWorkerHandleReference> handle_ref =
       adopt_handle
           ? ServiceWorkerHandleReference::Adopt(info, thread_safe_sender_.get())
           : ServiceWorkerHandleReference::Create(info,
                                                  thread_safe_sender_.get());
   // WebServiceWorkerImpl constructor calls AddServiceWorker.
   return new WebServiceWorkerImpl(handle_ref.Pass(), thread_safe_sender_.get());
 }
 
 WebServiceWorkerRegistrationImpl*
-ServiceWorkerDispatcher::GetServiceWorkerRegistration(
+ServiceWorkerDispatcher::FindServiceWorkerRegistration(
     const ServiceWorkerRegistrationObjectInfo& info,
     bool adopt_handle) {
+  RegistrationObjectMap::iterator registration =
+      registrations_.find(info.handle_id);
+  if (registration == registrations_.end())
+    return NULL;
+  if (adopt_handle) {
+    // We are instructed to adopt a handle but we already have one, so
+    // adopt and destroy a handle ref.
+    ServiceWorkerRegistrationHandleReference::Adopt(
+        info, thread_safe_sender_.get());
+  }
+  return registration->second;
+}
+
+WebServiceWorkerRegistrationImpl*
+ServiceWorkerDispatcher::CreateServiceWorkerRegistration(
+    const ServiceWorkerRegistrationObjectInfo& info,
+    bool adopt_handle) {
+  DCHECK(!FindServiceWorkerRegistration(info, adopt_handle));
   if (info.handle_id == kInvalidServiceWorkerRegistrationHandleId)
     return NULL;
 
-  RegistrationObjectMap::iterator existing_registration =
-      registrations_.find(info.handle_id);
-
-  if (existing_registration != registrations_.end()) {
-    if (adopt_handle) {
-      // We are instructed to adopt a handle but we already have one, so
-      // adopt and destroy a handle ref.
-      ServiceWorkerRegistrationHandleReference::Adopt(
-          info, thread_safe_sender_.get());
-    }
-    return existing_registration->second;
-  }
-
   scoped_ptr<ServiceWorkerRegistrationHandleReference> handle_ref =
       adopt_handle ? ServiceWorkerRegistrationHandleReference::Adopt(
                          info, thread_safe_sender_.get())
                    : ServiceWorkerRegistrationHandleReference::Create(
                          info, thread_safe_sender_.get());
 
   // WebServiceWorkerRegistrationImpl constructor calls
   // AddServiceWorkerRegistration.
   return new WebServiceWorkerRegistrationImpl(handle_ref.Pass());
 }
 
+void ServiceWorkerDispatcher::OnAssociateRegistration(
+    int thread_id,
+    int provider_id,
+    const ServiceWorkerRegistrationObjectInfo& info,
+    const ServiceWorkerVersionAttributes& attrs) {
+  ProviderContextMap::iterator provider = provider_contexts_.find(provider_id);
+  if (provider == provider_contexts_.end())
+    return;
+  provider->second->OnAssociateRegistration(info, attrs);
+  if (attrs.installing.handle_id != kInvalidServiceWorkerHandleId)
+    worker_to_provider_[attrs.installing.handle_id] = provider->second;
+  if (attrs.waiting.handle_id != kInvalidServiceWorkerHandleId)
+    worker_to_provider_[attrs.waiting.handle_id] = provider->second;
+  if (attrs.active.handle_id != kInvalidServiceWorkerHandleId)
+    worker_to_provider_[attrs.active.handle_id] = provider->second;
+}
+
+void ServiceWorkerDispatcher::OnDisassociateRegistration(
+    int thread_id,
+    int provider_id) {
+  ProviderContextMap::iterator provider = provider_contexts_.find(provider_id);
+  if (provider == provider_contexts_.end())
+    return;
+  provider->second->OnDisassociateRegistration();
+  worker_to_provider_.erase(provider->second->installing_handle_id());
+  worker_to_provider_.erase(provider->second->waiting_handle_id());
+  worker_to_provider_.erase(provider->second->active_handle_id());
+  worker_to_provider_.erase(provider->second->controller_handle_id());
+}
+
 void ServiceWorkerDispatcher::OnRegistered(
     int thread_id,
     int request_id,
     const ServiceWorkerRegistrationObjectInfo& info,
     const ServiceWorkerVersionAttributes& attrs) {
   TRACE_EVENT_ASYNC_STEP_INTO0("ServiceWorker",
                                "ServiceWorkerDispatcher::RegisterServiceWorker",
                                request_id,
                                "OnRegistered");
   WebServiceWorkerRegistrationCallbacks* callbacks =
       pending_registration_callbacks_.Lookup(request_id);
   DCHECK(callbacks);
   if (!callbacks)
     return;
 
   WebServiceWorkerRegistrationImpl* registration =
-      GetServiceWorkerRegistration(info, true);
-  registration->SetInstalling(GetServiceWorker(attrs.installing, true));
-  registration->SetWaiting(GetServiceWorker(attrs.waiting, true));
-  registration->SetActive(GetServiceWorker(attrs.active, true));
+      FindServiceWorkerRegistration(info, true);
+  if (!registration) {
+    registration = CreateServiceWorkerRegistration(info, true);
+    registration->SetInstalling(GetServiceWorker(attrs.installing, true));
+    registration->SetWaiting(GetServiceWorker(attrs.waiting, true));
+    registration->SetActive(GetServiceWorker(attrs.active, true));
+  } else {
+    // |registration| must already have version attributes, so adopt and destroy
+    // handle refs for them.
+    ServiceWorkerHandleReference::Adopt(
+        attrs.installing, thread_safe_sender_.get());
+    ServiceWorkerHandleReference::Adopt(
+        attrs.waiting, thread_safe_sender_.get());
+    ServiceWorkerHandleReference::Adopt(
+        attrs.active, thread_safe_sender_.get());
+  }
 
   callbacks->onSuccess(registration);
   pending_registration_callbacks_.Remove(request_id);
   TRACE_EVENT_ASYNC_END0("ServiceWorker",
                          "ServiceWorkerDispatcher::RegisterServiceWorker",
                          request_id);
 }
 
 void ServiceWorkerDispatcher::OnUnregistered(
     int thread_id,
@@ skipping 99 matching lines @@
   }
   if (mask.waiting_changed()) {
     SetWaitingServiceWorker(provider_id,
                             registration_handle_id,
                             attributes.waiting);
   }
   if (mask.active_changed()) {
     SetActiveServiceWorker(provider_id,
                            registration_handle_id,
                            attributes.active);
+    SetReadyRegistration(provider_id, registration_handle_id);
   }
 }
 
 void ServiceWorkerDispatcher::OnUpdateFound(
     int thread_id,
     const ServiceWorkerRegistrationObjectInfo& info) {
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerDispatcher::OnUpdateFound");
   RegistrationObjectMap::iterator found = registrations_.find(info.handle_id);
   if (found != registrations_.end())
     found->second->OnUpdateFound();
 }
 
 void ServiceWorkerDispatcher::SetInstallingServiceWorker(
     int provider_id,
     int registration_handle_id,
     const ServiceWorkerObjectInfo& info) {
   ProviderContextMap::iterator provider = provider_contexts_.find(provider_id);
-  if (provider != provider_contexts_.end()) {
+  if (provider != provider_contexts_.end() &&
+      provider->second->registration_handle_id() == registration_handle_id) {
     int existing_installing_id = provider->second->installing_handle_id();
     if (existing_installing_id != info.handle_id &&
         existing_installing_id != kInvalidServiceWorkerHandleId) {
       WorkerToProviderMap::iterator associated_provider =
           worker_to_provider_.find(existing_installing_id);
       DCHECK(associated_provider != worker_to_provider_.end());
       DCHECK(associated_provider->second->provider_id() == provider_id);
       worker_to_provider_.erase(associated_provider);
     }
-    provider->second->OnSetInstallingServiceWorker(provider_id, info);
+    provider->second->OnSetInstallingServiceWorker(
+        registration_handle_id, info);
     if (info.handle_id != kInvalidServiceWorkerHandleId)
       worker_to_provider_[info.handle_id] = provider->second;
   }
 
   RegistrationObjectMap::iterator found =
       registrations_.find(registration_handle_id);
   if (found != registrations_.end()) {
     // Populate the .installing field with the new worker object.
     found->second->SetInstalling(GetServiceWorker(info, false));
   }
 }
 
 void ServiceWorkerDispatcher::SetWaitingServiceWorker(
     int provider_id,
     int registration_handle_id,
     const ServiceWorkerObjectInfo& info) {
   ProviderContextMap::iterator provider = provider_contexts_.find(provider_id);
-  if (provider != provider_contexts_.end()) {
+  if (provider != provider_contexts_.end() &&
+      provider->second->registration_handle_id() == registration_handle_id) {
     int existing_waiting_id = provider->second->waiting_handle_id();
     if (existing_waiting_id != info.handle_id &&
         existing_waiting_id != kInvalidServiceWorkerHandleId) {
       WorkerToProviderMap::iterator associated_provider =
           worker_to_provider_.find(existing_waiting_id);
       DCHECK(associated_provider != worker_to_provider_.end());
       DCHECK(associated_provider->second->provider_id() == provider_id);
       worker_to_provider_.erase(associated_provider);
     }
-    provider->second->OnSetWaitingServiceWorker(provider_id, info);
+    provider->second->OnSetWaitingServiceWorker(registration_handle_id, info);
     if (info.handle_id != kInvalidServiceWorkerHandleId)
       worker_to_provider_[info.handle_id] = provider->second;
   }
 
   RegistrationObjectMap::iterator found =
       registrations_.find(registration_handle_id);
   if (found != registrations_.end()) {
     // Populate the .waiting field with the new worker object.
     found->second->SetWaiting(GetServiceWorker(info, false));
   }
 }
 
 void ServiceWorkerDispatcher::SetActiveServiceWorker(
     int provider_id,
     int registration_handle_id,
     const ServiceWorkerObjectInfo& info) {
   ProviderContextMap::iterator provider = provider_contexts_.find(provider_id);
-  if (provider != provider_contexts_.end()) {
+  if (provider != provider_contexts_.end() &&
+      provider->second->registration_handle_id() == registration_handle_id) {
     int existing_active_id = provider->second->active_handle_id();
     if (existing_active_id != info.handle_id &&
         existing_active_id != kInvalidServiceWorkerHandleId) {
       WorkerToProviderMap::iterator associated_provider =
           worker_to_provider_.find(existing_active_id);
       DCHECK(associated_provider != worker_to_provider_.end());
       DCHECK(associated_provider->second->provider_id() == provider_id);
       worker_to_provider_.erase(associated_provider);
     }
-    provider->second->OnSetActiveServiceWorker(provider_id, info);
+    provider->second->OnSetActiveServiceWorker(registration_handle_id, info);
     if (info.handle_id != kInvalidServiceWorkerHandleId)
       worker_to_provider_[info.handle_id] = provider->second;
   }
 
   RegistrationObjectMap::iterator found =
       registrations_.find(registration_handle_id);
   if (found != registrations_.end()) {
     // Populate the .active field with the new worker object.
     found->second->SetActive(GetServiceWorker(info, false));
   }
 }
 
+void ServiceWorkerDispatcher::SetReadyRegistration(
+    int provider_id,
+    int registration_handle_id) {
+  ProviderContextMap::iterator provider = provider_contexts_.find(provider_id);
+  if (provider == provider_contexts_.end() ||
+      provider->second->registration_handle_id() != registration_handle_id ||
+      provider->second->active_handle_id() == kInvalidServiceWorkerHandleId) {
+    return;
+  }
+
+  ScriptClientMap::iterator client = script_clients_.find(provider_id);
+  if (client == script_clients_.end())
+    return;
+
+  ServiceWorkerRegistrationObjectInfo info =
+      provider->second->registration()->info();
+  WebServiceWorkerRegistrationImpl* registration =
+      FindServiceWorkerRegistration(info, false);
+  if (!registration) {
+    registration = CreateServiceWorkerRegistration(info, false);
+    ServiceWorkerVersionAttributes attrs =
+        provider->second->GetVersionAttributes();
+    registration->SetInstalling(GetServiceWorker(attrs.installing, false));
+    registration->SetWaiting(GetServiceWorker(attrs.waiting, false));
+    registration->SetActive(GetServiceWorker(attrs.active, false));
+  }
+
+  // Resolve the .ready promise with the registration object.
+  client->second->setReadyRegistration(registration);
+}
+
 void ServiceWorkerDispatcher::OnSetControllerServiceWorker(
     int thread_id,
     int provider_id,
     const ServiceWorkerObjectInfo& info) {
   TRACE_EVENT2("ServiceWorker",
                "ServiceWorkerDispatcher::OnSetControllerServiceWorker",
                "Thread ID", thread_id,
                "Provider ID", provider_id);
   ProviderContextMap::iterator provider = provider_contexts_.find(provider_id);
   if (provider != provider_contexts_.end()) {
-    provider->second->OnSetControllerServiceWorker(provider_id, info);
+    provider->second->OnSetControllerServiceWorker(
+        provider->second->registration_handle_id(), info);
     worker_to_provider_[info.handle_id] = provider->second;
   }
 
   ScriptClientMap::iterator found = script_clients_.find(provider_id);
   if (found != script_clients_.end()) {
     // Populate the .controller field with the new worker object.
     found->second->setController(GetServiceWorker(info, false));
   }
 }
 
@@ skipping 48 matching lines @@
   registrations_[registration_handle_id] = registration;
 }
 
 void ServiceWorkerDispatcher::RemoveServiceWorkerRegistration(
     int registration_handle_id) {
   DCHECK(ContainsKey(registrations_, registration_handle_id));
   registrations_.erase(registration_handle_id);
 }
 
 }  // namespace content