WIP DO NOT COMMIT chromium side of navigator.connect

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 "base/command_line.h"
 #include "base/stl_util.h"
 #include "base/strings/string16.h"
 #include "content/browser/message_port_message_filter.h"
@@ skipping 71 matching lines @@
   task.Run();
 }
 
 void RunErrorFetchCallback(const ServiceWorkerVersion::FetchCallback& callback,
                            ServiceWorkerStatusCode status) {
   callback.Run(status,
                SERVICE_WORKER_FETCH_EVENT_RESULT_FALLBACK,
                ServiceWorkerResponse());
 }
 
+void RunErrorCrossOriginConnectCallback(
+    const ServiceWorkerVersion::CrossOriginConnectCallback& callback,
+    ServiceWorkerStatusCode status) {
+  callback.Run(status, false);
+}
+
 void RunErrorMessageCallback(
     const std::vector<int>& sent_message_port_ids,
     const ServiceWorkerVersion::StatusCallback& callback,
     ServiceWorkerStatusCode status) {
   // Transfering the message ports failed, so destroy the ports.
   for (int message_port_id : sent_message_port_ids) {
     MessagePortService::GetInstance()->ClosePort(message_port_id);
   }
   callback.Run(status);
 }
@@ skipping 188 matching lines @@
       embedded_worker_->message_port_message_filter();
   std::vector<int> new_routing_ids;
   filter->UpdateMessagePortsWithNewRoutes(sent_message_port_ids,
                                           &new_routing_ids);
   ServiceWorkerStatusCode status =
       embedded_worker_->SendMessage(ServiceWorkerMsg_MessageToWorker(
           message, sent_message_port_ids, new_routing_ids));
   RunSoon(base::Bind(callback, status));
 }
 
+void ServiceWorkerVersion::SendCrossOriginMessage(
+    const CrossOriginServiceWorkerClient& client,
+    const base::string16& message,
+    const std::vector<int>& sent_message_port_ids,
+    const ServiceWorkerVersion::StatusCallback& callback) {
+  if (running_status() != RUNNING) {
+    // Schedule calling this method after starting the worker.
+    StartWorker(base::Bind(
+        &RunTaskAfterStartWorker, weak_factory_.GetWeakPtr(), callback,
+        base::Bind(&self::SendCrossOriginMessage, weak_factory_.GetWeakPtr(),
+                   client, message, sent_message_port_ids, callback)));
+    return;
+  }
+
+  MessagePortMessageFilter* filter =
+      embedded_worker_->message_port_message_filter();
+  std::vector<int> new_routing_ids;
+  filter->UpdateMessagePortsWithNewRoutes(sent_message_port_ids,
+                                          &new_routing_ids);
+  ServiceWorkerStatusCode status =
+      embedded_worker_->SendMessage(ServiceWorkerMsg_CrossOriginMessageToWorker(
+          client, message, sent_message_port_ids, new_routing_ids));
+  RunSoon(base::Bind(callback, status));
+}
+
 void ServiceWorkerVersion::DispatchInstallEvent(
     int active_version_id,
     const StatusCallback& callback) {
   DCHECK_EQ(INSTALLING, status()) << status();
 
   if (running_status() != RUNNING) {
     // Schedule calling this method after starting the worker.
     StartWorker(
         base::Bind(&RunTaskAfterStartWorker,
                    weak_factory_.GetWeakPtr(),
@@ skipping 175 matching lines @@
   int request_id = geofencing_callbacks_.Add(new StatusCallback(callback));
   ServiceWorkerStatusCode status =
       embedded_worker_->SendMessage(ServiceWorkerMsg_GeofencingEvent(
           request_id, event_type, region_id, region));
   if (status != SERVICE_WORKER_OK) {
     geofencing_callbacks_.Remove(request_id);
     RunSoon(base::Bind(callback, status));
   }
 }
 
+void ServiceWorkerVersion::DispatchCrossOriginConnectEvent(
+    const CrossOriginConnectCallback& callback,
+    const GURL& target_url,
+    int message_port_id) {
+  DCHECK_EQ(ACTIVATED, status()) << status();
+
+  if (!CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kEnableExperimentalWebPlatformFeatures)) {
+    callback.Run(SERVICE_WORKER_ERROR_ABORT, false);
+    return;
+  }
+
+  if (running_status() != RUNNING) {
+    // Schedule calling this method after starting the worker.
+    StartWorker(
+        base::Bind(&RunTaskAfterStartWorker, weak_factory_.GetWeakPtr(),
+                   base::Bind(&RunErrorCrossOriginConnectCallback, callback),
+                   base::Bind(&self::DispatchCrossOriginConnectEvent,
+                              weak_factory_.GetWeakPtr(), callback, target_url,
+                              message_port_id)));
+    return;
+  }
+
+  int request_id = cross_origin_connect_callbacks_.Add(
+      new CrossOriginConnectCallback(callback));
+  ServiceWorkerStatusCode status =
+      embedded_worker_->SendMessage(ServiceWorkerMsg_CrossOriginConnectEvent(
+          request_id,
+          CrossOriginServiceWorkerClient(target_url, message_port_id)));
+  if (status != SERVICE_WORKER_OK) {
+    cross_origin_connect_callbacks_.Remove(request_id);
+    RunSoon(base::Bind(callback, status, false));
+  }
+}
+
 void ServiceWorkerVersion::AddControllee(
     ServiceWorkerProviderHost* provider_host) {
   DCHECK(!ContainsKey(controllee_map_, provider_host));
   int controllee_id = controllee_by_id_.Add(provider_host);
   controllee_map_[provider_host] = controllee_id;
   if (stop_worker_timer_.IsRunning())
     stop_worker_timer_.Stop();
 }
 
 void ServiceWorkerVersion::RemoveControllee(
@@ skipping 120 matching lines @@
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_FetchEventFinished,
                         OnFetchEventFinished)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_SyncEventFinished,
                         OnSyncEventFinished)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_NotificationClickEventFinished,
                         OnNotificationClickEventFinished)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_PushEventFinished,
                         OnPushEventFinished)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_GeofencingEventFinished,
                         OnGeofencingEventFinished)
