HTML MessagePort as mojo::MessagePipeHandle

content/renderer/service_worker/service_worker_context_client.cc

 // Copyright 2015 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/renderer/service_worker/service_worker_context_client.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/lazy_instance.h"
@@ skipping 15 matching lines @@
 #include "content/child/service_worker/service_worker_provider_context.h"
 #include "content/child/service_worker/service_worker_registration_handle_reference.h"
 #include "content/child/service_worker/web_service_worker_impl.h"
 #include "content/child/service_worker/web_service_worker_provider_impl.h"
 #include "content/child/service_worker/web_service_worker_registration_impl.h"
 #include "content/child/thread_safe_sender.h"
 #include "content/child/web_data_consumer_handle_impl.h"
 #include "content/child/web_url_loader_impl.h"
 #include "content/child/webmessageportchannel_impl.h"
 #include "content/common/devtools_messages.h"
-#include "content/common/message_port_messages.h"
 #include "content/common/service_worker/embedded_worker_messages.h"
 #include "content/common/service_worker/service_worker_event_dispatcher.mojom.h"
 #include "content/common/service_worker/service_worker_messages.h"
 #include "content/common/service_worker/service_worker_status_code.h"
 #include "content/common/service_worker/service_worker_utils.h"
 #include "content/public/common/push_event_payload.h"
 #include "content/public/common/referrer.h"
 #include "content/public/renderer/content_renderer_client.h"
 #include "content/public/renderer/document_state.h"
 #include "content/renderer/devtools/devtools_agent.h"
@@ skipping 78 matching lines @@
   }
   NOTREACHED() << "Got invalid result: " << result;
   return SERVICE_WORKER_ERROR_FAILED;
 }
 
 void SendPostMessageToClientOnMainThread(
     ThreadSafeSender* sender,
     int routing_id,
     const std::string& uuid,
     const base::string16& message,
-    std::unique_ptr<blink::WebMessagePortChannelArray> channels) {
+    blink::WebMessagePortChannelArray channels) {
   sender->Send(new ServiceWorkerHostMsg_PostMessageToClient(
       routing_id, uuid, message,
-      WebMessagePortChannelImpl::ExtractMessagePortIDs(std::move(channels))));
+      WebMessagePortChannelImpl::ExtractMessagePorts(std::move(channels))));
 }
 
 blink::WebURLRequest::FetchRequestMode GetBlinkFetchRequestMode(
     FetchRequestMode mode) {
   return static_cast<blink::WebURLRequest::FetchRequestMode>(mode);
 }
 
 blink::WebURLRequest::FetchCredentialsMode GetBlinkFetchCredentialsMode(
     FetchCredentialsMode credentials_mode) {
   return static_cast<blink::WebURLRequest::FetchCredentialsMode>(
@@ skipping 640 matching lines @@
   DCHECK(provider_context_);
 
   // Blink is responsible for deleting the returned object.
   return new WebServiceWorkerProviderImpl(
       sender_.get(), provider_context_.get());
 }
 
 void ServiceWorkerContextClient::postMessageToClient(
     const blink::WebString& uuid,
     const blink::WebString& message,
-    blink::WebMessagePortChannelArray* channels) {
+    blink::WebMessagePortChannelArray channels) {
   // This may send channels for MessagePorts, and all internal book-keeping
   // messages for MessagePort (e.g. QueueMessages) are sent from main thread
   // (with thread hopping), so we need to do the same thread hopping here not
   // to overtake those messages.
-  std::unique_ptr<blink::WebMessagePortChannelArray> channel_array(channels);
+  // TODO(darin): The above comment no longer makes sense. We can probably
+  // send from this thread now.
   main_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&SendPostMessageToClientOnMainThread,
                  base::RetainedRef(sender_), GetRoutingID(), uuid.utf8(),
-                 message.utf16(), base::Passed(&channel_array)));
+                 message.utf16(), base::Passed(&channels)));
 }
 
 void ServiceWorkerContextClient::focus(
     const blink::WebString& uuid,
     std::unique_ptr<blink::WebServiceWorkerClientCallbacks> callback) {
   DCHECK(callback);
   int request_id = context_->client_callbacks.Add(std::move(callback));
   Send(new ServiceWorkerHostMsg_FocusClient(GetRoutingID(), request_id,
                                             uuid.utf8()));
 }
@@ skipping 93 matching lines @@
 
 void ServiceWorkerContextClient::DispatchExtendableMessageEvent(
     mojom::ExtendableMessageEventPtr event,
     const DispatchExtendableMessageEventCallback& callback) {
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerContextClient::DispatchExtendableMessageEvent");
   int request_id = context_->message_event_callbacks.Add(
       base::MakeUnique<DispatchExtendableMessageEventCallback>(callback));
 
   blink::WebMessagePortChannelArray ports =
-      WebMessagePortChannelImpl::CreatePorts(event->message_ports,
-                                             event->new_routing_ids,
-                                             main_thread_task_runner_);
+      WebMessagePortChannelImpl::CreateFromMessagePipeHandles(
+          std::move(event->message_ports));
   if (event->source.client_info.IsValid()) {
     blink::WebServiceWorkerClientInfo web_client =
         ToWebServiceWorkerClientInfo(event->source.client_info);
     proxy_->dispatchExtendableMessageEvent(
         request_id, blink::WebString::fromUTF16(event->message),
-        event->source_origin, ports, web_client);
+        event->source_origin, std::move(ports), web_client);
     return;
   }
 
   DCHECK(event->source.service_worker_info.IsValid());
   std::unique_ptr<ServiceWorkerHandleReference> handle =
       ServiceWorkerHandleReference::Adopt(event->source.service_worker_info,
                                           sender_.get());
   ServiceWorkerDispatcher* dispatcher =
       ServiceWorkerDispatcher::GetOrCreateThreadSpecificInstance(
           sender_.get(), main_thread_task_runner_.get());
   scoped_refptr<WebServiceWorkerImpl> worker =
       dispatcher->GetOrCreateServiceWorker(std::move(handle));
   proxy_->dispatchExtendableMessageEvent(
       request_id, blink::WebString::fromUTF16(event->message),
-      event->source_origin, ports, WebServiceWorkerImpl::CreateHandle(worker));
+      event->source_origin, std::move(ports),
+      WebServiceWorkerImpl::CreateHandle(worker));
 }
 
 void ServiceWorkerContextClient::OnInstallEvent(int request_id) {
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerContextClient::OnInstallEvent");
   proxy_->dispatchInstallEvent(request_id);
 }
 
 void ServiceWorkerContextClient::DispatchFetchEvent(
     int fetch_event_id,
@@ skipping 298 matching lines @@
 }
 
 base::WeakPtr<ServiceWorkerContextClient>
 ServiceWorkerContextClient::GetWeakPtr() {
   DCHECK(worker_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(context_);
   return context_->weak_factory.GetWeakPtr();
 }
 
 }  // namespace content