HTML MessagePort as mojo::MessagePipeHandle

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 <utility>
 
 #include "base/debug/crash_logging.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "content/browser/bad_message.h"
-#include "content/browser/message_port_message_filter.h"
-#include "content/browser/message_port_service.h"
 #include "content/browser/service_worker/embedded_worker_registry.h"
 #include "content/browser/service_worker/embedded_worker_status.h"
 #include "content/browser/service_worker/service_worker_client_utils.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
 #include "content/browser/service_worker/service_worker_handle.h"
 #include "content/browser/service_worker/service_worker_navigation_handle_core.h"
 #include "content/browser/service_worker/service_worker_registration.h"
 #include "content/browser/service_worker/service_worker_registration_handle.h"
 #include "content/common/service_worker/embedded_worker_messages.h"
@@ skipping 47 matching lines @@
 WebContents* GetWebContents(int render_process_id, int render_frame_id) {
   RenderFrameHost* rfh =
       RenderFrameHost::FromID(render_process_id, render_frame_id);
   return WebContents::FromRenderFrameHost(rfh);
 }
 
 }  // namespace
 
 ServiceWorkerDispatcherHost::ServiceWorkerDispatcherHost(
     int render_process_id,
-    MessagePortMessageFilter* message_port_message_filter,
     ResourceContext* resource_context)
     : BrowserMessageFilter(kFilteredMessageClasses,
                            arraysize(kFilteredMessageClasses)),
       render_process_id_(render_process_id),