+    IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_CrossOriginConnectEventFinished,
+                        OnCrossOriginConnectEventFinished)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_PostMessageToDocument,
                         OnPostMessageToDocument)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void ServiceWorkerVersion::OnStartMessageSent(
     ServiceWorkerStatusCode status) {
   if (status != SERVICE_WORKER_OK)
@@ skipping 169 matching lines @@
   if (!callback) {
     NOTREACHED() << "Got unexpected message: " << request_id;
     return;
   }
 
   scoped_refptr<ServiceWorkerVersion> protect(this);
   callback->Run(SERVICE_WORKER_OK);
   geofencing_callbacks_.Remove(request_id);
 }
 
+void ServiceWorkerVersion::OnCrossOriginConnectEventFinished(
+    int request_id,
+    bool allow_connect) {
+  TRACE_EVENT1("ServiceWorker",
+               "ServiceWorkerVersion::OnCrossOriginConnectEventFinished",
+               "Request id", request_id);
+  CrossOriginConnectCallback* callback =
+      cross_origin_connect_callbacks_.Lookup(request_id);
+  if (!callback) {
+    NOTREACHED() << "Got unexpected message: " << request_id;
+    return;
+  }
+
+  scoped_refptr<ServiceWorkerVersion> protect(this);
+  callback->Run(SERVICE_WORKER_OK, allow_connect);
+  cross_origin_connect_callbacks_.Remove(request_id);
+}
+
 void ServiceWorkerVersion::OnPostMessageToDocument(
     int client_id,
     const base::string16& message,
     const std::vector<int>& sent_message_port_ids) {
   TRACE_EVENT1("ServiceWorker",
                "ServiceWorkerVersion::OnPostMessageToDocument",
                "Client id", client_id);
   ServiceWorkerProviderHost* provider_host =
       controllee_by_id_.Lookup(client_id);
   if (!provider_host) {
@@ skipping 22 matching lines @@
   SetStatus(REDUNDANT);
   StopWorker(base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
   if (!context_)
     return;
   std::vector<ServiceWorkerDatabase::ResourceRecord> resources;
   script_cache_map_.GetResources(&resources);
   context_->storage()->PurgeResources(resources);
 }
 
 }  // namespace content