WIP: Obtain Bootstrap from utility process Service

content/browser/mojo/service_manager_context_impl.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/mojo/mojo_shell_context.h"
+#include "content/browser/mojo/service_manager_context_impl.h"
 
 #include <unordered_map>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/path_service.h"
@@ skipping 105 matching lines @@
   process_control->LoadApplication(app_name, std::move(request),
                                    base::Bind(&OnApplicationLoaded, app_name));
 }
 
 #endif  // ENABLE_MOJO_MEDIA_IN_GPU_PROCESS
 
 }  // namespace
 
 // A ManifestProvider which resolves application names to builtin manifest
 // resources for the catalog service to consume.
-class MojoShellContext::BuiltinManifestProvider
+class ServiceManagerContextImpl::BuiltinManifestProvider
     : public catalog::ManifestProvider {
  public:
   BuiltinManifestProvider() {}
   ~BuiltinManifestProvider() override {}
 
   void AddManifestResource(const std::string& name, int resource_id) {
     auto result = manifest_resources_.insert(
         std::make_pair(name, resource_id));
     DCHECK(result.second);
   }
@@ skipping 25 matching lines @@
     return false;
   }
 
   std::unordered_map<std::string, int> manifest_resources_;
   std::unique_ptr<ContentBrowserClient::MojoApplicationManifestMap> manifests_;
 
   DISALLOW_COPY_AND_ASSIGN(BuiltinManifestProvider);
 };
 
 // Thread-safe proxy providing access to the shell context from any thread.
