ServiceWorker: Implement updatefound event and version attributes (Chromium)

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"
 #include "content/child/service_worker/service_worker_handle_reference.h"
 #include "content/child/service_worker/service_worker_provider_context.h"
+#include "content/child/service_worker/service_worker_registration_handle_reference.h"
 #include "content/child/service_worker/web_service_worker_impl.h"
 #include "content/child/service_worker/web_service_worker_registration_impl.h"
 #include "content/child/thread_safe_sender.h"
 #include "content/child/webmessageportchannel_impl.h"
 #include "content/common/service_worker/service_worker_messages.h"
 #include "content/public/common/url_utils.h"
 #include "third_party/WebKit/public/platform/WebServiceWorkerProviderClient.h"
 #include "third_party/WebKit/public/web/WebSecurityOrigin.h"
 
 using blink::WebServiceWorkerError;
@@ skipping 172 matching lines @@
   }
 
   scoped_ptr<ServiceWorkerHandleReference> handle_ref =
       adopt_handle
           ? ServiceWorkerHandleReference::Adopt(info, thread_safe_sender_)
           : ServiceWorkerHandleReference::Create(info, thread_safe_sender_);
   // WebServiceWorkerImpl constructor calls AddServiceWorker.
   return new WebServiceWorkerImpl(handle_ref.Pass(), thread_safe_sender_);
 }
 
+WebServiceWorkerRegistrationImpl*
+ServiceWorkerDispatcher::GetServiceWorkerRegistration(
+    int registration_handle_id,
+    const ServiceWorkerObjectInfo& info,
+    bool adopt_handle) {
+  if (registration_handle_id == kInvalidServiceWorkerRegistrationHandleId)
+    return NULL;
+
+  RegistrationObjectMap::iterator existing_registration =
+      registrations_.find(registration_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(
+          registration_handle_id, info, thread_safe_sender_);
+    }
+    return existing_registration->second;
+  }
+
+  scoped_ptr<ServiceWorkerRegistrationHandleReference> handle_ref =
+      adopt_handle
+          ? ServiceWorkerRegistrationHandleReference::Adopt(
+              registration_handle_id, info, thread_safe_sender_)
+          : ServiceWorkerRegistrationHandleReference::Create(
+              registration_handle_id, info, thread_safe_sender_);
+
+  // WebServiceWorkerRegistrationImpl constructor calls
+  // AddServiceWorkerRegistration.
+  return new WebServiceWorkerRegistrationImpl(handle_ref.Pass());
+}
+
 void ServiceWorkerDispatcher::OnRegistered(
     int thread_id,
     int request_id,
+    int registration_handle_id,
     const ServiceWorkerObjectInfo& info) {
   WebServiceWorkerRegistrationCallbacks* callbacks =
       pending_callbacks_.Lookup(request_id);
   DCHECK(callbacks);
   if (!callbacks)
     return;
 
 #ifdef DISABLE_SERVICE_WORKER_REGISTRATION
   callbacks->onSuccess(GetServiceWorker(info, true));
+  // We should adopt and destroy an unused handle ref.
+  ServiceWorkerRegistrationHandleReference::Adopt(
+      registration_handle_id, info, thread_safe_sender_);
 #else
-  callbacks->onSuccess(new WebServiceWorkerRegistrationImpl(info));
+  callbacks->onSuccess(GetServiceWorkerRegistration(
+      registration_handle_id, info, true));
+  // We should adopt and destroy an unused handle ref.
+  ServiceWorkerHandleReference::Adopt(info, thread_safe_sender_);
 #endif
   pending_callbacks_.Remove(request_id);
 }
 
 void ServiceWorkerDispatcher::OnUnregistered(
     int thread_id,
     int request_id) {
   WebServiceWorkerRegistrationCallbacks* callbacks =
       pending_callbacks_.Lookup(request_id);
   DCHECK(callbacks);
@@ skipping 30 matching lines @@
     worker->second->OnStateChanged(state);
 
   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);
