ServiceWorker: Introduce ExtendableMessageEvent to replace MessageEvent

content/browser/service_worker/service_worker_dispatcher_host.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/browser/service_worker/service_worker_dispatcher_host.h"
 
 #include "base/logging.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/trace_event/trace_event.h"
@@ skipping 660 matching lines @@
   if (!provider_host->GetRegistrationForReady(base::Bind(
           &ServiceWorkerDispatcherHost::GetRegistrationForReadyComplete,
           this, thread_id, request_id, provider_host->AsWeakPtr()))) {
     bad_message::ReceivedBadMessage(
         this, bad_message::SWDH_GET_REGISTRATION_FOR_READY_ALREADY_IN_PROGRESS);
   }
 }
 
 void ServiceWorkerDispatcherHost::OnPostMessageToWorker(
     int handle_id,
+    int provider_id,
     const base::string16& message,
     const std::vector<TransferredMessagePort>& sent_message_ports) {
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerDispatcherHost::OnPostMessageToWorker");
   if (!GetContext())
     return;
 
   ServiceWorkerHandle* handle = handles_.Lookup(handle_id);
   if (!handle) {
     bad_message::ReceivedBadMessage(this, bad_message::SWDH_POST_MESSAGE);
     return;
   }
-
+  ServiceWorkerProviderHost* provider_host =
+      GetContext()->GetProviderHost(render_process_id_, provider_id);
+  if (!provider_host) {
+    bad_message::ReceivedBadMessage(this, bad_message::SWDH_POST_MESSAGE);
+    return;
+  }
   handle->version()->DispatchMessageEvent(
-      message, sent_message_ports,
+      provider_host, message, sent_message_ports,
       base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
 }
 
 void ServiceWorkerDispatcherHost::OnProviderCreated(
     int provider_id,
     int route_id,
     ServiceWorkerProviderType provider_type) {
   // TODO(pkasting): Remove ScopedTracker below once crbug.com/477117 is fixed.
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
@@ skipping 128 matching lines @@
 
   ServiceWorkerRegistration* registration =
       GetContext()->GetLiveRegistration(registration_id);
   DCHECK(registration);
 
   ServiceWorkerRegistrationObjectInfo info;
   ServiceWorkerVersionAttributes attrs;
   GetRegistrationObjectInfoAndVersionAttributes(
       provider_host->AsWeakPtr(), registration, &info, &attrs);
 
-  Send(new ServiceWorkerMsg_ServiceWorkerRegistered(
-      thread_id, request_id, info, attrs));
+  Send(new ServiceWorkerMsg_ServiceWorkerRegistered(thread_id, request_id,
+                                                    provider_id, info, attrs));
   TRACE_EVENT_ASYNC_END1("ServiceWorker",
                          "ServiceWorkerDispatcherHost::RegisterServiceWorker",
                          request_id,
                          "Registration ID",
                          registration_id);
 }
 
 void ServiceWorkerDispatcherHost::OnWorkerReadyForInspection(
     int embedded_worker_id) {
   TRACE_EVENT0("ServiceWorker",
@@ skipping 234 matching lines @@
   ServiceWorkerRegistrationObjectInfo info;
   ServiceWorkerVersionAttributes attrs;
   if (status == SERVICE_WORKER_OK) {
     DCHECK(registration.get());
     if (!registration->is_uninstalling()) {
       GetRegistrationObjectInfoAndVersionAttributes(
           provider_host->AsWeakPtr(), registration.get(), &info, &attrs);
     }
   }
 
-  Send(new ServiceWorkerMsg_DidGetRegistration(
-      thread_id, request_id, info, attrs));
+  Send(new ServiceWorkerMsg_DidGetRegistration(thread_id, request_id,
+                                               provider_id, info, attrs));
 }
 
 void ServiceWorkerDispatcherHost::GetRegistrationsComplete(
     int thread_id,
     int provider_id,
     int request_id,
     const std::vector<scoped_refptr<ServiceWorkerRegistration>>&
         registrations) {
   TRACE_EVENT_ASYNC_END0("ServiceWorker",
                          "ServiceWorkerDispatcherHost::GetRegistrations",
@@ skipping 15 matching lines @@
       ServiceWorkerRegistrationObjectInfo object_info;
       ServiceWorkerVersionAttributes version_attr;
       GetRegistrationObjectInfoAndVersionAttributes(
           provider_host->AsWeakPtr(), registration.get(), &object_info,
           &version_attr);
       object_infos.push_back(object_info);
       version_attrs.push_back(version_attr);
     }
   }
 
-  Send(new ServiceWorkerMsg_DidGetRegistrations(thread_id, request_id,
-                                                object_infos, version_attrs));
+  Send(new ServiceWorkerMsg_DidGetRegistrations(
+      thread_id, request_id, provider_id, object_infos, version_attrs));
 }
 
 void ServiceWorkerDispatcherHost::GetRegistrationForReadyComplete(
     int thread_id,
     int request_id,
     base::WeakPtr<ServiceWorkerProviderHost> provider_host,
     ServiceWorkerRegistration* registration) {
   DCHECK(registration);
   TRACE_EVENT_ASYNC_END1("ServiceWorker",
                          "ServiceWorkerDispatcherHost::GetRegistrationForReady",
                          request_id,
                          "Registration ID",
                          registration ? registration->id()
                              : kInvalidServiceWorkerRegistrationId);
 
   if (!GetContext())
     return;
 
   ServiceWorkerRegistrationObjectInfo info;
   ServiceWorkerVersionAttributes attrs;
   GetRegistrationObjectInfoAndVersionAttributes(
       provider_host, registration, &info, &attrs);
   Send(new ServiceWorkerMsg_DidGetRegistrationForReady(
-        thread_id, request_id, info, attrs));
+      thread_id, request_id, provider_host->provider_id(), info, attrs));
 }
 
 void ServiceWorkerDispatcherHost::SendRegistrationError(
     int thread_id,
     int request_id,
     ServiceWorkerStatusCode status,
     const std::string& status_message) {
   base::string16 error_message;
   blink::WebServiceWorkerError::ErrorType error_type;
   GetServiceWorkerRegistrationStatusResponse(status, status_message,
@@ skipping 55 matching lines @@
   if (!handle) {
     bad_message::ReceivedBadMessage(this,
                                     bad_message::SWDH_TERMINATE_BAD_HANDLE);
     return;
   }
   handle->version()->StopWorker(
       base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
 }
 
 }  // namespace content