-class MojoShellContext::Proxy {
+class ServiceManagerContextImpl::Proxy {
  public:
-  Proxy(MojoShellContext* shell_context)
-      : shell_context_(shell_context),
+  Proxy(ServiceManagerContextImpl* context)
+      : context_(context),
         task_runner_(base::ThreadTaskRunnerHandle::Get()) {}
 
   ~Proxy() {}
 
   void ConnectToApplication(
       const std::string& user_id,
       const std::string& name,
       const std::string& requestor_name,
       shell::mojom::InterfaceProviderRequest request,
       shell::mojom::InterfaceProviderPtr exposed_services,
       const shell::mojom::Connector::ConnectCallback& callback) {
     if (task_runner_ == base::ThreadTaskRunnerHandle::Get()) {
-      if (shell_context_) {
-        shell_context_->ConnectToApplicationOnOwnThread(
+      if (context_) {
+        context_->ConnectToApplicationOnOwnThread(
             user_id, name, requestor_name, std::move(request),
             std::move(exposed_services), callback);
       }
     } else {
-      // |shell_context_| outlives the main MessageLoop, so it's safe for it to
+      // |context_| outlives the main MessageLoop, so it's safe for it to
       // be unretained here.
       task_runner_->PostTask(
           FROM_HERE,
-          base::Bind(&MojoShellContext::ConnectToApplicationOnOwnThread,
-                     base::Unretained(shell_context_), user_id, name,
+          base::Bind(&ServiceManagerContextImpl::ConnectToApplicationOnOwnThread,
+                     base::Unretained(context_), user_id, name,
                      requestor_name, base::Passed(&request),
                      base::Passed(&exposed_services), callback));
     }
   }
 
  private:
-  MojoShellContext* shell_context_;
+  ServiceManagerContextImpl* context_;
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(Proxy);
 };
 
 // static
-base::LazyInstance<std::unique_ptr<MojoShellContext::Proxy>>
-    MojoShellContext::proxy_ = LAZY_INSTANCE_INITIALIZER;
+base::LazyInstance<std::unique_ptr<ServiceManagerContextImpl::Proxy>>
+    ServiceManagerContextImpl::proxy_ = LAZY_INSTANCE_INITIALIZER;
 
-MojoShellContext::MojoShellContext() {
+ServiceManagerContextImpl::ServiceManagerContextImpl() {
   proxy_.Get().reset(new Proxy(this));
 
   scoped_refptr<base::SingleThreadTaskRunner> file_task_runner =
       BrowserThread::GetTaskRunnerForThread(BrowserThread::FILE);
   std::unique_ptr<shell::NativeRunnerFactory> native_runner_factory(
       new shell::InProcessNativeRunnerFactory(
           BrowserThread::GetBlockingPool()));
 
   // Allow the embedder to register additional Mojo application manifests
   // beyond the default ones below.
@@ skipping 34 matching lines @@
       std::move(request),
       BrowserThread::GetTaskRunnerForThread(BrowserThread::IO)));
 
   ContentBrowserClient::StaticMojoApplicationMap apps;
   GetContentClient()->browser()->RegisterInProcessMojoApplications(&apps);
   for (const auto& entry : apps) {
     MojoShellConnection::GetForProcess()->AddEmbeddedService(entry.first,
                                                              entry.second);
   }
 
-  // This is safe to assign directly from any thread, because MojoShellContext
-  // must be constructed before anyone can call GetConnectorForIOThread().
+  // This is safe to assign directly from any thread, because
+  // ServiceManagerContextImpl must be constructed before anyone can call
+  // GetConnectorForIOThread().
   g_io_thread_connector.Get() =
       MojoShellConnection::GetForProcess()->GetConnector()->Clone();
 
   MojoShellConnection::GetForProcess()->Start();
 
   ContentBrowserClient::OutOfProcessMojoApplicationMap sandboxed_apps;
   GetContentClient()
       ->browser()
       ->RegisterOutOfProcessMojoApplications(&sandboxed_apps);
   for (const auto& app : sandboxed_apps) {
@@ skipping 13 matching lines @@
         base::Bind(&LaunchAppInUtilityProcess, app.first, app.second,
                    false /* use_sandbox */));
   }
 
 #if (ENABLE_MOJO_MEDIA_IN_GPU_PROCESS)
   MojoShellConnection::GetForProcess()->AddServiceRequestHandler(
       "mojo:media", base::Bind(&LaunchAppInGpuProcess, "mojo:media"));
 #endif
 }
 
-MojoShellContext::~MojoShellContext() {
+ServiceManagerContextImpl::~ServiceManagerContextImpl() {
   if (MojoShellConnection::GetForProcess())
     MojoShellConnection::DestroyForProcess();
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                           base::Bind(&DestroyConnectorOnIOThread));
   catalog_.reset();
 }
 
 // static
-void MojoShellContext::ConnectToApplication(
+void ServiceManagerContextImpl::ConnectToApplication(
     const std::string& user_id,
     const std::string& name,
     const std::string& requestor_name,
     shell::mojom::InterfaceProviderRequest request,
     shell::mojom::InterfaceProviderPtr exposed_services,
     const shell::mojom::Connector::ConnectCallback& callback) {
   proxy_.Get()->ConnectToApplication(user_id, name, requestor_name,
                                      std::move(request),
                                      std::move(exposed_services), callback);
 }
 
 // static
-shell::Connector* MojoShellContext::GetConnectorForIOThread() {
+shell::Connector* ServiceManagerContextImpl::GetConnectorForIOThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   return g_io_thread_connector.Get().get();
 }
 
-void MojoShellContext::ConnectToApplicationOnOwnThread(
+void ServiceManagerContextImpl::ConnectToApplicationOnOwnThread(
     const std::string& user_id,
     const std::string& name,
     const std::string& requestor_name,
     shell::mojom::InterfaceProviderRequest request,
     shell::mojom::InterfaceProviderPtr exposed_services,
     const shell::mojom::Connector::ConnectCallback& callback) {
   std::unique_ptr<shell::ConnectParams> params(new shell::ConnectParams);
   shell::Identity source_id(requestor_name, user_id);
   params->set_source(source_id);
   params->set_target(shell::Identity(name, user_id));
   params->set_remote_interfaces(std::move(request));
   params->set_local_interfaces(std::move(exposed_services));
   params->set_connect_callback(callback);
   service_manager_->Connect(std::move(params));
 }
 
+// static
+std::unique_ptr<ServiceManagerContext> ServiceManagerContext::Create() {
+  return base::WrapUnique(new ServiceManagerContextImpl);
+}
+
 }  // namespace content