ServiceWorker: Update the install sequence as per the latest spec

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/lazy_instance.h"
 #include "base/stl_util.h"
 #include "base/threading/thread_local.h"
 #include "content/child/child_thread.h"
@@ skipping 44 matching lines @@
   IPC_BEGIN_MESSAGE_MAP(ServiceWorkerDispatcher, msg)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_ServiceWorkerRegistered, OnRegistered)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_ServiceWorkerUnregistered,
                         OnUnregistered)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_ServiceWorkerRegistrationError,
                         OnRegistrationError)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_ServiceWorkerStateChanged,
                         OnServiceWorkerStateChanged)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_SetVersionAttributes,
                         OnSetVersionAttributes)
+    IPC_MESSAGE_HANDLER(ServiceWorkerMsg_UpdateFound,
+                        OnUpdateFound)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_SetControllerServiceWorker,
                         OnSetControllerServiceWorker)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_MessageToDocument,
                         OnPostMessage)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   DCHECK(handled) << "Unhandled message:" << msg.type();
 }
 
 bool ServiceWorkerDispatcher::Send(IPC::Message* msg) {
@@ skipping 156 matching lines @@
                          info, thread_safe_sender_.get());
 
   // WebServiceWorkerRegistrationImpl constructor calls
   // AddServiceWorkerRegistration.
   return new WebServiceWorkerRegistrationImpl(handle_ref.Pass());
 }
 
 void ServiceWorkerDispatcher::OnRegistered(
     int thread_id,
     int request_id,
-    const ServiceWorkerRegistrationObjectInfo& info) {
+    const ServiceWorkerRegistrationObjectInfo& info,
+    const ServiceWorkerVersionAttributes& attrs) {
   WebServiceWorkerRegistrationCallbacks* callbacks =
       pending_callbacks_.Lookup(request_id);
   DCHECK(callbacks);
   if (!callbacks)
     return;
 
-  callbacks->onSuccess(GetServiceWorkerRegistration(info, true));
+  WebServiceWorkerRegistrationImpl* registration =
+      GetServiceWorkerRegistration(info, true);
+
+  ChangedVersionAttributesMask mask(attrs.changed_mask);
+  if (mask.installing_changed())
+    registration->SetInstalling(GetServiceWorker(attrs.installing, true));
+  if (mask.waiting_changed())
+    registration->SetWaiting(GetServiceWorker(attrs.waiting, true));
+  if (mask.active_changed())
+    registration->SetActive(GetServiceWorker(attrs.active, true));
+
+  callbacks->onSuccess(registration);
   pending_callbacks_.Remove(request_id);
 }
 
 void ServiceWorkerDispatcher::OnUnregistered(
     int thread_id,
     int request_id) {
   WebServiceWorkerRegistrationCallbacks* callbacks =
       pending_callbacks_.Lookup(request_id);
   DCHECK(callbacks);
   if (!callbacks)
@@ skipping 30 matching lines @@
 
   WorkerToProviderMap::iterator provider = worker_to_provider_.find(handle_id);
   if (provider != worker_to_provider_.end())
     provider->second->OnServiceWorkerStateChanged(handle_id, state);
 }
 
 void ServiceWorkerDispatcher::OnSetVersionAttributes(
     int thread_id,
     int provider_id,
     int registration_handle_id,
-    int changed_mask,
-    const ServiceWorkerVersionAttributes& attributes) {
-  ChangedVersionAttributesMask mask(changed_mask);
+    const ServiceWorkerVersionAttributes& attrs) {
+  ChangedVersionAttributesMask mask(attrs.changed_mask);
   if (mask.installing_changed()) {
     SetInstallingServiceWorker(provider_id,
                                registration_handle_id,
-                               attributes.installing);
+                               attrs.installing);
   }
   if (mask.waiting_changed()) {
     SetWaitingServiceWorker(provider_id,
                             registration_handle_id,
-                            attributes.waiting);
+                            attrs.waiting);
   }
   if (mask.active_changed()) {
     SetActiveServiceWorker(provider_id,
                            registration_handle_id,
-                           attributes.active);
+                           attrs.active);
   }
 }
 
+void ServiceWorkerDispatcher::OnUpdateFound(
+    int thread_id,
+    const ServiceWorkerRegistrationObjectInfo& info) {
+  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()) {
     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);
     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));
-    if (info.handle_id != kInvalidServiceWorkerHandleId)
-      found->second->OnUpdateFound();
   }
 }
 
 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()) {
     int existing_waiting_id = provider->second->waiting_handle_id();
@@ skipping 111 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