Eliminate kMojoChannelToken usage for render processes

content/browser/mojo/mojo_shell_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/mojo/mojo_shell_context.h"
 
-#include <unordered_map>
+#include <memory>
+#include <string>
 #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"
 #include "base/single_thread_task_runner.h"
-#include "base/threading/thread_task_runner_handle.h"
 #include "content/browser/gpu/gpu_process_host.h"
 #include "content/common/mojo/constants.h"
-#include "content/common/mojo/mojo_shell_connection_impl.h"
 #include "content/common/process_control.mojom.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"
 #include "content/public/common/content_client.h"
-#include "content/public/common/content_switches.h"
+#include "content/public/common/mojo_shell_connection.h"
 #include "mojo/edk/embedder/embedder.h"
-#include "mojo/public/cpp/bindings/interface_request.h"
-#include "mojo/public/cpp/bindings/string.h"
 #include "services/catalog/catalog.h"
 #include "services/catalog/manifest_provider.h"
 #include "services/catalog/store.h"
 #include "services/shell/connect_params.h"
 #include "services/shell/native_runner.h"
 #include "services/shell/public/cpp/connector.h"
-#include "services/shell/public/cpp/identity.h"
 #include "services/shell/public/cpp/service.h"
-#include "services/shell/public/interfaces/connector.mojom.h"
 #include "services/shell/public/interfaces/service.mojom.h"
-#include "services/shell/public/interfaces/service_factory.mojom.h"
 #include "services/shell/runner/common/client_util.h"
 #include "services/shell/runner/host/in_process_native_runner.h"
