WIP DO NOT COMMIT chromium side of navigator.connect

content/renderer/service_worker/service_worker_script_context.cc

 // Copyright 2014 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_script_context.h"
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
+#include "content/child/service_worker/web_cross_origin_service_worker_client_impl.h"
 #include "content/child/thread_safe_sender.h"
 #include "content/child/webmessageportchannel_impl.h"
+#include "content/common/message_port_messages.h"
 #include "content/common/service_worker/service_worker_messages.h"
 #include "content/renderer/service_worker/embedded_worker_context_client.h"
 #include "ipc/ipc_message.h"
 #include "third_party/WebKit/public/platform/WebNotificationData.h"
 #include "third_party/WebKit/public/platform/WebReferrerPolicy.h"
 #include "third_party/WebKit/public/platform/WebServiceWorkerRequest.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
 #include "third_party/WebKit/public/web/WebServiceWorkerContextClient.h"
 #include "third_party/WebKit/public/web/WebServiceWorkerContextProxy.h"
 
 namespace content {
 
 namespace {
 
 void SendPostMessageToDocumentOnMainThread(
     ThreadSafeSender* sender,
     int routing_id,
     int client_id,
     const base::string16& message,
     scoped_ptr<blink::WebMessagePortChannelArray> channels) {
   sender->Send(new ServiceWorkerHostMsg_PostMessageToDocument(
       routing_id, client_id, message,
       WebMessagePortChannelImpl::ExtractMessagePortIDs(channels.release())));
 }
 
+void SendCrossOriginMessageOnMainThread(
+    ThreadSafeSender* sender,
+    int message_port_id,
+    const base::string16& message,
+    scoped_ptr<blink::WebMessagePortChannelArray> channels) {
+  sender->Send(new MessagePortHostMsg_PostMessage(
+      message_port_id, message,
+      WebMessagePortChannelImpl::ExtractMessagePortIDs(channels.release())));
+}
+
 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>(
       credentials_mode);
 }
@@ skipping 24 matching lines @@
 void ServiceWorkerScriptContext::OnMessageReceived(
     const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ServiceWorkerScriptContext, message)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_ActivateEvent, OnActivateEvent)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_FetchEvent, OnFetchEvent)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_InstallEvent, OnInstallEvent)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_SyncEvent, OnSyncEvent)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_PushEvent, OnPushEvent)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_GeofencingEvent, OnGeofencingEvent)
+    IPC_MESSAGE_HANDLER(ServiceWorkerMsg_CrossOriginConnectEvent,
+                        OnCrossOriginConnectEvent)
+    IPC_MESSAGE_HANDLER(ServiceWorkerMsg_CrossOriginMessageToWorker,
+                        OnCrossOriginMessageToWorker)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_MessageToWorker, OnPostMessage)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_DidGetClientDocuments,
                         OnDidGetClientDocuments)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   // TODO(gavinp): Would it be preferable to put an AddListener() method to
   // EmbeddedWorkerContextClient?
   if (!handled)
     handled = cache_storage_dispatcher_->OnMessageReceived(message);
@@ skipping 62 matching lines @@
 
   Send(new ServiceWorkerHostMsg_PushEventFinished(
       GetRoutingID(), request_id, result));
 }
 
 void ServiceWorkerScriptContext::DidHandleSyncEvent(int request_id) {
   Send(new ServiceWorkerHostMsg_SyncEventFinished(
       GetRoutingID(), request_id));
 }
 
+void ServiceWorkerScriptContext::DidHandleCrossOriginConnectEvent(
+    int request_id,
+    bool allow_connect) {
+  Send(new ServiceWorkerHostMsg_CrossOriginConnectEventFinished(
+      GetRoutingID(), request_id, allow_connect));
+}
+
 void ServiceWorkerScriptContext::GetClientDocuments(
     blink::WebServiceWorkerClientsCallbacks* callbacks) {
   DCHECK(callbacks);
   int request_id = pending_clients_callbacks_.Add(callbacks);
   Send(new ServiceWorkerHostMsg_GetClientDocuments(
       GetRoutingID(), request_id));
 }
 
 void ServiceWorkerScriptContext::PostMessageToDocument(
     int client_id,
     const base::string16& message,
     scoped_ptr<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.
   embedded_context_->main_thread_proxy()->PostTask(
       FROM_HERE,
       base::Bind(&SendPostMessageToDocumentOnMainThread,
                  make_scoped_refptr(embedded_context_->thread_safe_sender()),
                  GetRoutingID(), client_id, message, base::Passed(&channels)));
 }
 
