Add a mojo ServiceRegistry to embedded workers.

content/renderer/render_thread_impl.cc

 // Copyright (c) 2012 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/renderer/render_thread_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <vector>
@@ skipping 49 matching lines @@
 #include "content/common/content_constants_internal.h"
 #include "content/common/database_messages.h"
 #include "content/common/dom_storage/dom_storage_messages.h"
 #include "content/common/frame_messages.h"
 #include "content/common/gpu/client/context_provider_command_buffer.h"
 #include "content/common/gpu/client/gpu_channel_host.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/common/gpu/gpu_process_launch_causes.h"
 #include "content/common/render_frame_setup.mojom.h"
 #include "content/common/resource_messages.h"
+#include "content/common/service_worker/embedded_worker_setup.mojom.h"
 #include "content/common/view_messages.h"
 #include "content/common/worker_messages.h"
 #include "content/public/common/content_constants.h"
 #include "content/public/common/content_paths.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/mojo_channel_switches.h"
 #include "content/public/common/renderer_preferences.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/renderer/content_renderer_client.h"
 #include "content/public/renderer/render_process_observer.h"
@@ skipping 23 matching lines @@
 #include "content/renderer/media/video_capture_impl_manager.h"
 #include "content/renderer/media/video_capture_message_filter.h"
 #include "content/renderer/net_info_helper.h"
 #include "content/renderer/p2p/socket_dispatcher.h"
 #include "content/renderer/render_frame_proxy.h"
 #include "content/renderer/render_process_impl.h"
 #include "content/renderer/render_view_impl.h"
 #include "content/renderer/renderer_blink_platform_impl.h"
 #include "content/renderer/scheduler/resource_dispatch_throttler.h"
 #include "content/renderer/service_worker/embedded_worker_dispatcher.h"
+#include "content/renderer/service_worker/service_worker_context_client.h"
 #include "content/renderer/service_worker/service_worker_context_message_filter.h"
 #include "content/renderer/shared_worker/embedded_shared_worker_stub.h"
 #include "gin/public/debug.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "ipc/ipc_channel_handle.h"
 #include "ipc/ipc_platform_file.h"
 #include "ipc/mojo/ipc_channel_mojo.h"
 #include "media/base/audio_hardware_config.h"
 #include "media/base/media.h"
@@ skipping 247 matching lines @@
 blink::WebGraphicsContext3D::Attributes GetOffscreenAttribs() {
   blink::WebGraphicsContext3D::Attributes attributes;
   attributes.shareResources = true;
   attributes.depth = false;
   attributes.stencil = false;
   attributes.antialias = false;
   attributes.noAutomaticFlushes = true;
   return attributes;
 }
 
+void SetupEmbeddedWorkerOnWorkerThread(
+    mojo::InterfaceRequest<mojo::ServiceProvider> services,
+    mojo::ServiceProviderPtr exposed_services) {
+  ServiceWorkerContextClient* client =
+      ServiceWorkerContextClient::ThreadSpecificInstance();
+  DCHECK(client);

[kinuko, 2015/07/08 08:32:41]

It feels it's possible to end up with null client here if the worker gets killed
while all these thread hopping is happening on both processes?

+  client->BindServiceRegistry(services.Pass(), exposed_services.Pass());
+}
+
+class EmbeddedWorkerSetupImpl : public EmbeddedWorkerSetup {
+ public:
+  explicit EmbeddedWorkerSetupImpl(
+      mojo::InterfaceRequest<EmbeddedWorkerSetup> request)
+      : binding_(this, request.Pass()) {}
+
+  void ExchangeServiceProviders(
+      int32_t thread_id,
+      mojo::InterfaceRequest<mojo::ServiceProvider> services,
+      mojo::ServiceProviderPtr exposed_services) override {
+    WorkerTaskRunner::Instance()->GetTaskRunnerFor(thread_id)->PostTask(
+        FROM_HERE,
+        base::Bind(&SetupEmbeddedWorkerOnWorkerThread, base::Passed(&services),
+                   base::Passed(&exposed_services)));
+  }
+
+ private:
+  mojo::StrongBinding<EmbeddedWorkerSetup> binding_;
+};
+
+void CreateEmbeddedWorkerSetup(
+    mojo::InterfaceRequest<EmbeddedWorkerSetup> request) {
+  new EmbeddedWorkerSetupImpl(request.Pass());
+}
+
 }  // namespace
 
 class RasterWorkerPool : public base::SequencedTaskRunner,
                          public base::DelegateSimpleThread::Delegate {
  public:
   RasterWorkerPool()
       : namespace_token_(task_graph_runner_.GetNamespaceToken()) {}
 
   void Start(int num_threads,
              const base::SimpleThread::Options& thread_options) {
@@ skipping 388 matching lines @@
   raster_worker_pool_->Start(num_raster_threads, thread_options);
 
   // TODO(boliu): In single process, browser main loop should set up the
   // discardable memory manager, and should skip this if kSingleProcess.
   // See crbug.com/503724.
   base::DiscardableMemoryAllocator::SetInstance(
       ChildThreadImpl::discardable_shared_memory_manager());
 
   service_registry()->AddService<RenderFrameSetup>(
       base::Bind(CreateRenderFrameSetup));
+  service_registry()->AddService<EmbeddedWorkerSetup>(
+      base::Bind(CreateEmbeddedWorkerSetup));
 
   TRACE_EVENT_END_ETW("RenderThreadImpl::Init", 0, "");
 }
 
 RenderThreadImpl::~RenderThreadImpl() {
 }
 
 void RenderThreadImpl::Shutdown() {
   FOR_EACH_OBSERVER(
       RenderProcessObserver, observers_, OnRenderProcessShutdown());
@@ skipping 1173 matching lines @@
 }
 
 void RenderThreadImpl::PendingRenderFrameConnect::OnConnectionError() {
   size_t erased =
       RenderThreadImpl::current()->pending_render_frame_connects_.erase(
           routing_id_);
   DCHECK_EQ(1u, erased);
 }
 
 }  // namespace content