Update navigator.services API to use the new services.onconnect event [2/3].

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/location.h"
 #include "base/memory/ref_counted.h"
 #include "base/metrics/histogram_macros.h"
@@ skipping 144 matching lines @@
     const std::vector<TransferredMessagePort>& sent_message_ports,
     const ServiceWorkerVersion::StatusCallback& callback,
     ServiceWorkerStatusCode status) {
   // Transfering the message ports failed, so destroy the ports.
   for (const TransferredMessagePort& port : sent_message_ports) {
     MessagePortService::GetInstance()->ClosePort(port.id);
   }
   callback.Run(status);
 }
 
-void RunErrorCrossOriginConnectCallback(
-    const ServiceWorkerVersion::CrossOriginConnectCallback& callback,
+void RunErrorServicePortConnectCallback(
+    const ServiceWorkerVersion::ServicePortConnectCallback& callback,
     ServiceWorkerStatusCode status) {
-  callback.Run(status, false /* accept_connection */);
+  callback.Run(status, false /* accept_connection */, base::string16(),
+               base::string16());
 }
 
 void RunErrorSendStashedPortsCallback(
     const ServiceWorkerVersion::SendStashedPortsCallback& callback,
     ServiceWorkerStatusCode status) {
   callback.Run(status, std::vector<int>());
 }
 
 using WindowOpenedCallback = base::Callback<void(int, int)>;
 
@@ skipping 711 matching lines @@
       AddRequest(callback, &geofencing_callbacks_, REQUEST_GEOFENCING);
   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 NavigatorConnectClient& client) {
+void ServiceWorkerVersion::DispatchServicePortConnectEvent(
+    const ServicePortConnectCallback& callback,
+    const GURL& target_url,
+    const GURL& origin,
+    int port_id) {
   DCHECK_EQ(ACTIVATED, status()) << status();
 
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableExperimentalWebPlatformFeatures)) {
-    callback.Run(SERVICE_WORKER_ERROR_ABORT, false);
+    callback.Run(SERVICE_WORKER_ERROR_ABORT, false, base::string16(),
+                 base::string16());
     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, client)));
+                   base::Bind(&RunErrorServicePortConnectCallback, callback),
+                   base::Bind(&self::DispatchServicePortConnectEvent,
+                              weak_factory_.GetWeakPtr(), callback, target_url,
+                              origin, port_id)));
     return;
   }
 
-  int request_id = AddRequest(callback, &cross_origin_connect_callbacks_,
-                              REQUEST_CROSS_ORIGIN_CONNECT);
-  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));
+  int request_id = AddRequest(callback, &service_port_connect_callbacks_,
+                              REQUEST_SERVICE_PORT_CONNECT);
+  if (!service_port_dispatcher_) {
+    embedded_worker_->GetServiceRegistry()->ConnectToRemoteService(

[iclelland, 2015/07/08 02:59:29]

This looks to me like it has the same problem as one of my earlier proposals for
DispatchSyncEvent -- that the ServiceWorkerVersion may outlive any given worker
thread -- I think that service_port_dispatcher_ here will be set once, and never
reset if the worker thread dies. The solution in the Sync case was to move the
mojo connection from the ServiceWorkerVersion to the
ServiceWorkerDispatcherHost.

(see michaeln's comment at
https://codereview.chromium.org/1171173002/diff/410001/content/browser/servic...
)

+        mojo::GetProxy(&service_port_dispatcher_));
+    service_port_dispatcher_.set_connection_error_handler(
+        base::Bind(&ServiceWorkerVersion::OnMojoConnectionError<
+                       ServicePortDispatcher, ServicePortConnectCallback>,
+                   weak_factory_.GetWeakPtr(), &service_port_dispatcher_,
+                   &service_port_connect_callbacks_,
+                   base::Bind(&RunErrorServicePortConnectCallback)));
   }
