ServiceWorker: Introduce ExtendableMessageEvent to replace MessageEvent

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/thread_task_runner_handle.h"
 #include "base/threading/thread_local.h"
@@ skipping 244 matching lines @@
     return NULL;
   return g_dispatcher_tls.Pointer()->Get();
 }
 
 void ServiceWorkerDispatcher::OnWorkerRunLoopStopped() {
   delete this;
 }
 
 WebServiceWorkerImpl* ServiceWorkerDispatcher::GetServiceWorker(
     const ServiceWorkerObjectInfo& info,
+    int provider_id,
     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_.get());
     }
     return existing_worker->second;
   }
 
   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());
+  return new WebServiceWorkerImpl(handle_ref.Pass(), provider_id,
+                                  thread_safe_sender_.get());
 }
 
 WebServiceWorkerRegistrationImpl*
 ServiceWorkerDispatcher::CreateServiceWorkerRegistration(
     const ServiceWorkerRegistrationObjectInfo& info,
     bool adopt_handle) {
   DCHECK(!ContainsKey(registrations_, info.handle_id));
   if (info.handle_id == kInvalidServiceWorkerRegistrationHandleId)
     return NULL;
 
@@ skipping 55 matching lines @@
   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());
   provider->second->OnDisassociateRegistration();
 }
 
 void ServiceWorkerDispatcher::OnRegistered(
     int thread_id,
     int request_id,
+    int provider_id,
     const ServiceWorkerRegistrationObjectInfo& info,
     const ServiceWorkerVersionAttributes& attrs) {
   TRACE_EVENT_ASYNC_STEP_INTO0("ServiceWorker",
                                "ServiceWorkerDispatcher::RegisterServiceWorker",
                                request_id,
                                "OnRegistered");
   TRACE_EVENT_ASYNC_END0("ServiceWorker",
                          "ServiceWorkerDispatcher::RegisterServiceWorker",
                          request_id);
   WebServiceWorkerRegistrationCallbacks* callbacks =
       pending_registration_callbacks_.Lookup(request_id);
   DCHECK(callbacks);
   if (!callbacks)
     return;
 
-  callbacks->onSuccess(FindOrCreateRegistration(info, attrs));
+  callbacks->onSuccess(FindOrCreateRegistration(provider_id, info, attrs));
   pending_registration_callbacks_.Remove(request_id);
 }
 
 void ServiceWorkerDispatcher::OnUnregistered(int thread_id,
                                              int request_id,
                                              bool is_success) {
   TRACE_EVENT_ASYNC_STEP_INTO0(
       "ServiceWorker",
       "ServiceWorkerDispatcher::UnregisterServiceWorker",
       request_id,
       "OnUnregistered");
   TRACE_EVENT_ASYNC_END0("ServiceWorker",
                          "ServiceWorkerDispatcher::UnregisterServiceWorker",
                          request_id);
   WebServiceWorkerUnregistrationCallbacks* callbacks =
       pending_unregistration_callbacks_.Lookup(request_id);
   DCHECK(callbacks);
   if (!callbacks)
     return;
   callbacks->onSuccess(&is_success);
   pending_unregistration_callbacks_.Remove(request_id);
 }
 
 void ServiceWorkerDispatcher::OnDidGetRegistration(
     int thread_id,
     int request_id,
+    int provider_id,
     const ServiceWorkerRegistrationObjectInfo& info,
     const ServiceWorkerVersionAttributes& attrs) {
   TRACE_EVENT_ASYNC_STEP_INTO0(
       "ServiceWorker",
       "ServiceWorkerDispatcher::GetRegistration",
       request_id,
       "OnDidGetRegistration");
   TRACE_EVENT_ASYNC_END0("ServiceWorker",
                          "ServiceWorkerDispatcher::GetRegistration",
                          request_id);
   WebServiceWorkerRegistrationCallbacks* callbacks =
       pending_get_registration_callbacks_.Lookup(request_id);
   DCHECK(callbacks);
   if (!callbacks)
     return;
 
   WebServiceWorkerRegistrationImpl* registration = NULL;
   if (info.handle_id != kInvalidServiceWorkerHandleId)
-    registration = FindOrCreateRegistration(info, attrs);
+    registration = FindOrCreateRegistration(provider_id, info, attrs);
 
   callbacks->onSuccess(registration);
   pending_get_registration_callbacks_.Remove(request_id);
 }
 
 void ServiceWorkerDispatcher::OnDidGetRegistrations(
     int thread_id,
     int request_id,
+    int provider_id,
     const std::vector<ServiceWorkerRegistrationObjectInfo>& infos,
     const std::vector<ServiceWorkerVersionAttributes>& attrs) {
   TRACE_EVENT_ASYNC_STEP_INTO0(
       "ServiceWorker",
       "ServiceWorkerDispatcher::GetRegistrations",
       request_id,
       "OnDidGetRegistrations");
   TRACE_EVENT_ASYNC_END0("ServiceWorker",
                          "ServiceWorkerDispatcher::GetRegistrations",
                          request_id);
 
   WebServiceWorkerGetRegistrationsCallbacks* callbacks =
       pending_get_registrations_callbacks_.Lookup(request_id);
   DCHECK(callbacks);
   if (!callbacks)
     return;
 
   typedef blink::WebVector<blink::WebServiceWorkerRegistration*>
       WebServiceWorkerRegistrationArray;
   scoped_ptr<WebServiceWorkerRegistrationArray>
       registrations(new WebServiceWorkerRegistrationArray(infos.size()));
   for (size_t i = 0; i < infos.size(); ++i) {
     if (infos[i].handle_id != kInvalidServiceWorkerHandleId) {
       ServiceWorkerRegistrationObjectInfo info(infos[i]);
       ServiceWorkerVersionAttributes attr(attrs[i]);
-      (*registrations)[i] = FindOrCreateRegistration(info, attr);
+      (*registrations)[i] = FindOrCreateRegistration(provider_id, info, attr);
     }
   }
 
   callbacks->onSuccess(registrations.release());
   pending_get_registrations_callbacks_.Remove(request_id);
 }
 
 void ServiceWorkerDispatcher::OnDidGetRegistrationForReady(
     int thread_id,
     int request_id,
+    int provider_id,
     const ServiceWorkerRegistrationObjectInfo& info,
     const ServiceWorkerVersionAttributes& attrs) {
   TRACE_EVENT_ASYNC_STEP_INTO0(
       "ServiceWorker",
       "ServiceWorkerDispatcher::GetRegistrationForReady",
       request_id,
       "OnDidGetRegistrationForReady");
   TRACE_EVENT_ASYNC_END0("ServiceWorker",
                          "ServiceWorkerDispatcher::GetRegistrationForReady",
                          request_id);
   WebServiceWorkerGetRegistrationForReadyCallbacks* callbacks =
       get_for_ready_callbacks_.Lookup(request_id);
   DCHECK(callbacks);
   if (!callbacks)
     return;
 
   WebServiceWorkerRegistrationImpl* registration = NULL;
   DCHECK(info.handle_id != kInvalidServiceWorkerHandleId);
-  registration = FindOrCreateRegistration(info, attrs);
+  registration = FindOrCreateRegistration(provider_id, info, attrs);
   callbacks->onSuccess(registration);
   get_for_ready_callbacks_.Remove(request_id);
 }
 
 void ServiceWorkerDispatcher::OnRegistrationError(
     int thread_id,
     int request_id,
     WebServiceWorkerError::ErrorType error_type,
     const base::string16& message) {
   TRACE_EVENT_ASYNC_STEP_INTO0("ServiceWorker",
@@ skipping 137 matching lines @@
         worker_to_provider_[attrs.active.handle_id] = provider->second;
     }
     provider->second->SetVersionAttributes(mask, attrs);
   }
 
   RegistrationObjectMap::iterator found =
       registrations_.find(registration_handle_id);
   if (found != registrations_.end()) {
     // Populate the version fields (eg. .installing) with new worker objects.
     if (mask.installing_changed())
-      found->second->SetInstalling(GetServiceWorker(attrs.installing, false));
+      found->second->SetInstalling(
+          GetServiceWorker(attrs.installing, provider_id, false));
     if (mask.waiting_changed())
-      found->second->SetWaiting(GetServiceWorker(attrs.waiting, false));
+      found->second->SetWaiting(
+          GetServiceWorker(attrs.waiting, provider_id, false));
     if (mask.active_changed())
-      found->second->SetActive(GetServiceWorker(attrs.active, false));
+      found->second->SetActive(
+          GetServiceWorker(attrs.active, provider_id, false));
   }
 }
 
 void ServiceWorkerDispatcher::OnUpdateFound(
     int thread_id,
     int registration_handle_id) {
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerDispatcher::OnUpdateFound");
   RegistrationObjectMap::iterator found =
       registrations_.find(registration_handle_id);
@@ skipping 15 matching lines @@
   if (provider != provider_contexts_.end()) {
     worker_to_provider_.erase(provider->second->controller_handle_id());
     if (info.handle_id != kInvalidServiceWorkerHandleId)
       worker_to_provider_[info.handle_id] = provider->second;
     provider->second->OnSetControllerServiceWorker(info);
   }
 
   ProviderClientMap::iterator found = provider_clients_.find(provider_id);
   if (found != provider_clients_.end()) {
     // Populate the .controller field with the new worker object.
-    found->second->setController(GetServiceWorker(info, false),
+    found->second->setController(GetServiceWorker(info, provider_id, false),
                                  should_notify_controllerchange);
   }
 }
 
 void ServiceWorkerDispatcher::OnPostMessage(
     const ServiceWorkerMsg_MessageToDocument_Params& params) {
   // Make sure we're on the main document thread. (That must be the only
   // thread we get this message)
   DCHECK(ChildThreadImpl::current());
   TRACE_EVENT1("ServiceWorker", "ServiceWorkerDispatcher::OnPostMessage",
                "Thread ID", params.thread_id);
 
   ProviderClientMap::iterator found =
       provider_clients_.find(params.provider_id);
   if (found == provider_clients_.end()) {
     // For now we do no queueing for messages sent to nonexistent / unattached
     // client.
     return;
   }
 
   blink::WebMessagePortChannelArray ports =
       WebMessagePortChannelImpl::CreatePorts(
           params.message_ports, params.new_routing_ids,
           base::ThreadTaskRunnerHandle::Get());
 
   found->second->dispatchMessageEvent(
-      GetServiceWorker(params.service_worker_info, false /* adopt_handle */),
+      GetServiceWorker(params.service_worker_info, params.provider_id,
+                       false /* adopt_handle */),
       params.message, ports);
 }
 
 void ServiceWorkerDispatcher::AddServiceWorker(
     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);
 }
 
 WebServiceWorkerRegistrationImpl*
 ServiceWorkerDispatcher::FindOrCreateRegistration(
+    int provider_id,
     const ServiceWorkerRegistrationObjectInfo& info,
     const ServiceWorkerVersionAttributes& attrs) {
   RegistrationObjectMap::iterator found = registrations_.find(info.handle_id);
   if (found != registrations_.end()) {
     ServiceWorkerRegistrationHandleReference::Adopt(info,
                                                     thread_safe_sender_.get());
     ServiceWorkerHandleReference::Adopt(attrs.installing,
                                         thread_safe_sender_.get());
     ServiceWorkerHandleReference::Adopt(attrs.waiting,
                                         thread_safe_sender_.get());
     ServiceWorkerHandleReference::Adopt(attrs.active,
                                         thread_safe_sender_.get());
     return found->second;
   }
 
   bool adopt_handle = true;
   WebServiceWorkerRegistrationImpl* registration =
       CreateServiceWorkerRegistration(info, adopt_handle);
-  registration->SetInstalling(GetServiceWorker(attrs.installing, adopt_handle));
-  registration->SetWaiting(GetServiceWorker(attrs.waiting, adopt_handle));
-  registration->SetActive(GetServiceWorker(attrs.active, adopt_handle));
+  registration->SetInstalling(
+      GetServiceWorker(attrs.installing, provider_id, adopt_handle));
+  registration->SetWaiting(
+      GetServiceWorker(attrs.waiting, provider_id, adopt_handle));
+  registration->SetActive(
+      GetServiceWorker(attrs.active, provider_id, adopt_handle));
   return registration;
 }
 
 }  // namespace content