Add a mojo ServiceRegistry to embedded workers.

content/browser/service_worker/embedded_worker_instance.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/embedded_worker_instance.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind_helpers.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/threading/non_thread_safe.h"
 #include "base/trace_event/trace_event.h"
 #include "content/browser/devtools/service_worker_devtools_manager.h"
 #include "content/browser/service_worker/embedded_worker_registry.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/common/content_switches_internal.h"
+#include "content/common/mojo/service_registry_impl.h"
 #include "content/common/service_worker/embedded_worker_messages.h"
+#include "content/common/service_worker/embedded_worker_setup.mojom.h"
 #include "content/common/service_worker/service_worker_types.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_process_host.h"
 #include "ipc/ipc_message.h"
 #include "url/gurl.h"
 
 namespace content {
 
 namespace {
 
@@ skipping 47 matching lines @@
                 service_worker_context_weak,
                 service_worker_version_id,
                 url));
   }
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(callback, worker_devtools_agent_route_id, wait_for_debugger));
 }
 
+void SetupMojoOnUIThread(int process_id,
+                         int thread_id,
+                         mojo::InterfaceRequest<mojo::ServiceProvider> services,
+                         mojo::ServiceProviderPtr exposed_services) {
+  RenderProcessHost* rph = RenderProcessHost::FromID(process_id);
+  // |rph| may be NULL in unit tests.
+  if (!rph)
+    return;
+  EmbeddedWorkerSetupPtr setup;
+  rph->GetServiceRegistry()->ConnectToRemoteService(mojo::GetProxy(&setup));
+  setup->ExchangeServiceProviders(thread_id, services.Pass(),
+                                  exposed_services.Pass());
+}
+
 }  // namespace
 
 // Lives on IO thread, proxies notifications to DevToolsManager that lives on
 // UI thread. Owned by EmbeddedWorkerInstance.
 class EmbeddedWorkerInstance::DevToolsProxy : public base::NonThreadSafe {
  public:
   DevToolsProxy(int process_id, int agent_route_id)
       : process_id_(process_id),
         agent_route_id_(agent_route_id) {}
 
@@ skipping 99 matching lines @@
 ServiceWorkerStatusCode EmbeddedWorkerInstance::SendMessage(
     const IPC::Message& message) {
   DCHECK_NE(kInvalidEmbeddedWorkerThreadId, thread_id_);
   if (status_ != RUNNING && status_ != STARTING)
     return SERVICE_WORKER_ERROR_IPC_FAILED;
   return registry_->Send(process_id_,
                          new EmbeddedWorkerContextMsg_MessageToWorker(
                              thread_id_, embedded_worker_id_, message));
 }
 
+ServiceRegistry* EmbeddedWorkerInstance::GetServiceRegistry() {

[michaeln, 2015/07/15 02:34:22]

Maybe DCHECK its either STARTING or RUNNING and service_registry_ is not null.

But as coded, I think that DCHECK would trip? The EmbeddedWorkerInstance goes
into the STARTING state in the Start() method, a whole lot happens prior to
OnScriptLoaded() running which is where the ServiceRegistry is being created.

Is it possible to create it and BindRemoteServiceProvider() here, and defer
SetupMojoOnUIThread until after the script has loaded? Or maybe just say "please
only call GetServiceRegistry() when its RUNNING."?

[Marijn Kruisselbrink, 2015/07/15 18:13:28]

I added the DCHECK and moved the creating of the service_registry_ to the
Start() method. ServiceRegistry will just queue up any connection attempts until
it is bound to a remote service provider, so trying to use it before
SetupMojoOnUIThread is called works in that calls will eventually resolve
(assuming the worker actually starts). Creating the ServiceRegistry on demand
here in the getter would of course also work, but since it's always going to be
created anyway (and is fairly lightweight) I don't think that really gains us
much.

+  return service_registry_.get();
+}
+
 EmbeddedWorkerInstance::EmbeddedWorkerInstance(
     base::WeakPtr<ServiceWorkerContextCore> context,
     int embedded_worker_id)
     : context_(context),
       registry_(context->embedded_worker_registry()),
       embedded_worker_id_(embedded_worker_id),
       status_(STOPPED),
       starting_phase_(NOT_STARTING),
       process_id_(-1),
       thread_id_(kInvalidEmbeddedWorkerThreadId),
@@ skipping 122 matching lines @@
       UMA_HISTOGRAM_TIMES(
           "EmbeddedWorkerInstance.ScriptLoadWithoutNetworkAccess",
           base::TimeTicks::Now() - start_timing_);
     }
     // Reset |start_timing_| to measure the time excluding the process
     // allocation time and the script loading time.
     start_timing_ = base::TimeTicks::Now();
   }
   thread_id_ = thread_id;
   FOR_EACH_OBSERVER(Listener, listener_list_, OnScriptLoaded());
+
+  service_registry_.reset(new ServiceRegistryImpl());
+  mojo::ServiceProviderPtr exposed_services;
+  service_registry_->Bind(GetProxy(&exposed_services));
+  mojo::ServiceProviderPtr services;
+  mojo::InterfaceRequest<mojo::ServiceProvider> services_request =
+      GetProxy(&services);
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(SetupMojoOnUIThread, process_id_, thread_id_,
+                 base::Passed(&services_request),
+                 base::Passed(&exposed_services)));
+  service_registry_->BindRemoteServiceProvider(services.Pass());
 }
 
 void EmbeddedWorkerInstance::OnScriptLoadFailed() {
 }
 
 void EmbeddedWorkerInstance::OnScriptEvaluated(bool success) {
   starting_phase_ = SCRIPT_EVALUATED;
   if (start_callback_.is_null()) {
     DVLOG(1) << "Received unexpected OnScriptEvaluated message.";
     return;
@@ skipping 12 matching lines @@
   if (status_ == STOPPING)
     return;
   DCHECK(status_ == STARTING);
   status_ = RUNNING;
   FOR_EACH_OBSERVER(Listener, listener_list_, OnStarted());
 }
 
 void EmbeddedWorkerInstance::OnStopped() {
   Status old_status = status_;
   ReleaseProcess();
+  service_registry_.reset();
   FOR_EACH_OBSERVER(Listener, listener_list_, OnStopped(old_status));
 }
 
 void EmbeddedWorkerInstance::OnDetached() {
   Status old_status = status_;
   ReleaseProcess();

[michaeln, 2015/07/15 02:34:22]

probably should reset the registry here too, looks like ReleaseProcess() is the
probably the best place to do this

[Marijn Kruisselbrink, 2015/07/15 18:13:28]

Yes, moved the resetting of the registry to ReleaseProcess (and the one other
spot where Status can get set to STOPPED if starting it fails).

   FOR_EACH_OBSERVER(Listener, listener_list_, OnDetached(old_status));
 }
 
 bool EmbeddedWorkerInstance::OnMessageReceived(const IPC::Message& message) {
   ListenerList::Iterator it(&listener_list_);
   while (Listener* listener = it.GetNext()) {
     if (listener->OnMessageReceived(message))
       return true;
   }
   return false;
@@ skipping 91 matching lines @@
     case SCRIPT_EVALUATED:
       return "Script evaluated";
     case STARTING_PHASE_MAX_VALUE:
       NOTREACHED();
   }
   NOTREACHED() << phase;
   return std::string();
 }
 
 }  // namespace content