+  service_port_dispatcher_->Connect(

[michaeln, 2015/07/07 22:13:17]

What happens to service_port_dispatcher_ when the embedded instance 'stops' and
then is started in a new process?

[Marijn Kruisselbrink, 2015/07/07 23:58:42]

Hmm, good question. I seem to have assumed that that would automatically sever
the connection, thus causing service_port_dispatcher_ to call its connection
error handler, but I think you're right that either OnStoppedInternal or some
method like that should sever these connections on the browser side, or
ServicePortDispatcherImpl would have to destroy itself/sever the connection when
the embedded worker it "belongs" to is stopped.

[iclelland, 2015/07/08 02:59:29]

I took a closer look at this last week, since I had a draft message asking
essentially the same thing. As far as I can tell, when the embedded worker
stops, the connection will be shut down automatically, and the InterfacePtr will
test as false the next time that DispatchCrossOriginConnectEvent is called. (see
https://code.google.com/p/chromium/codesearch#chromium/src/third_party/mojo/s...)
If there are outstanding callbacks, then the connection error handler will be
called first.
I'd like to test this behaviour, and probably loop someone like rockot@ in to
make sure it's okay, but I think it's correct.

+      mojo::String::From(target_url), mojo::String::From(origin), port_id,
+      base::Bind(&ServiceWorkerVersion::OnServicePortConnectEventFinished,
+                 weak_factory_.GetWeakPtr(), request_id));
 }
 
 void ServiceWorkerVersion::DispatchCrossOriginMessageEvent(
     const NavigatorConnectClient& client,
     const base::string16& message,
     const std::vector<TransferredMessagePort>& sent_message_ports,
     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.
@@ skipping 247 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_OpenWindow,
                         OnOpenWindow)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_SetCachedMetadata,
                         OnSetCachedMetadata)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_ClearCachedMetadata,
                         OnClearCachedMetadata)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_PostMessageToClient,
                         OnPostMessageToClient)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_FocusClient,
                         OnFocusClient)
@@ skipping 222 matching lines @@
   if (!callback) {
     NOTREACHED() << "Got unexpected message: " << request_id;
     return;
   }
 
   scoped_refptr<ServiceWorkerVersion> protect(this);
   callback->Run(SERVICE_WORKER_OK);
   RemoveCallbackAndStopIfRedundant(&geofencing_callbacks_, request_id);
 }
 