-      message_port_message_filter_(message_port_message_filter),
       resource_context_(resource_context),
       channel_ready_(false),
       weak_factory_(this) {
   AddAssociatedInterface(
       mojom::ServiceWorkerDispatcherHost::Name_,
       base::Bind(&ServiceWorkerDispatcherHost::AddMojoBinding,
                  base::Unretained(this)));
 }
 
 ServiceWorkerDispatcherHost::~ServiceWorkerDispatcherHost() {
@@ skipping 10 matching lines @@
     BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                             base::Bind(&ServiceWorkerDispatcherHost::Init, this,
                                        base::RetainedRef(context_wrapper)));
     return;
   }
 
   context_wrapper_ = context_wrapper;
   if (!GetContext())
     return;
   GetContext()->embedded_worker_registry()->AddChildProcessSender(
-      render_process_id_, this, message_port_message_filter_);
+      render_process_id_, this);
 }
 
 void ServiceWorkerDispatcherHost::OnFilterAdded(IPC::Channel* channel) {
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerDispatcherHost::OnFilterAdded");
   channel_ready_ = true;
   std::vector<std::unique_ptr<IPC::Message>> messages;
   messages.swap(pending_messages_);
   for (auto& message : messages) {
     BrowserMessageFilter::Send(message.release());
@@ skipping 768 matching lines @@
       registration->id(), registration->pattern().GetOrigin(), value,
       base::Bind(&ServiceWorkerDispatcherHost::DidUpdateNavigationPreloadHeader,
                  this, thread_id, request_id, registration->id(), value));
 }
 
 void ServiceWorkerDispatcherHost::OnPostMessageToWorker(
     int handle_id,
     int provider_id,
     const base::string16& message,
     const url::Origin& source_origin,
-    const std::vector<int>& sent_message_ports) {
+    const std::vector<MessagePort>& 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* sender_provider_host =
       GetContext()->GetProviderHost(render_process_id_, provider_id);
   if (!sender_provider_host) {
     // This may occur when destruction of the sender provider overtakes
     // postMessage() because of thread hopping on WebServiceWorkerImpl.
     return;
   }
 
   DispatchExtendableMessageEvent(
       make_scoped_refptr(handle->version()), message, source_origin,
       sent_message_ports, sender_provider_host,
       base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
 }
 
 void ServiceWorkerDispatcherHost::DispatchExtendableMessageEvent(
     scoped_refptr<ServiceWorkerVersion> worker,
     const base::string16& message,
     const url::Origin& source_origin,
-    const std::vector<int>& sent_message_ports,
+    const std::vector<MessagePort>& sent_message_ports,
     ServiceWorkerProviderHost* sender_provider_host,
     const StatusCallback& callback) {
-  for (int port : sent_message_ports)
-    MessagePortService::GetInstance()->HoldMessages(port);
-
   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(&ServiceWorkerDispatcherHost::
                          DispatchExtendableMessageEventInternal<
                              ServiceWorkerClientInfo>,
                      this, worker, message, source_origin, sent_message_ports,
@@ skipping 165 matching lines @@
 
   Send(new ServiceWorkerMsg_AssociateRegistration(kDocumentMainThreadId,
                                                   provider_id, info, attrs));
 }
 
 template <typename SourceInfo>
 void ServiceWorkerDispatcherHost::DispatchExtendableMessageEventInternal(
     scoped_refptr<ServiceWorkerVersion> worker,
     const base::string16& message,
     const url::Origin& source_origin,
-    const std::vector<int>& sent_message_ports,
+    const std::vector<MessagePort>& sent_message_ports,
     const base::Optional<base::TimeDelta>& timeout,
     const StatusCallback& callback,
     const SourceInfo& source_info) {
   if (!source_info.IsValid()) {
     DidFailToDispatchExtendableMessageEvent<SourceInfo>(
         sent_message_ports, source_info, callback, SERVICE_WORKER_ERROR_FAILED);
     return;
   }
 
   // If not enough time is left to actually process the event don't even
@@ skipping 15 matching lines @@
           &ServiceWorkerDispatcherHost::DidFailToDispatchExtendableMessageEvent<
               SourceInfo>,
           this, sent_message_ports, source_info, callback));
 }
 
 void ServiceWorkerDispatcherHost::
     DispatchExtendableMessageEventAfterStartWorker(
         scoped_refptr<ServiceWorkerVersion> worker,
         const base::string16& message,
         const url::Origin& source_origin,
-        const std::vector<int>& sent_message_ports,
+        const std::vector<MessagePort>& sent_message_ports,
         const ExtendableMessageEventSource& source,
         const base::Optional<base::TimeDelta>& timeout,
         const StatusCallback& callback) {
   int request_id;
   if (timeout) {
     request_id = worker->StartRequestWithCustomTimeout(
         ServiceWorkerMetrics::EventType::MESSAGE, callback, *timeout,
         ServiceWorkerVersion::CONTINUE_ON_TIMEOUT);
   } else {
     request_id = worker->StartRequest(ServiceWorkerMetrics::EventType::MESSAGE,
                                       callback);
   }
 
-  MessagePortMessageFilter* filter =
-      worker->embedded_worker()->message_port_message_filter();
-  std::vector<int> new_routing_ids;
-  filter->UpdateMessagePortsWithNewRoutes(sent_message_ports, &new_routing_ids);
-
   mojom::ExtendableMessageEventPtr event = mojom::ExtendableMessageEvent::New();
   event->message = message;
   event->source_origin = source_origin;
-  event->message_ports = sent_message_ports;
-  event->new_routing_ids = new_routing_ids;
+  event->message_ports = MessagePort::ReleaseHandles(sent_message_ports);
   event->source = source;
 
   // Hide the client url if the client has a unique origin.
   if (source_origin.unique()) {
     if (event->source.client_info.IsValid())
       event->source.client_info.url = GURL();
     else
       event->source.service_worker_info.url = GURL();
   }
 
   // |event_dispatcher| is owned by |worker|, once |worker| got destroyed, the
   // bound function will never be called, so it is safe to use
   // base::Unretained() here.
   worker->event_dispatcher()->DispatchExtendableMessageEvent(
       std::move(event), base::Bind(&ServiceWorkerVersion::OnSimpleEventFinished,
                                    base::Unretained(worker.get()), request_id));
 }
 
 template <typename SourceInfo>
 void ServiceWorkerDispatcherHost::DidFailToDispatchExtendableMessageEvent(
-    const std::vector<int>& sent_message_ports,
+    const std::vector<MessagePort>& sent_message_ports,
     const SourceInfo& source_info,
     const StatusCallback& callback,
     ServiceWorkerStatusCode status) {
-  // Transfering the message ports failed, so destroy the ports.
-  for (int port : sent_message_ports)
-    MessagePortService::GetInstance()->ClosePort(port);
   if (source_info.IsValid())
     ReleaseSourceInfo(source_info);
   callback.Run(status);
 }
 
 void ServiceWorkerDispatcherHost::ReleaseSourceInfo(
     const ServiceWorkerClientInfo& source_info) {
   // ServiceWorkerClientInfo is just a snapshot of the client. There is no need
   // to do anything for it.
 }
@@ skipping 536 matching lines @@
   if (!handle) {
     bad_message::ReceivedBadMessage(this,
                                     bad_message::SWDH_TERMINATE_BAD_HANDLE);
     return;
   }
   handle->version()->StopWorker(
       base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
 }
 
 }  // namespace content