First step to refactor ServiceWorkerVersion to make event dispatching more modular.

content/browser/navigator_connect/navigator_connect_context_impl.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/browser/navigator_connect/navigator_connect_context_impl.h"
 
 #include "content/browser/message_port_service.h"
 #include "content/browser/navigator_connect/service_port_service_impl.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
 #include "content/common/service_worker/service_worker_utils.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/navigator_connect_service_factory.h"
 #include "content/public/common/navigator_connect_client.h"
+#include "mojo/common/url_type_converters.h"
 
 namespace content {
 
 struct NavigatorConnectContextImpl::Port {
   // ID of this port.
   int id;
   // ID of the port this port is connected to.
   int entangled_id;
 
   // Service url and client origin describing this connection. These fields will
@@ skipping 106 matching lines @@
     int client_port_id,
     int service_port_id,
     ServiceWorkerStatusCode status,
     const scoped_refptr<ServiceWorkerRegistration>& registration) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(ports_.find(client_port_id) != ports_.end());
   DCHECK(ports_.find(service_port_id) != ports_.end());
 
   if (status != SERVICE_WORKER_OK) {
     // No service worker found, reject connection attempt.
-    OnConnectResult(callback, client_port_id, service_port_id, registration,
-                     status, false, base::string16(), base::string16());
+    OnConnectError(callback, client_port_id, service_port_id, status);
     return;
   }
 
   ServiceWorkerVersion* active_version = registration->active_version();
   DCHECK(active_version);
 
   Port& service_port = ports_[service_port_id];
   service_port.service_worker_registration_id = registration->id();
   service_port.service_worker_registration_origin =
       registration->pattern().GetOrigin();
 
-  active_version->DispatchServicePortConnectEvent(
+  active_version->RunAfterStartWorker(
+      base::Bind(&NavigatorConnectContextImpl::OnConnectError, this, callback,
+                 client_port_id, service_port_id),
+      base::Bind(&NavigatorConnectContextImpl::DispatchConnectEvent, this,
+                 callback, client_port_id, service_port_id, registration,
+                 make_scoped_refptr(active_version)));
+}
+
+void NavigatorConnectContextImpl::DispatchConnectEvent(
+    const ConnectCallback& callback,
+    int client_port_id,
+    int service_port_id,
+    const scoped_refptr<ServiceWorkerRegistration>& service_worker_registration,
+    const scoped_refptr<ServiceWorkerVersion>& worker) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DCHECK(ports_.find(client_port_id) != ports_.end());
+  DCHECK(ports_.find(service_port_id) != ports_.end());

[nhiroki, 2016/01/05 09:33:24]

nit: ContainsKey() in stl_util.h would be more readable.

DCHECK(ContainsKey(ports_, client_port_id));
DCHECK(ContainsKey(ports_, service_port_id));

[Marijn Kruisselbrink, 2016/01/05 23:23:16]

Done

+
+  const Port& service_port = ports_[service_port_id];
+  int request_id = worker->StartRequest(
+      base::Bind(&NavigatorConnectContextImpl::OnConnectError, this, callback,
+                 client_port_id, service_port_id));
+  base::WeakPtr<ServicePortDispatcher> dispatcher =
+      worker->GetMojoServiceForRequest<ServicePortDispatcher>(request_id);
+  dispatcher->Connect(
+      mojo::String::From(service_port.target_url),
+      mojo::String::From(service_port.client_origin), service_port_id,
       base::Bind(&NavigatorConnectContextImpl::OnConnectResult, this, callback,
-                 client_port_id, service_port_id, registration),
-      service_port.target_url, service_port.client_origin, service_port_id);
+                 client_port_id, service_port_id, service_worker_registration,
+                 worker, request_id));
 }
 
 void NavigatorConnectContextImpl::ServicePortServiceDestroyed(
     ServicePortServiceImpl* service_port_service) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   for (auto& port : ports_) {
     if (port.second.service != service_port_service)
       continue;
     port.second.service = nullptr;
     // TODO(mek): Should actually inform other side of connections that the
     // connection was closed, or in the case of service workers somehow keep
     // track of the connection.
   }
 }
 
+void NavigatorConnectContextImpl::OnConnectError(
+    const ConnectCallback& callback,
+    int client_port_id,
+    int service_port_id,
+    ServiceWorkerStatusCode status) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  // Destroy ports since connection failed.
+  ports_.erase(service_port_id);
+  ports_.erase(client_port_id);
+  callback.Run(MSG_ROUTING_NONE, false);
+}
+
 void NavigatorConnectContextImpl::OnConnectResult(
     const ConnectCallback& callback,
     int client_port_id,
     int service_port_id,
     const scoped_refptr<ServiceWorkerRegistration>& service_worker_registration,
-    ServiceWorkerStatusCode status,
-    bool accept_connection,
-    const base::string16& name,
-    const base::string16& data) {
+    const scoped_refptr<ServiceWorkerVersion>& worker,
+    int request_id,
+    ServicePortConnectResult result,
+    const mojo::String& name,
+    const mojo::String& data) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  if (accept_connection) {
-    // TODO(mek): Might have to do something else if the client connection got
-    // severed while the service side connection was being set up.
-    callback.Run(client_port_id, true);
-  } else {
-    // Destroy ports since connection failed.
-    ports_.erase(service_port_id);
-    ports_.erase(client_port_id);
-    callback.Run(MSG_ROUTING_NONE, false);
+
+  if (!worker->FinishRequest(request_id))
+    return;
+
+  if (result != SERVICE_PORT_CONNECT_RESULT_ACCEPT) {
+    OnConnectError(callback, client_port_id, service_port_id,
+                   SERVICE_WORKER_ERROR_FAILED);
+    return;
   }
+
+  // TODO(mek): Might have to do something else if the client connection got
+  // severed while the service side connection was being set up.
+  callback.Run(client_port_id, true);
 }
 
 void NavigatorConnectContextImpl::DeliverMessage(
     int port_id,
     const base::string16& message,
     const std::vector<TransferredMessagePort>& sent_message_ports,
     ServiceWorkerStatusCode service_worker_status,
     const scoped_refptr<ServiceWorkerRegistration>&
         service_worker_registration) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(ports_.find(port_id) != ports_.end());
 
   if (service_worker_status != SERVICE_WORKER_OK) {
     // TODO(mek): Do something when no service worker was found.
     return;
   }
 
   ServiceWorkerVersion* active_version =
       service_worker_registration->active_version();
   DCHECK(active_version);
 
   const Port& port = ports_[port_id];
   NavigatorConnectClient client(port.target_url, port.client_origin, port_id);
   active_version->DispatchCrossOriginMessageEvent(
       client, message, sent_message_ports,
       base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
 }
 
 }  // namespace content