+#include "services/shell/service_manager.h"
 #include "services/user/public/cpp/constants.h"
 
 namespace content {
 
 namespace {
 
 base::LazyInstance<std::unique_ptr<shell::Connector>>::Leaky
     g_io_thread_connector = LAZY_INSTANCE_INITIALIZER;
 
 void DestroyConnectorOnIOThread() { g_io_thread_connector.Get().reset(); }
 
-void StartUtilityProcessOnIOThread(
-    mojo::InterfaceRequest<mojom::ProcessControl> request,
-    const base::string16& process_name,
-    bool use_sandbox) {
+void StartUtilityProcessOnIOThread(mojom::ProcessControlRequest request,
+                                   const base::string16& process_name,
+                                   bool use_sandbox) {
   UtilityProcessHost* process_host =
       UtilityProcessHost::Create(nullptr, nullptr);
   process_host->SetName(process_name);
   if (!use_sandbox)
     process_host->DisableSandbox();
   process_host->Start();
 
   process_host->GetRemoteInterfaces()->GetInterface(std::move(request));
 }
 
@@ skipping 45 matching lines @@
       mojo::GetProxy(&process_control);
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&RequestGpuProcessControl, base::Passed(&process_request)));
   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
-    : public catalog::ManifestProvider {
+class 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);
+  void AddManifests(std::unique_ptr<
+      ContentBrowserClient::MojoApplicationManifestMap> manifests) {
+    DCHECK(!manifests_);
+    manifests_ = std::move(manifests);
   }
 
-  void AddManifests(std::unique_ptr<
-      ContentBrowserClient::MojoApplicationManifestMap> manifests) {
-    manifests_ = std::move(manifests);
+  void AddManifestResource(const std::string& name, int resource_id) {
+    std::string contents = GetContentClient()->GetDataResource(
+        resource_id, ui::ScaleFactor::SCALE_FACTOR_NONE).as_string();
+    DCHECK(!contents.empty());
+
+    DCHECK(manifests_);
+    auto result = manifests_->insert(std::make_pair(name, contents));
+    DCHECK(result.second) << "Duplicate manifest entry: " << name;
   }
 
  private:
   // catalog::ManifestProvider:
   bool GetApplicationManifest(const base::StringPiece& name,
                               std::string* manifest_contents) override {
-    auto it = manifest_resources_.find(name.as_string());
-    if (it != manifest_resources_.end()) {
-      *manifest_contents =
-          GetContentClient()
-              ->GetDataResource(it->second, ui::ScaleFactor::SCALE_FACTOR_NONE)
-              .as_string();
-      DCHECK(!manifest_contents->empty());
-      return true;
-    }
     auto manifest_it = manifests_->find(name.as_string());
     if (manifest_it != manifests_->end()) {
       *manifest_contents = manifest_it->second;
       DCHECK(!manifest_contents->empty());
       return true;
     }
     return false;
   }
 
-  std::unordered_map<std::string, int> manifest_resources_;
   std::unique_ptr<ContentBrowserClient::MojoApplicationManifestMap> manifests_;
 
   DISALLOW_COPY_AND_ASSIGN(BuiltinManifestProvider);
 };
 
+}  // namespace
+
+// State which lives on the IO thread and drives the ServiceManager.
+class MojoShellContext::InProcessServiceManagerContext
+    : public base::RefCountedThreadSafe<InProcessServiceManagerContext> {
+ public:
+  InProcessServiceManagerContext() {}
+
+  shell::mojom::ServiceRequest Start(
+      std::unique_ptr<BuiltinManifestProvider> manifest_provider) {
+    shell::mojom::ServicePtr embedder_service_proxy;
+    shell::mojom::ServiceRequest embedder_service_request =
+        mojo::GetProxy(&embedder_service_proxy);
+    shell::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;
+  }
+
+  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,
+      shell::mojom::ServicePtrInfo embedder_service_proxy_info) {
+    manifest_provider_ = std::move(manifest_provider);
+
+    scoped_refptr<base::SingleThreadTaskRunner> file_task_runner =
+        BrowserThread::GetTaskRunnerForThread(BrowserThread::FILE);
+    std::unique_ptr<shell::NativeRunnerFactory> native_runner_factory(
+        new shell::InProcessNativeRunnerFactory(
+            BrowserThread::GetBlockingPool()));
+    catalog_.reset(new catalog::Catalog(
+        file_task_runner.get(), nullptr, manifest_provider_.get()));
+    service_manager_.reset(new shell::ServiceManager(
+        std::move(native_runner_factory), catalog_->TakeService()));
+
+    shell::mojom::ServiceRequest request =
+        service_manager_->StartEmbedderService(kBrowserMojoApplicationName);
+    mojo::FuseInterface(
+        std::move(request), std::move(embedder_service_proxy_info));
+  }
+
+  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<shell::ServiceManager> service_manager_;
+
+  DISALLOW_COPY_AND_ASSIGN(InProcessServiceManagerContext);
+};
+
+
 MojoShellContext::MojoShellContext() {
-  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.
-  std::unique_ptr<ContentBrowserClient::MojoApplicationManifestMap> manifests(
-      new ContentBrowserClient::MojoApplicationManifestMap);
-  GetContentClient()->browser()->RegisterMojoApplicationManifests(
-      manifests.get());
-
-  manifest_provider_.reset(new BuiltinManifestProvider);
-  manifest_provider_->AddManifests(std::move(manifests));
-  manifest_provider_->AddManifestResource(kBrowserMojoApplicationName,
-                                          IDR_MOJO_CONTENT_BROWSER_MANIFEST);
-  manifest_provider_->AddManifestResource(kGpuMojoApplicationName,
-                                          IDR_MOJO_CONTENT_GPU_MANIFEST);
-  manifest_provider_->AddManifestResource(kRendererMojoApplicationName,
-                                          IDR_MOJO_CONTENT_RENDERER_MANIFEST);
-  manifest_provider_->AddManifestResource(kUtilityMojoApplicationName,
-                                          IDR_MOJO_CONTENT_UTILITY_MANIFEST);
-  manifest_provider_->AddManifestResource("mojo:catalog",
-                                          IDR_MOJO_CATALOG_MANIFEST);
-  manifest_provider_->AddManifestResource(user_service::kUserServiceName,
-                                          IDR_MOJO_PROFILE_MANIFEST);
-
-  catalog_.reset(new catalog::Catalog(file_task_runner.get(), nullptr,
-                                      manifest_provider_.get()));
-
   shell::mojom::ServiceRequest request;
   if (shell::ShellIsRemote()) {
     mojo::edk::SetParentPipeHandleFromCommandLine();
     request = shell::GetServiceRequestFromCommandLine();
   } else {
-    service_manager_.reset(new shell::ServiceManager(
-        std::move(native_runner_factory), catalog_->TakeService()));
-    request =
-        service_manager_->StartEmbedderService(kBrowserMojoApplicationName);
+    // Allow the embedder to register additional Mojo application manifests
+    // beyond the default ones below.
+    std::unique_ptr<ContentBrowserClient::MojoApplicationManifestMap> manifests(
+        new ContentBrowserClient::MojoApplicationManifestMap);
+    GetContentClient()->browser()->RegisterMojoApplicationManifests(
+        manifests.get());
+    std::unique_ptr<BuiltinManifestProvider> manifest_provider =
+        base::MakeUnique<BuiltinManifestProvider>();
+    manifest_provider->AddManifests(std::move(manifests));
+    manifest_provider->AddManifestResource(kBrowserMojoApplicationName,
+                                           IDR_MOJO_CONTENT_BROWSER_MANIFEST);
+    manifest_provider->AddManifestResource(kGpuMojoApplicationName,
+                                           IDR_MOJO_CONTENT_GPU_MANIFEST);
+    manifest_provider->AddManifestResource(kRendererMojoApplicationName,
+                                           IDR_MOJO_CONTENT_RENDERER_MANIFEST);
+    manifest_provider->AddManifestResource(kUtilityMojoApplicationName,
+                                           IDR_MOJO_CONTENT_UTILITY_MANIFEST);
+    manifest_provider->AddManifestResource("mojo:catalog",
+                                           IDR_MOJO_CATALOG_MANIFEST);
+    manifest_provider->AddManifestResource(user_service::kUserServiceName,
+                                           IDR_MOJO_PROFILE_MANIFEST);
+
+    in_process_context_ = new InProcessServiceManagerContext;
+    request = in_process_context_->Start(std::move(manifest_provider));
   }
   MojoShellConnection::SetForProcess(MojoShellConnection::Create(
       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);
@@ skipping 32 matching lines @@
   MojoShellConnection::GetForProcess()->AddServiceRequestHandler(
       "mojo:media", base::Bind(&LaunchAppInGpuProcess, "mojo:media"));
 #endif
 }
 
 MojoShellContext::~MojoShellContext() {
   if (MojoShellConnection::GetForProcess())
     MojoShellConnection::DestroyForProcess();
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                           base::Bind(&DestroyConnectorOnIOThread));
-  catalog_.reset();
+  if (in_process_context_)
+    in_process_context_->ShutDown();
 }
 
 // static
 shell::Connector* MojoShellContext::GetConnectorForIOThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   return g_io_thread_connector.Get().get();
 }
 
 }  // namespace content