Set the "waiting" Service Worker of Service Worker providers

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 39 matching lines @@
 void ServiceWorkerDispatcher::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   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_SetWaitingServiceWorker,
+                        OnSetWaitingServiceWorker)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_SetCurrentServiceWorker,
                         OnSetCurrentServiceWorker)
     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 27 matching lines @@
   int provider_id = provider_context->provider_id();
   DCHECK(!ContainsKey(provider_contexts_, provider_id));
   provider_contexts_[provider_id] = provider_context;
 }
 
 void ServiceWorkerDispatcher::RemoveProviderContext(
     ServiceWorkerProviderContext* provider_context) {
   DCHECK(provider_context);
   DCHECK(ContainsKey(provider_contexts_, provider_context->provider_id()));
   provider_contexts_.erase(provider_context->provider_id());
+  worker_to_provider_.erase(provider_context->waiting_handle_id());
   worker_to_provider_.erase(provider_context->current_handle_id());
 }
 
 void ServiceWorkerDispatcher::AddScriptClient(
     int provider_id,
     blink::WebServiceWorkerProviderClient* client) {
   DCHECK(client);
   DCHECK(!ContainsKey(script_clients_, provider_id));
   script_clients_[provider_id] = client;
 }
@@ skipping 27 matching lines @@
   return g_dispatcher_tls.Pointer()->Get();
 }
 
 void ServiceWorkerDispatcher::OnWorkerRunLoopStopped() {
   delete this;
 }
 
 WebServiceWorkerImpl* ServiceWorkerDispatcher::GetServiceWorker(
     const ServiceWorkerObjectInfo& info,
     bool adopt_handle) {
+  if (info.handle_id == kInvalidServiceWorkerHandleId)
+    return NULL;
+
   WorkerObjectMap::iterator existing_worker =
       service_workers_.find(info.handle_id);
 
   if (existing_worker != service_workers_.end()) {
     if (adopt_handle) {
       // We are instructed to adopt a handle but we already have one, so
       // adopt and destroy a handle ref.
       ServiceWorkerHandleReference::Adopt(info, thread_safe_sender_);
     }
     return existing_worker->second;
@@ skipping 57 matching lines @@
     blink::WebServiceWorkerState state) {
   WorkerObjectMap::iterator worker = service_workers_.find(handle_id);
   if (worker != service_workers_.end())
     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::OnSetWaitingServiceWorker(
+    int thread_id,
+    int provider_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;
+  }
+
+  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));
+  }
+}
+
 void ServiceWorkerDispatcher::OnSetCurrentServiceWorker(
     int thread_id,
     int provider_id,
     const ServiceWorkerObjectInfo& info) {
   ProviderContextMap::iterator provider = provider_contexts_.find(provider_id);
   if (provider != provider_contexts_.end()) {
     provider->second->OnSetCurrentServiceWorker(provider_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 .current field with the new worker object.
-    found->second->setCurrentServiceWorker(GetServiceWorker(info, false));
+    // Populate the .controller field with the new worker object.
+    found->second->setController(GetServiceWorker(info, false));
   }
 }
 
 void ServiceWorkerDispatcher::OnPostMessage(
     int thread_id,
     int provider_id,
     const base::string16& message,
     const std::vector<int>& sent_message_port_ids,
     const std::vector<int>& new_routing_ids) {
   // Make sure we're on the main document thread. (That must be the only
@@ skipping 25 matching lines @@
   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);
 }
 
 }  // namespace content