+void ServiceWorkerScriptContext::PostCrossOriginMessage(
+    WebCrossOriginServiceWorkerClientImpl* client,
+    const base::string16& message,
+    scoped_ptr<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.
+  embedded_context_->main_thread_proxy()->PostTask(
+      FROM_HERE,
+      base::Bind(&SendCrossOriginMessageOnMainThread,
+                 make_scoped_refptr(embedded_context_->thread_safe_sender()),
+                 client->message_port_id(), message, base::Passed(&channels)));
+}
+
 void ServiceWorkerScriptContext::Send(IPC::Message* message) {
   embedded_context_->Send(message);
 }
 
 int ServiceWorkerScriptContext::GetRoutingID() const {
   return embedded_context_->embedded_worker_id();
 }
 
 void ServiceWorkerScriptContext::OnActivateEvent(int request_id) {
   TRACE_EVENT0("ServiceWorker",
@@ skipping 76 matching lines @@
     const std::string& region_id,
     const blink::WebCircularGeofencingRegion& region) {
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerScriptContext::OnGeofencingEvent");
   proxy_->dispatchGeofencingEvent(
       request_id, event_type, blink::WebString::fromUTF8(region_id), region);
   Send(new ServiceWorkerHostMsg_GeofencingEventFinished(GetRoutingID(),
                                                         request_id));
 }
 
+void ServiceWorkerScriptContext::OnCrossOriginConnectEvent(
+    int request_id,
+    const CrossOriginServiceWorkerClient& client) {
+  TRACE_EVENT0("ServiceWorker",
+               "ServiceWorkerScriptContext::OnCrossOriginConnectEvent");
+  // base::MessageLoopProxy* loop_proxy =
+  // embedded_context_->main_thread_proxy();
+  blink::WebCrossOriginServiceWorkerClient* web_client =
+      new WebCrossOriginServiceWorkerClientImpl(client);
+  proxy_->dispatchCrossOriginConnectEvent(request_id, web_client);
+}
+
+void ServiceWorkerScriptContext::OnCrossOriginMessageToWorker(
+    const CrossOriginServiceWorkerClient& client,
+    const base::string16& message,
+    const std::vector<int>& sent_message_port_ids,
+    const std::vector<int>& new_routing_ids) {
+  TRACE_EVENT0("ServiceWorker",
+               "ServiceWorkerScriptContext::OnCrossOriginMessageToWorker");
+  std::vector<WebMessagePortChannelImpl*> ports;
+  if (!sent_message_port_ids.empty()) {
+    base::MessageLoopProxy* loop_proxy = embedded_context_->main_thread_proxy();
+    ports.resize(sent_message_port_ids.size());
+    for (size_t i = 0; i < sent_message_port_ids.size(); ++i) {
+      ports[i] = new WebMessagePortChannelImpl(
+          new_routing_ids[i], sent_message_port_ids[i], loop_proxy);
+    }
+  }
+
+  blink::WebCrossOriginServiceWorkerClient* web_client =
+      new WebCrossOriginServiceWorkerClientImpl(client);
+  proxy_->dispatchCrossOriginMessageEvent(web_client, message, ports);
+}
+
 void ServiceWorkerScriptContext::OnPostMessage(
     const base::string16& message,
     const std::vector<int>& sent_message_port_ids,
     const std::vector<int>& new_routing_ids) {
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerScriptContext::OnPostEvent");
   std::vector<WebMessagePortChannelImpl*> ports;
   if (!sent_message_port_ids.empty()) {
     base::MessageLoopProxy* loop_proxy = embedded_context_->main_thread_proxy();
     ports.resize(sent_message_port_ids.size());
@@ skipping 23 matching lines @@
     return;
   }
   scoped_ptr<blink::WebServiceWorkerClientsInfo> info(
       new blink::WebServiceWorkerClientsInfo);
   info->clientIDs = client_ids;
   callbacks->onSuccess(info.release());
   pending_clients_callbacks_.Remove(request_id);
 }
 
 }  // namespace content