Make browser process a singleton service

content/browser/service_manager/service_manager_context.cc

Index: content/browser/service_manager/service_manager_context.cc
diff --git a/content/browser/service_manager/service_manager_context.cc b/content/browser/service_manager/service_manager_context.cc
index 0cad78c8a54fbce6dde976f6c5948d6b269c2fc6..db56719c833e15ef86a50ad54b1117d3f36b5614 100644
--- a/content/browser/service_manager/service_manager_context.cc
+++ b/content/browser/service_manager/service_manager_context.cc
@@ -13,6 +13,7 @@
 #include "base/lazy_instance.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
+#include "base/process/process_handle.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/gpu/gpu_process_host.h"
@@ -182,19 +183,14 @@ class ServiceManagerContext::InProcessServiceManagerContext
  public:
   InProcessServiceManagerContext() {}
 
-  service_manager::mojom::ServiceRequest Start(
+  void Start(
+      service_manager::mojom::ServicePtrInfo packaged_services_service_info,
       std::unique_ptr<BuiltinManifestProvider> manifest_provider) {
-    service_manager::mojom::ServicePtr embedder_service_proxy;
-    service_manager::mojom::ServiceRequest embedder_service_request(
-        &embedder_service_proxy);
-    service_manager::mojom::ServicePtrInfo embedder_service_proxy_info =
-        embedder_service_proxy.PassInterface();
-    BrowserThread::GetTaskRunnerForThread(BrowserThread::IO)->PostTask(
-        FROM_HERE,
-        base::Bind(&InProcessServiceManagerContext::StartOnIOThread, this,
-                   base::Passed(&manifest_provider),
-                   base::Passed(&embedder_service_proxy_info)));
-    return embedder_service_request;
+    BrowserThread::GetTaskRunnerForThread(BrowserThread::IO)
+        ->PostTask(FROM_HERE,
+                   base::Bind(&InProcessServiceManagerContext::StartOnIOThread,
+                              this, base::Passed(&manifest_provider),
+                              base::Passed(&packaged_services_service_info)));
   }
 
   void ShutDown() {
@@ -210,7 +206,7 @@ class ServiceManagerContext::InProcessServiceManagerContext
 
   void StartOnIOThread(
       std::unique_ptr<BuiltinManifestProvider> manifest_provider,
-      service_manager::mojom::ServicePtrInfo embedder_service_proxy_info) {
+      service_manager::mojom::ServicePtrInfo packaged_services_service_info) {
     manifest_provider_ = std::move(manifest_provider);
     catalog_ =
         base::MakeUnique<catalog::Catalog>(nullptr, manifest_provider_.get());
@@ -218,12 +214,12 @@ class ServiceManagerContext::InProcessServiceManagerContext
         base::MakeUnique<NullServiceProcessLauncherFactory>(),
         catalog_->TakeService());
 
-    service_manager::mojom::ServicePtr service;
-    service.Bind(std::move(embedder_service_proxy_info));
+    service_manager::mojom::ServicePtr packaged_services_service;
+    packaged_services_service.Bind(std::move(packaged_services_service_info));
     service_manager_->RegisterService(
-        service_manager::Identity(
-            mojom::kBrowserServiceName, service_manager::mojom::kRootUserID),
-        std::move(service), nullptr);
+        service_manager::Identity(mojom::kPackagedServicesServiceName,
+                                  service_manager::mojom::kRootUserID),
+        std::move(packaged_services_service), nullptr);
   }
 
   void ShutDownOnIOThread() {
@@ -240,10 +236,11 @@ class ServiceManagerContext::InProcessServiceManagerContext
 };
 
 ServiceManagerContext::ServiceManagerContext() {
-  service_manager::mojom::ServiceRequest request;
+  service_manager::mojom::ServiceRequest packaged_services_request;
   if (service_manager::ServiceManagerIsRemote()) {
     mojo::edk::SetParentPipeHandleFromCommandLine();
-    request = service_manager::GetServiceRequestFromCommandLine();
+    packaged_services_request =
+        service_manager::GetServiceRequestFromCommandLine();
   } else {
     std::unique_ptr<BuiltinManifestProvider> manifest_provider =
         base::MakeUnique<BuiltinManifestProvider>();
@@ -252,12 +249,14 @@ ServiceManagerContext::ServiceManagerContext() {
       const char* name;
       int resource_id;
     } kManifests[] = {
-      { mojom::kBrowserServiceName, IDR_MOJO_CONTENT_BROWSER_MANIFEST },
-      { mojom::kGpuServiceName, IDR_MOJO_CONTENT_GPU_MANIFEST },
-      { mojom::kPluginServiceName, IDR_MOJO_CONTENT_PLUGIN_MANIFEST },
-      { mojom::kRendererServiceName, IDR_MOJO_CONTENT_RENDERER_MANIFEST },
-      { mojom::kUtilityServiceName, IDR_MOJO_CONTENT_UTILITY_MANIFEST },
-      { catalog::mojom::kServiceName, IDR_MOJO_CATALOG_MANIFEST },
+        {mojom::kBrowserServiceName, IDR_MOJO_CONTENT_BROWSER_MANIFEST},
+        {mojom::kGpuServiceName, IDR_MOJO_CONTENT_GPU_MANIFEST},
+        {mojom::kPackagedServicesServiceName,
+         IDR_MOJO_CONTENT_PACKAGED_SERVICES_MANIFEST},
+        {mojom::kPluginServiceName, IDR_MOJO_CONTENT_PLUGIN_MANIFEST},
+        {mojom::kRendererServiceName, IDR_MOJO_CONTENT_RENDERER_MANIFEST},
+        {mojom::kUtilityServiceName, IDR_MOJO_CONTENT_UTILITY_MANIFEST},
+        {catalog::mojom::kServiceName, IDR_MOJO_CATALOG_MANIFEST},
     };
 
     for (size_t i = 0; i < arraysize(kManifests); ++i) {
@@ -270,24 +269,44 @@ ServiceManagerContext::ServiceManagerContext() {
                                             manifest.resource_id);
     }
     in_process_context_ = new InProcessServiceManagerContext;
-    request = in_process_context_->Start(std::move(manifest_provider));
+
+    service_manager::mojom::ServicePtr packaged_services_service;
+    packaged_services_request = mojo::MakeRequest(&packaged_services_service);
+    in_process_context_->Start(packaged_services_service.PassInterface(),
+                               std::move(manifest_provider));
   }
+
+  packaged_services_connection_ = ServiceManagerConnection::Create(
+      std::move(packaged_services_request),
+      BrowserThread::GetTaskRunnerForThread(BrowserThread::IO));
+
+  service_manager::mojom::ServicePtr root_browser_service;
   ServiceManagerConnection::SetForProcess(ServiceManagerConnection::Create(
-      std::move(request),
+      mojo::MakeRequest(&root_browser_service),
       BrowserThread::GetTaskRunnerForThread(BrowserThread::IO)));
 
+  service_manager::mojom::PIDReceiverPtr pid_receiver;
+  packaged_services_connection_->GetConnector()->StartService(
+      service_manager::Identity(mojom::kBrowserServiceName,
+                                service_manager::mojom::kRootUserID),
+      std::move(root_browser_service), mojo::MakeRequest(&pid_receiver));
+  pid_receiver->SetPID(base::GetCurrentProcId());
+
+  packaged_services_connection_->Start();
+  ServiceManagerConnection::GetForProcess()->Start();
+
   ServiceInfo device_info;
   device_info.factory =
       base::Bind(&device::CreateDeviceService,
                  BrowserThread::GetTaskRunnerForThread(BrowserThread::FILE));
-  ServiceManagerConnection::GetForProcess()->AddEmbeddedService(
-      device::mojom::kServiceName, device_info);
+  packaged_services_connection_->AddEmbeddedService(device::mojom::kServiceName,
+                                                    device_info);
 
   ContentBrowserClient::StaticServiceMap services;
   GetContentClient()->browser()->RegisterInProcessServices(&services);
   for (const auto& entry : services) {
-    ServiceManagerConnection::GetForProcess()->AddEmbeddedService(entry.first,
-                                                                  entry.second);
+    packaged_services_connection_->AddEmbeddedService(entry.first,
+                                                      entry.second);
   }
 
   // This is safe to assign directly from any thread, because
@@ -296,17 +315,14 @@ ServiceManagerContext::ServiceManagerContext() {
   g_io_thread_connector.Get() =
       ServiceManagerConnection::GetForProcess()->GetConnector()->Clone();
 
-  ServiceManagerConnection::GetForProcess()->Start();
-
   ContentBrowserClient::OutOfProcessServiceMap sandboxed_services;
   GetContentClient()
       ->browser()
       ->RegisterOutOfProcessServices(&sandboxed_services);
   for (const auto& service : sandboxed_services) {
-    ServiceManagerConnection::GetForProcess()->AddServiceRequestHandler(
-      service.first,
-        base::Bind(&StartServiceInUtilityProcess, service.first, service.second,
-                   true /* use_sandbox */));
+    packaged_services_connection_->AddServiceRequestHandler(
+        service.first, base::Bind(&StartServiceInUtilityProcess, service.first,
+                                  service.second, true /* use_sandbox */));
   }
 
   ContentBrowserClient::OutOfProcessServiceMap unsandboxed_services;
@@ -317,25 +333,15 @@ ServiceManagerContext::ServiceManagerContext() {
       std::make_pair(shape_detection::mojom::kServiceName,
                      base::ASCIIToUTF16("Shape Detection Service")));
   for (const auto& service : unsandboxed_services) {
-    ServiceManagerConnection::GetForProcess()->AddServiceRequestHandler(
-        service.first,
-        base::Bind(&StartServiceInUtilityProcess, service.first, service.second,
-                   false /* use_sandbox */));
+    packaged_services_connection_->AddServiceRequestHandler(
+        service.first, base::Bind(&StartServiceInUtilityProcess, service.first,
+                                  service.second, false /* use_sandbox */));
   }
 
 #if (ENABLE_MOJO_MEDIA_IN_GPU_PROCESS)
-  ServiceManagerConnection::GetForProcess()->AddServiceRequestHandler(
+  packaged_services_connection_->AddServiceRequestHandler(
       "media", base::Bind(&StartServiceInGpuProcess, "media"));
 #endif
-
-  // Initiates the first connection to device service to create the singleton
-  // instance, later the same instance will serve all the clients wanting to
-  // connect to device service.
-  // TODO(rockot): http://crbug.com/679407 Eliminate this connection once
-  // content_browser is itself a singleton service.
-  std::unique_ptr<service_manager::Connection> device_connection =
-      ServiceManagerConnection::GetForProcess()->GetConnector()->Connect(
-          device::mojom::kServiceName);
 }
 
 ServiceManagerContext::~ServiceManagerContext() {