-void ServiceWorkerVersion::OnCrossOriginConnectEventFinished(
+void ServiceWorkerVersion::OnServicePortConnectEventFinished(
     int request_id,
-    bool accept_connection) {
+    ServicePortConnectResult result,
+    const mojo::String& name,
+    const mojo::String& data) {
   TRACE_EVENT1("ServiceWorker",
-               "ServiceWorkerVersion::OnCrossOriginConnectEventFinished",
+               "ServiceWorkerVersion::OnServicePortConnectEventFinished",
                "Request id", request_id);
-  CrossOriginConnectCallback* callback =
-      cross_origin_connect_callbacks_.Lookup(request_id);
+  ServicePortConnectCallback* callback =
+      service_port_connect_callbacks_.Lookup(request_id);
   if (!callback) {
     NOTREACHED() << "Got unexpected message: " << request_id;
     return;
   }
 
   scoped_refptr<ServiceWorkerVersion> protect(this);
-  callback->Run(SERVICE_WORKER_OK, accept_connection);
-  RemoveCallbackAndStopIfRedundant(&cross_origin_connect_callbacks_,
+  callback->Run(SERVICE_WORKER_OK, result == SERVICE_PORT_CONNECT_RESULT_ACCEPT,
+                name.To<base::string16>(), data.To<base::string16>());
+  RemoveCallbackAndStopIfRedundant(&service_port_connect_callbacks_,
                                    request_id);
 }
 
 void ServiceWorkerVersion::OnOpenWindow(int request_id, GURL url) {
   // Just abort if we are shutting down.
   if (!context_)
     return;
 
   if (!url.is_valid()) {
     DVLOG(1) << "Received unexpected invalid URL from renderer process.";
@@ skipping 477 matching lines @@
     return;
   }
 
   // TODO(falken): We may need to handle StopIfIdle failure and
   // forcibly fail pending callbacks so no one is stuck waiting
   // for the worker.
   embedded_worker_->StopIfIdle();
 }
 
 bool ServiceWorkerVersion::HasInflightRequests() const {
-  return
-    !activate_callbacks_.IsEmpty() ||
-    !install_callbacks_.IsEmpty() ||
-    !fetch_callbacks_.IsEmpty() ||
-    !sync_callbacks_.IsEmpty() ||
-    !notification_click_callbacks_.IsEmpty() ||
-    !push_callbacks_.IsEmpty() ||
-    !geofencing_callbacks_.IsEmpty() ||
-    !cross_origin_connect_callbacks_.IsEmpty() ||
-    !streaming_url_request_jobs_.empty();
+  return !activate_callbacks_.IsEmpty() || !install_callbacks_.IsEmpty() ||
+         !fetch_callbacks_.IsEmpty() || !sync_callbacks_.IsEmpty() ||
+         !notification_click_callbacks_.IsEmpty() ||
+         !push_callbacks_.IsEmpty() || !geofencing_callbacks_.IsEmpty() ||
+         !service_port_connect_callbacks_.IsEmpty() ||
+         !streaming_url_request_jobs_.empty();
 }
 
 void ServiceWorkerVersion::RecordStartWorkerResult(
     ServiceWorkerStatusCode status) {
   base::TimeTicks start_time = start_time_;
   ClearTick(&start_time_);
 
   ServiceWorkerMetrics::RecordStartWorkerStatus(status,
                                                 IsInstalled(prestart_status_));
 
@@ skipping 67 matching lines @@
                               SERVICE_WORKER_ERROR_TIMEOUT);
     case REQUEST_NOTIFICATION_CLICK:
       return RunIDMapCallback(&notification_click_callbacks_, info.id,
                               SERVICE_WORKER_ERROR_TIMEOUT);
     case REQUEST_PUSH:
       return RunIDMapCallback(&push_callbacks_, info.id,
                               SERVICE_WORKER_ERROR_TIMEOUT);
     case REQUEST_GEOFENCING:
       return RunIDMapCallback(&geofencing_callbacks_, info.id,
                               SERVICE_WORKER_ERROR_TIMEOUT);
-    case REQUEST_CROSS_ORIGIN_CONNECT:
-      return RunIDMapCallback(&cross_origin_connect_callbacks_, info.id,
+    case REQUEST_SERVICE_PORT_CONNECT:
+      return RunIDMapCallback(&service_port_connect_callbacks_, info.id,
                               SERVICE_WORKER_ERROR_TIMEOUT,
-                              false /* accept_connection */);
+                              false /* accept_connection */, base::string16(),
+                              base::string16());
   }
   NOTREACHED() << "Got unexpected request type: " << info.type;
   return false;
 }
 
 void ServiceWorkerVersion::SetAllRequestTimes(const base::TimeTicks& ticks) {
   std::queue<RequestInfo> new_requests;
   while (!requests_.empty()) {
     RequestInfo info = requests_.front();
     info.time = ticks;
@@ skipping 94 matching lines @@
   RunIDMapCallbacks(&install_callbacks_,
                     SERVICE_WORKER_ERROR_INSTALL_WORKER_FAILED);
   RunIDMapCallbacks(&fetch_callbacks_, SERVICE_WORKER_ERROR_FAILED,
                     SERVICE_WORKER_FETCH_EVENT_RESULT_FALLBACK,
                     ServiceWorkerResponse());
   RunIDMapCallbacks(&sync_callbacks_, SERVICE_WORKER_ERROR_FAILED);
   RunIDMapCallbacks(&notification_click_callbacks_,
                     SERVICE_WORKER_ERROR_FAILED);
   RunIDMapCallbacks(&push_callbacks_, SERVICE_WORKER_ERROR_FAILED);
   RunIDMapCallbacks(&geofencing_callbacks_, SERVICE_WORKER_ERROR_FAILED);
-  RunIDMapCallbacks(&cross_origin_connect_callbacks_,
-                    SERVICE_WORKER_ERROR_FAILED, false);
+  RunIDMapCallbacks(&service_port_connect_callbacks_,
+                    SERVICE_WORKER_ERROR_FAILED, false, base::string16(),
+                    base::string16());
 
   streaming_url_request_jobs_.clear();
 
   FOR_EACH_OBSERVER(Listener, listeners_, OnRunningStateChanged(this));
 
   if (should_restart)
     StartWorkerInternal(false /* pause_after_download */);
 }
 
+template <typename Interface, typename Callback>
+void ServiceWorkerVersion::OnMojoConnectionError(
+    mojo::InterfacePtr<Interface>* interface,
+    IDMap<Callback, IDMapOwnPointer>* callbacks,
+    const base::Callback<void(const Callback&, ServiceWorkerStatusCode)>
+        callback) {
+  typename IDMap<Callback, IDMapOwnPointer>::iterator iter(callbacks);
+  while (!iter.IsAtEnd()) {
+    callback.Run(*iter.GetCurrentValue(), SERVICE_WORKER_ERROR_FAILED);
+    iter.Advance();
+  }
+  callbacks->Clear();
+}
+
 }  // namespace content