ServiceWorker: Implement 'source' and 'origin' attributes of ExtendableMessageEvent

content/browser/service_worker/service_worker_version.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_version.h"
 
 #include <stddef.h>
 
 #include <map>
 #include <string>
@@ skipping 508 matching lines @@
   if (running_status() == RUNNING) {
     DCHECK(start_callbacks_.empty());
     task.Run();
     return;
   }
   StartWorker(base::Bind(&RunTaskAfterStartWorker, weak_factory_.GetWeakPtr(),
                          error_callback, task));
 }
 
 void ServiceWorkerVersion::DispatchExtendableMessageEvent(
+    ServiceWorkerProviderHost* sender_provider_host,
     const base::string16& message,
+    const url::Origin& source_origin,
     const std::vector<TransferredMessagePort>& sent_message_ports,
     const StatusCallback& callback) {
   for (const TransferredMessagePort& port : sent_message_ports)
     MessagePortService::GetInstance()->HoldMessages(port.id);
-  RunAfterStartWorker(
-      base::Bind(
-          &ServiceWorkerVersion::DispatchExtendableMessageEventAfterStartWorker,
-          weak_factory_.GetWeakPtr(), message, sent_message_ports, callback),
-      base::Bind(&RunErrorMessageCallback, sent_message_ports, callback));
+
+  switch (sender_provider_host->provider_type()) {
+    case SERVICE_WORKER_PROVIDER_FOR_WINDOW:
+    case SERVICE_WORKER_PROVIDER_FOR_WORKER:
+    case SERVICE_WORKER_PROVIDER_FOR_SHARED_WORKER:
+      service_worker_client_utils::GetClient(
+          sender_provider_host,
+          base::Bind(
+              &ServiceWorkerVersion::DispatchExtendableMessageEventInternal<
+                  ServiceWorkerClientInfo>,
+              weak_factory_.GetWeakPtr(), message, source_origin,
+              sent_message_ports, callback));
+      break;
+    case SERVICE_WORKER_PROVIDER_FOR_CONTROLLER:
+      // TODO(nhiroki): Decrement a reference to ServiceWorkerHandle if starting
+      // worker fails. Handles are managed by ServiceWorkerDispatcherHost, and
+      // we might need to make a new path to ask the dispatcher host to release
+      // the handle from ServiceWorkerVersion (http://crbug.com/543198).
+      RunSoon(base::Bind(
+          &ServiceWorkerVersion::DispatchExtendableMessageEventInternal<
+              ServiceWorkerObjectInfo>,
+          weak_factory_.GetWeakPtr(), message, source_origin,
+          sent_message_ports, callback,
+          sender_provider_host->GetOrCreateServiceWorkerHandle(
+              sender_provider_host->running_hosted_version())));
+      break;
+    case SERVICE_WORKER_PROVIDER_FOR_SANDBOXED_FRAME:
+    case SERVICE_WORKER_PROVIDER_UNKNOWN:
+      NOTREACHED() << sender_provider_host->provider_type();
+      RunSoon(base::Bind(&RunErrorMessageCallback, sent_message_ports, callback,
+                         SERVICE_WORKER_ERROR_FAILED));
+      break;
+  }
 }
 
 void ServiceWorkerVersion::DispatchMessageEvent(
     const base::string16& message,
     const std::vector<TransferredMessagePort>& sent_message_ports,
     const StatusCallback& callback) {
   for (const TransferredMessagePort& port : sent_message_ports) {
     MessagePortService::GetInstance()->HoldMessages(port.id);
   }
 
@@ skipping 352 matching lines @@
 
 void ServiceWorkerVersion::OnStartSentAndScriptEvaluated(
     ServiceWorkerStatusCode status) {
   if (status != SERVICE_WORKER_OK) {
     scoped_refptr<ServiceWorkerVersion> protect(this);
     RunCallbacks(this, &start_callbacks_,
                  DeduceStartWorkerFailureReason(status));
   }
 }
 
+template <typename SourceInfo>
+void ServiceWorkerVersion::DispatchExtendableMessageEventInternal(
+    const base::string16& message,
+    const url::Origin& source_origin,
+    const std::vector<TransferredMessagePort>& sent_message_ports,
+    const StatusCallback& callback,
+    const SourceInfo& source_info) {
+  if (!source_info.IsValid()) {
+    RunErrorMessageCallback(sent_message_ports, callback,
+                            SERVICE_WORKER_ERROR_FAILED);
+    return;
+  }
+  RunAfterStartWorker(
+      base::Bind(
+          &ServiceWorkerVersion::DispatchExtendableMessageEventAfterStartWorker,
+          weak_factory_.GetWeakPtr(), message, source_origin,
+          sent_message_ports, ExtendableMessageEventSource(source_info),
+          callback),
+      base::Bind(&RunErrorMessageCallback, sent_message_ports, callback));
+}
+
 void ServiceWorkerVersion::DispatchExtendableMessageEventAfterStartWorker(
     const base::string16& message,
+    const url::Origin& source_origin,
     const std::vector<TransferredMessagePort>& sent_message_ports,
+    const ExtendableMessageEventSource& source,
     const StatusCallback& callback) {
   int request_id =
       StartRequest(ServiceWorkerMetrics::EventType::MESSAGE, callback);
 
   MessagePortMessageFilter* filter =
       embedded_worker_->message_port_message_filter();
   std::vector<int> new_routing_ids;
   filter->UpdateMessagePortsWithNewRoutes(sent_message_ports, &new_routing_ids);
 
+  ServiceWorkerMsg_ExtendableMessageEvent_Params params;
+  params.message = message;
+  params.source_origin = source_origin;
+  params.message_ports = sent_message_ports;
+  params.new_routing_ids = new_routing_ids;
+  params.source = source;
+
+  // Hide the client url if the client has a unique origin.
+  if (source_origin.unique()) {
+    if (params.source.client_info.IsValid())
+      params.source.client_info.url = GURL();
+    else
+      params.source.service_worker_info.url = GURL();
+  }
+
   DispatchSimpleEvent<ServiceWorkerHostMsg_ExtendableMessageEventFinished>(
-      request_id,
-      ServiceWorkerMsg_ExtendableMessageEvent(
-          request_id, message, sent_message_ports, new_routing_ids));
+      request_id, ServiceWorkerMsg_ExtendableMessageEvent(request_id, params));
 }
 
 void ServiceWorkerVersion::OnGetClient(int request_id,
                                        const std::string& client_uuid) {
   if (!context_)
     return;
   TRACE_EVENT_ASYNC_BEGIN1("ServiceWorker", "ServiceWorkerVersion::OnGetClient",
                            request_id, "client_uuid", client_uuid);
   ServiceWorkerProviderHost* provider_host =
       context_->GetProviderHostByClientID(client_uuid);
@@ skipping 787 matching lines @@
 void ServiceWorkerVersion::OnBeginEvent() {
   if (should_exclude_from_uma_ || running_status() != RUNNING ||
       idle_time_.is_null()) {
     return;
   }
   ServiceWorkerMetrics::RecordTimeBetweenEvents(base::TimeTicks::Now() -
                                                 idle_time_);
 }
 
 }  // namespace content