Make browser process a singleton service

content/browser/service_manager/service_manager_context.cc

 // Copyright 2015 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_manager/service_manager_context.h"
 
 #include <memory>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/json/json_reader.h"
 #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"
 #include "content/browser/service_manager/merge_dictionary.h"
 #include "content/common/service_manager/service_manager_connection_impl.h"
 #include "content/grit/content_resources.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/utility_process_host.h"
 #include "content/public/browser/utility_process_host_client.h"
@@ skipping 149 matching lines @@
 };
 
 }  // namespace
 
 // State which lives on the IO thread and drives the ServiceManager.
 class ServiceManagerContext::InProcessServiceManagerContext
     : public base::RefCountedThreadSafe<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() {
     BrowserThread::GetTaskRunnerForThread(BrowserThread::IO)->PostTask(
         FROM_HERE,
         base::Bind(&InProcessServiceManagerContext::ShutDownOnIOThread, this));
   }
 
  private:
   friend class base::RefCountedThreadSafe<InProcessServiceManagerContext>;
 
   ~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());
     service_manager_ = base::MakeUnique<service_manager::ServiceManager>(
         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() {
     service_manager_.reset();
     catalog_.reset();
     manifest_provider_.reset();
   }
 
   std::unique_ptr<BuiltinManifestProvider> manifest_provider_;
   std::unique_ptr<catalog::Catalog> catalog_;
   std::unique_ptr<service_manager::ServiceManager> service_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(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>();
 
     static const struct ManifestInfo {
       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) {
       manifest_provider->AddServiceManifest(kManifests[i].name,
                                             kManifests[i].resource_id);
     }
     for (const auto& manifest :
          GetContentClient()->browser()->GetExtraServiceManifests()) {
       manifest_provider->AddServiceManifest(manifest.name,
                                             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
   // ServiceManagerContext must be constructed before anyone can call
   // GetConnectorForIOThread().
   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;
   GetContentClient()
       ->browser()
       ->RegisterUnsandboxedOutOfProcessServices(&unsandboxed_services);
   unsandboxed_services.insert(
       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() {
   // NOTE: The in-process ServiceManager MUST be destroyed before the browser
   // process-wide ServiceManagerConnection. Otherwise it's possible for the
   // ServiceManager to receive connection requests for service:content_browser
   // which it may attempt to service by launching a new instance of the browser.
   if (in_process_context_)
     in_process_context_->ShutDown();
   if (ServiceManagerConnection::GetForProcess())
     ServiceManagerConnection::DestroyForProcess();
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                           base::Bind(&DestroyConnectorOnIOThread));
 }
 
 // static
 service_manager::Connector* ServiceManagerContext::GetConnectorForIOThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   return g_io_thread_connector.Get().get();
 }
 
 }  // namespace content