-  if (mask.installing_changed())
-    SetInstallingServiceWorker(provider_id, attributes.installing);
-  if (mask.waiting_changed())
-    SetWaitingServiceWorker(provider_id, attributes.waiting);
-  if (mask.active_changed())
-    SetActiveServiceWorker(provider_id, attributes.active);
+  if (mask.installing_changed()) {
+    SetInstallingServiceWorker(provider_id,
+                               registration_handle_id,
+                               attributes.installing);
+  }
+  if (mask.waiting_changed()) {
+    SetWaitingServiceWorker(provider_id,
+                            registration_handle_id,
+                            attributes.waiting);
+  }
+  if (mask.active_changed()) {
+    SetActiveServiceWorker(provider_id,
+                           registration_handle_id,
+                           attributes.active);
+  }
 }
 
 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;
   }
 
+#ifdef DISABLE_SERVICE_WORKER_REGISTRATION
   ScriptClientMap::iterator found = script_clients_.find(provider_id);
   if (found != script_clients_.end()) {
     // Populate the .installing field with the new worker object.
     found->second->setInstalling(GetServiceWorker(info, false));
   }
+#else
+  RegistrationObjectMap::iterator found =
+      registrations_.find(registration_handle_id);
+  if (found != registrations_.end()) {
+    found->second->setInstalling(GetServiceWorker(info, false));
+    if (info.handle_id != kInvalidServiceWorkerHandleId)
+      found->second->OnUpdateFound();
+  }
+#endif
 }
 
 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();
     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);
     if (info.handle_id != kInvalidServiceWorkerHandleId)
       worker_to_provider_[info.handle_id] = provider->second;
   }
 
+#ifdef DISABLE_SERVICE_WORKER_REGISTRATION
   ScriptClientMap::iterator found = script_clients_.find(provider_id);
   if (found != script_clients_.end()) {
     // Populate the .waiting field with the new worker object.
     found->second->setWaiting(GetServiceWorker(info, false));
   }
+#else
+  RegistrationObjectMap::iterator found =
+      registrations_.find(registration_handle_id);
+  if (found != registrations_.end())
+    found->second->setWaiting(GetServiceWorker(info, false));
+#endif
 }
 
 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()) {
     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);
     if (info.handle_id != kInvalidServiceWorkerHandleId)
       worker_to_provider_[info.handle_id] = provider->second;
   }
 
+#ifdef DISABLE_SERVICE_WORKER_REGISTRATION
   ScriptClientMap::iterator found = script_clients_.find(provider_id);
   if (found != script_clients_.end()) {
     // Populate the .active field with the new worker object.
     found->second->setActive(GetServiceWorker(info, false));
   }
+#else
+  RegistrationObjectMap::iterator found =
+      registrations_.find(registration_handle_id);
+  if (found != registrations_.end())
+    found->second->setActive(GetServiceWorker(info, false));
+#endif
 }
 
 void ServiceWorkerDispatcher::OnSetControllerServiceWorker(
     int thread_id,
     int provider_id,
     const ServiceWorkerObjectInfo& info) {
   ProviderContextMap::iterator provider = provider_contexts_.find(provider_id);
   if (provider != provider_contexts_.end()) {
     provider->second->OnSetControllerServiceWorker(provider_id, info);
     worker_to_provider_[info.handle_id] = provider->second;
@@ skipping 40 matching lines @@
     int handle_id, WebServiceWorkerImpl* worker) {
   DCHECK(!ContainsKey(service_workers_, handle_id));
   service_workers_[handle_id] = worker;
 }
 
 void ServiceWorkerDispatcher::RemoveServiceWorker(int handle_id) {
   DCHECK(ContainsKey(service_workers_, handle_id));
   service_workers_.erase(handle_id);
 }
 
+void ServiceWorkerDispatcher::AddServiceWorkerRegistration(
+    int registration_handle_id,
+    WebServiceWorkerRegistrationImpl* registration) {
+  DCHECK(!ContainsKey(registrations_, registration_handle_id));
+  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