Enable messaging over a navigator.connect initiated channel.

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/memory/ref_counted.h"
 #include "base/stl_util.h"
 #include "base/strings/string16.h"
@@ skipping 573 matching lines @@
   int request_id = cross_origin_connect_callbacks_.Add(
       new CrossOriginConnectCallback(callback));
   ServiceWorkerStatusCode status = embedded_worker_->SendMessage(
       ServiceWorkerMsg_CrossOriginConnectEvent(request_id, client));
   if (status != SERVICE_WORKER_OK) {
     cross_origin_connect_callbacks_.Remove(request_id);
     RunSoon(base::Bind(callback, status, false));
   }
 }
 
+void ServiceWorkerVersion::DispatchCrossOriginMessageEvent(
+    const CrossOriginServiceWorkerClient& client,
+    const base::string16& message,
+    const std::vector<int>& sent_message_port_ids,
+    const StatusCallback& callback) {
+  // Unlike in the case of DispatchMessageEvent, here the caller is assumed to
+  // have already put all the sent message ports on hold. So no need to do that
+  // here again.
+
+  if (running_status() != RUNNING) {
+    // Schedule calling this method after starting the worker.
+    StartWorker(base::Bind(
+        &RunTaskAfterStartWorker, weak_factory_.GetWeakPtr(), callback,
+        base::Bind(&self::DispatchCrossOriginMessageEvent,
+                   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::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;
   // Reset the timer if it's running (so that it's kept alive a bit longer
   // right after a new controllee is added).
   ScheduleStopWorker();
 }
 
@@ skipping 504 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