Revert "Move GPU and Plugin processes off Service Manager"

This reverts commit bdc39552.

Reason for revert: breaks graphics on some Chrome OS devices.

Original change's description:
> Move GPU and Plugin processes off Service Manager
>
> This introduces a new mode for Browser/ChildProcessHost where the
> primordial pipe is a simple content.mojom.ChildProcess pipe. This will
> become the new default mode of operation for child processes, and
> eventually will be the only mode of operation once NaCl processes are
> gone.
>
> GPU and plugin processes are ported to this mode here since both
> require only minimal changes. This means that "content_gpu" and
> "content_plugin" services no longer exist.
>
> Bug: 977637
> Change-Id: I39c5d2284bd84246663d5f0eb4cbab3b3483d798
> Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1918326
> Reviewed-by: Avi Drissman <avi@chromium.org>
> Reviewed-by: Robert Sesek <rsesek@chromium.org>
> Commit-Queue: Ken Rockot <rockot@google.com>
> Cr-Commit-Position: refs/heads/master@{#717857}

NOPRESUBMIT=true

Bug: 1028852
Bug: 977637
Tbr: rockot@google.com
Tbr: avi@chromium.org
Tbr: rsesek@chromium.org
Change-Id: I21259f3cf7718ad940cafba4a56d9349412d3b74
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1948664
Commit-Queue: Shuhei Takahashi <nya@chromium.org>
Reviewed-by: Shuhei Takahashi <nya@chromium.org>
Cr-Commit-Position: refs/heads/master@{#720940}

content/browser/builtin_service_manifests.cc

@@ -8,6 +8,8 @@
 #include "base/no_destructor.h"
 #include "build/build_config.h"
 #include "content/public/app/content_browser_manifest.h"
+#include "content/public/app/content_gpu_manifest.h"
+#include "content/public/app/content_plugin_manifest.h"
 #include "content/public/app/content_renderer_manifest.h"
 #include "content/public/app/content_utility_manifest.h"
 #include "content/public/browser/content_browser_client.h"
@@ -43,6 +45,8 @@ const std::vector<service_manager::Manifest>& GetBuiltinServiceManifests() {
           // browser process, but the distinction between "in-process" and
           // "out-of-process" manifests is temporary. For now, this is the right
           // place for these manifests.
+          GetContentGpuManifest(),
+          GetContentPluginManifest(),
           GetContentRendererManifest(),
           GetContentUtilityManifest(),
 

content/browser/child_process_task_port_provider_mac_unittest.cc

@@ -41,8 +41,6 @@ class MockChildProcess : public mojom::ChildProcess {
                void(mojo::PendingReceiver<
                     tracing::mojom::BackgroundTracingAgentProvider>));
   MOCK_METHOD0(CrashHungProcess, void());
-  MOCK_METHOD1(BootstrapLegacyIpc,
-               void(mojo::PendingReceiver<IPC::mojom::ChannelBootstrap>));
   MOCK_METHOD2(RunService,
                void(const std::string&,
                     mojo::PendingReceiver<service_manager::mojom::Service>));

content/browser/gpu/gpu_process_host.cc

@@ -42,9 +42,11 @@
 #include "content/browser/gpu/gpu_main_thread_factory.h"
 #include "content/browser/gpu/gpu_memory_buffer_manager_singleton.h"
 #include "content/browser/gpu/shader_cache_factory.h"
+#include "content/browser/service_manager/service_manager_context.h"
 #include "content/common/child_process.mojom.h"
 #include "content/common/child_process_host_impl.h"
 #include "content/common/in_process_child_thread_params.h"
+#include "content/common/service_manager/child_connection.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/browser_main_runner.h"
 #include "content/public/browser/browser_task_traits.h"
@@ -56,6 +58,8 @@
 #include "content/public/common/content_switches.h"
 #include "content/public/common/result_codes.h"
 #include "content/public/common/sandboxed_process_launcher_delegate.h"
+#include "content/public/common/service_manager_connection.h"
+#include "content/public/common/service_names.mojom.h"
 #include "gpu/command_buffer/service/gpu_switches.h"
 #include "gpu/config/gpu_driver_bug_list.h"
 #include "gpu/config/gpu_driver_bug_workaround_type.h"
@@ -646,8 +650,8 @@ GpuProcessHost::GpuProcessHost(int host_id, GpuProcessKind kind)
 
   g_gpu_process_hosts[kind] = this;
 
-  process_.reset(new BrowserChildProcessHostImpl(
-      PROCESS_TYPE_GPU, this, ChildProcessHost::IpcMode::kNormal));
+  process_.reset(new BrowserChildProcessHostImpl(PROCESS_TYPE_GPU, this,
+                                                 mojom::kGpuServiceName));
 }
 
 GpuProcessHost::~GpuProcessHost() {
@@ -785,8 +789,10 @@ bool GpuProcessHost::Init() {
     GpuDataManagerImpl::GetInstance()->UpdateGpuPreferences(
         &gpu_preferences, GPU_PROCESS_KIND_SANDBOXED);
     in_process_gpu_thread_.reset(GetGpuMainThreadFactory()(
-        InProcessChildThreadParams(base::ThreadTaskRunnerHandle::Get(),
-                                   process_->GetInProcessMojoInvitation()),
+        InProcessChildThreadParams(
+            base::ThreadTaskRunnerHandle::Get(),
+            process_->GetInProcessMojoInvitation(),
+            process_->child_connection()->service_token()),
         gpu_preferences));
     base::Thread::Options options;
 #if defined(OS_WIN) || defined(OS_MACOSX)

content/browser/ppapi_plugin_process_host.cc

@@ -33,6 +33,7 @@
 #include "content/public/common/pepper_plugin_info.h"
 #include "content/public/common/process_type.h"
 #include "content/public/common/sandboxed_process_launcher_delegate.h"
+#include "content/public/common/service_names.mojom.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/shared_impl/ppapi_permissions.h"
 #include "services/network/public/cpp/network_connection_tracker.h"
@@ -321,7 +322,7 @@ PpapiPluginProcessHost::PpapiPluginProcessHost(
   permissions_ = ppapi::PpapiPermissions::GetForCommandLine(base_permissions);
 
   process_ = std::make_unique<BrowserChildProcessHostImpl>(
-      PROCESS_TYPE_PPAPI_PLUGIN, this, ChildProcessHost::IpcMode::kNormal);
+      PROCESS_TYPE_PPAPI_PLUGIN, this, mojom::kPluginServiceName);
 
   host_impl_ = std::make_unique<BrowserPpapiHostImpl>(
       this, permissions_, info.name, info.path, profile_data_directory,
@@ -340,7 +341,7 @@ PpapiPluginProcessHost::PpapiPluginProcessHost(
 
 PpapiPluginProcessHost::PpapiPluginProcessHost() : is_broker_(true) {
   process_ = std::make_unique<BrowserChildProcessHostImpl>(
-      PROCESS_TYPE_PPAPI_BROKER, this, ChildProcessHost::IpcMode::kNormal);
+      PROCESS_TYPE_PPAPI_BROKER, this, mojom::kPluginServiceName);
 
   ppapi::PpapiPermissions permissions;  // No permissions.
   // The plugin name, path and profile data directory shouldn't be needed for

content/child/child_thread_impl.cc

@@ -287,20 +287,11 @@ class ChildThreadImpl::IOThreadState
         wait_for_interface_binders_(wait_for_interface_binders),
         host_receiver_(std::move(host_receiver)) {}
 
-  // Used only in the deprecated Service Manager IPC mode.
   void BindChildProcessReceiver(
       mojo::PendingReceiver<mojom::ChildProcess> receiver) {
     receiver_.Bind(std::move(receiver));
   }
 
-  // Used in non-Service Manager IPC mode.
-  void BindChildProcessReceiverAndLegacyIpc(
-      mojo::PendingReceiver<mojom::ChildProcess> receiver,
-      mojo::PendingRemote<IPC::mojom::ChannelBootstrap> legacy_ipc_bootstrap) {
-    legacy_ipc_bootstrap_ = std::move(legacy_ipc_bootstrap);
-    receiver_.Bind(std::move(receiver));
-  }
-
   void ExposeInterfacesToBrowser(mojo::BinderMap binders) {
     DCHECK(wait_for_interface_binders_);
     wait_for_interface_binders_ = false;
@@ -368,12 +359,6 @@ class ChildThreadImpl::IOThreadState
     IMMEDIATE_CRASH();
   }
 
-  void BootstrapLegacyIpc(
-      mojo::PendingReceiver<IPC::mojom::ChannelBootstrap> receiver) override {
-    DCHECK(legacy_ipc_bootstrap_);
-    mojo::FusePipes(std::move(receiver), std::move(legacy_ipc_bootstrap_));
-  }
-
   void RunService(const std::string& service_name,
                   mojo::PendingReceiver<service_manager::mojom::Service>
                       receiver) override {
@@ -435,11 +420,6 @@ class ChildThreadImpl::IOThreadState
   mojo::Receiver<mojom::ChildProcess> receiver_{this};
   mojo::PendingReceiver<mojom::ChildProcessHost> host_receiver_;
 
-  // The pending legacy IPC channel endpoint to fuse with one we will eventually
-  // receiver on the ChildProcess interface. Only used when not in the
-  // deprecated Service Manager IPC mode.
-  mojo::PendingRemote<IPC::mojom::ChannelBootstrap> legacy_ipc_bootstrap_;
-
   // Binding requests which should be handled by |interface_binders|, but which
   // have been queued because |allow_interface_binders_| is still |false|.
   std::vector<mojo::GenericPendingReceiver> pending_binding_requests_;
@@ -572,7 +552,7 @@ void ChildThreadImpl::OnFieldTrialGroupFinalized(
   field_trial_recorder->FieldTrialActivated(trial_name);
 }
 
-void ChildThreadImpl::ConnectLegacyIpcChannelThroughServiceManager() {
+void ChildThreadImpl::ConnectChannel() {
   DCHECK(service_manager_connection_);
   mojo::PendingRemote<IPC::mojom::ChannelBootstrap> bootstrap;
   mojo::ScopedMessagePipeHandle handle =
@@ -609,10 +589,6 @@ void ChildThreadImpl::Init(const Options& options) {
     IPC::Logging::GetInstance()->SetIPCSender(this);
 #endif
 
-  // Only one of these will be made valid by the block below. This determines
-  // whether we were launched in normal IPC mode or deprecated Service Manager
-  // IPC mode.
-  mojo::ScopedMessagePipeHandle child_process_pipe;
   mojo::ScopedMessagePipeHandle service_request_pipe;
   if (!IsInBrowserProcess()) {
     mojo_ipc_support_.reset(new mojo::core::ScopedIPCSupport(
@@ -625,52 +601,30 @@ void ChildThreadImpl::Init(const Options& options) {
     if (!service_request_token.empty()) {
       service_request_pipe =
           invitation.ExtractMessagePipe(service_request_token);
-    } else {
-      child_process_pipe = invitation.ExtractMessagePipe(0);
     }
   } else {
-    if (!options.in_process_service_request_token.empty()) {
-      service_request_pipe = options.mojo_invitation->ExtractMessagePipe(
-          options.in_process_service_request_token);
-    } else {
-      child_process_pipe = options.mojo_invitation->ExtractMessagePipe(0);
-    }
+    service_request_pipe = options.mojo_invitation->ExtractMessagePipe(
+        options.in_process_service_request_token);
   }
 
   if (service_request_pipe.is_valid()) {
-    // We're in deprecated legacy IPC mode. Initialize a connection to the
-    // Service Manager.
     service_manager_connection_ = ServiceManagerConnection::Create(
         service_manager::mojom::ServiceRequest(std::move(service_request_pipe)),
         GetIOTaskRunner());
-  } else {
-    // We're in normal IPC mode. Set up the ChildProcess receiver and legacy IPC
-    // Channel.
-    DCHECK(child_process_pipe.is_valid());
-
-    mojo::PendingRemote<IPC::mojom::ChannelBootstrap> legacy_ipc_bootstrap;
-    mojo::ScopedMessagePipeHandle legacy_ipc_channel_handle =
-        legacy_ipc_bootstrap.InitWithNewPipeAndPassReceiver().PassPipe();
-    channel_->Init(IPC::ChannelMojo::CreateClientFactory(
-                       std::move(legacy_ipc_channel_handle),
-                       ChildProcess::current()->io_task_runner(),
-                       ipc_task_runner_ ? ipc_task_runner_
-                                        : base::ThreadTaskRunnerHandle::Get()),
-                   /*create_pipe_now=*/true);
-
-    ChildThreadImpl::GetIOTaskRunner()->PostTask(
-        FROM_HERE,
-        base::BindOnce(&IOThreadState::BindChildProcessReceiverAndLegacyIpc,
-                       io_thread_state_,
-                       mojo::PendingReceiver<mojom::ChildProcess>(
-                           std::move(child_process_pipe)),
-                       std::move(legacy_ipc_bootstrap)));
   }
 
   sync_message_filter_ = channel_->CreateSyncMessageFilter();
   thread_safe_sender_ =
       new ThreadSafeSender(main_thread_runner_, sync_message_filter_.get());
 
+  auto registry = std::make_unique<service_manager::BinderRegistry>();
+  registry->AddInterface(
+      base::BindRepeating(&IOThreadState::BindChildProcessReceiver,
+                          io_thread_state_),
+      ChildThreadImpl::GetIOTaskRunner());
+  service_manager_connection_->AddConnectionFilter(
+      std::make_unique<SimpleConnectionFilter>(std::move(registry)));
+
   // In single process mode, browser-side tracing and memory will cover the
   // whole process including renderers.
   if (!IsInBrowserProcess()) {
@@ -713,18 +667,12 @@ void ChildThreadImpl::Init(const Options& options) {
     channel_->AddFilter(startup_filter);
   }
 
-  if (service_manager_connection_) {
-    auto registry = std::make_unique<service_manager::BinderRegistry>();
-    registry->AddInterface(
-        base::BindRepeating(&IOThreadState::BindChildProcessReceiver,
-                            io_thread_state_),
-        ChildThreadImpl::GetIOTaskRunner());
-    service_manager_connection_->AddConnectionFilter(
-        std::make_unique<SimpleConnectionFilter>(std::move(registry)));
+  ConnectChannel();
 
-    ConnectLegacyIpcChannelThroughServiceManager();
+  // This must always be done after ConnectChannel, because ConnectChannel() may
+  // add a ConnectionFilter to the connection.
+  if (service_manager_connection_)
     StartServiceManagerConnection();
-  }
 
   int connection_timeout = kConnectionTimeoutS;
   std::string connection_override =

content/child/child_thread_impl.h

@@ -200,7 +200,7 @@ class CONTENT_EXPORT ChildThreadImpl
 
   // We create the channel first without connecting it so we can add filters
   // prior to any messages being received, then connect it afterwards.
-  void ConnectLegacyIpcChannelThroughServiceManager();
+  void ConnectChannel();
 
   // IPC message handlers.
 

content/common/BUILD.gn

@@ -503,7 +503,6 @@ mojom("mojo_bindings") {
     "//components/tracing/common:interfaces",
     "//content/public/common:interfaces",
     "//content/public/common:resource_type_bindings",
-    "//ipc:mojom",
     "//ipc:mojom_constants",
     "//media/capture/mojom:video_capture",
     "//media/mojo/mojom",

content/common/child_process.mojom

@@ -5,7 +5,6 @@
 module content.mojom;
 
 import "components/tracing/common/background_tracing_agent.mojom";
-import "ipc/ipc.mojom";
 import "mojo/public/mojom/base/file.mojom";
 import "mojo/public/mojom/base/generic_pending_receiver.mojom";
 import "services/service_manager/public/mojom/service.mojom";
@@ -62,9 +61,6 @@ interface ChildProcess {
   // cleanup, generating a crash report).
   CrashHungProcess();
 
-  // Binds the legacy IPC Channel bootstrapping pipe.
-  BootstrapLegacyIpc(pending_receiver<IPC.mojom.ChannelBootstrap> receiver);
-
   // Tells the child process to run an instance of a service named
   // |service_name|, binding it to |receiver|. This is used by the browser to
   // support launching of packaged services within Utility or GPU processes.

content/common/child_process_host_impl.cc

@@ -123,10 +123,6 @@ ChildProcessHostImpl::ChildProcessHostImpl(ChildProcessHostDelegate* delegate,
         base::ThreadTaskRunnerHandle::Get(),
         base::ThreadTaskRunnerHandle::Get(),
         mojo::internal::MessageQuotaChecker::MaybeCreate());
-  } else if (ipc_mode_ == IpcMode::kNormal) {
-    child_process_.Bind(mojo::PendingRemote<mojom::ChildProcess>(
-        mojo_invitation_->AttachMessagePipe(0), /*version=*/0));
-    child_process_->Initialize(bootstrap_receiver_.BindNewPipeAndPassRemote());
   }
 }
 
@@ -180,21 +176,10 @@ void ChildProcessHostImpl::CreateChannelMojo() {
   // not bound through the Service Manager.
   if (ipc_mode_ != IpcMode::kLegacy) {
     DCHECK(!channel_);
-
-    mojo::PendingRemote<IPC::mojom::ChannelBootstrap> bootstrap;
-    auto bootstrap_receiver = bootstrap.InitWithNewPipeAndPassReceiver();
-
-    if (ipc_mode_ == IpcMode::kServiceManager) {
-      BindInterface(IPC::mojom::ChannelBootstrap::Name_,
-                    bootstrap_receiver.PassPipe());
-    } else {
-      DCHECK_EQ(ipc_mode_, IpcMode::kNormal);
-      DCHECK(child_process_);
-      child_process_->BootstrapLegacyIpc(std::move(bootstrap_receiver));
-    }
-
+    mojo::MessagePipe pipe;
+    BindInterface(IPC::mojom::ChannelBootstrap::Name_, std::move(pipe.handle1));
     channel_ = IPC::ChannelMojo::Create(
-        bootstrap.PassPipe(), IPC::Channel::MODE_SERVER, this,
+        std::move(pipe.handle0), IPC::Channel::MODE_SERVER, this,
         base::ThreadTaskRunnerHandle::Get(),
         base::ThreadTaskRunnerHandle::Get(),
         mojo::internal::MessageQuotaChecker::MaybeCreate());
@@ -215,10 +200,8 @@ bool ChildProcessHostImpl::InitChannel() {
   delegate_->OnChannelInitialized(channel_.get());
 
   // In legacy mode, |child_process_| endpoint is already bound to a
-  // disconnected pipe and will remain dysfunctional. In normal mode, it's bound
-  // in the constructor.
+  // disconnected pipe and will remain dysfunctional.
   if (!child_process_) {
-    DCHECK_EQ(ipc_mode_, IpcMode::kServiceManager);
     // We want to bind this interface as early as possible, but the constructor
     // is too early. |delegate_| may not be fully initialized at that point and
     // thus may be unable to properly fulfill the BindInterface() call. Instead

content/common/in_process_child_thread_params.h

@@ -22,7 +22,7 @@ class CONTENT_EXPORT InProcessChildThreadParams {
   InProcessChildThreadParams(
       scoped_refptr<base::SingleThreadTaskRunner> io_runner,
       mojo::OutgoingInvitation* mojo_invitation,
-      const std::string& service_request_token = {});
+      const std::string& service_request_token);
   InProcessChildThreadParams(const InProcessChildThreadParams& other);
   ~InProcessChildThreadParams();
 

content/public/app/BUILD.gn

@@ -193,6 +193,38 @@ source_set("content_browser_manifest") {
   ]
 }
 
+source_set("content_gpu_manifest") {
+  sources = [
+    "content_gpu_manifest.cc",
+    "content_gpu_manifest.h",
+  ]
+
+  deps = [
+    "//base",
+    "//content/public/common:service_names",
+  ]
+
+  public_deps = [
+    "//services/service_manager/public/cpp",
+  ]
+}
+
+source_set("content_plugin_manifest") {
+  sources = [
+    "content_plugin_manifest.cc",
+    "content_plugin_manifest.h",
+  ]
+
+  deps = [
+    "//base",
+    "//content/public/common:service_names",
+  ]
+
+  public_deps = [
+    "//services/service_manager/public/cpp",
+  ]
+}
+
 source_set("content_renderer_manifest") {
   sources = [
     "content_renderer_manifest.cc",
@@ -248,6 +280,8 @@ source_set("v8_snapshot_overlay_manifest") {
 group("service_manifests") {
   public_deps = [
     ":content_browser_manifest",
+    ":content_gpu_manifest",
+    ":content_plugin_manifest",
     ":content_renderer_manifest",
     ":content_utility_manifest",
   ]

content/public/app/OWNERS

@@ -6,6 +6,16 @@ per-file content_browser_manifest.cc=file://ipc/SECURITY_OWNERS
 per-file content_browser_manifest.h=set noparent
 per-file content_browser_manifest.h=file://ipc/SECURITY_OWNERS
 
+per-file content_gpu_manifest.cc=set noparent
+per-file content_gpu_manifest.cc=file://ipc/SECURITY_OWNERS
+per-file content_gpu_manifest.h=set noparent
+per-file content_gpu_manifest.h=file://ipc/SECURITY_OWNERS
+
+per-file content_plugin_manifest.cc=set noparent
+per-file content_plugin_manifest.cc=file://ipc/SECURITY_OWNERS
+per-file content_plugin_manifest.h=set noparent
+per-file content_plugin_manifest.h=file://ipc/SECURITY_OWNERS
+
 per-file content_renderer_manifest.cc=set noparent
 per-file content_renderer_manifest.cc=file://ipc/SECURITY_OWNERS
 per-file content_renderer_manifest.h=set noparent

content/public/app/content_gpu_manifest.cc

+// Copyright 2019 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/public/app/content_gpu_manifest.h"
+
+#include "base/no_destructor.h"
+#include "content/public/common/service_names.mojom.h"
+#include "services/service_manager/public/cpp/manifest_builder.h"
+
+namespace content {
+
+const service_manager::Manifest& GetContentGpuManifest() {
+  static base::NoDestructor<service_manager::Manifest> manifest{
+      service_manager::ManifestBuilder()
+          .WithServiceName(mojom::kGpuServiceName)
+          .WithDisplayName("Content (GPU process)")
+          .ExposeCapability("browser",
+                            std::set<const char*>{
+                                "content.mojom.Child",
+                                "content.mojom.ChildHistogramFetcher",
+                                "content.mojom.ChildHistogramFetcherFactory",
+                                "content.mojom.ChildProcess",
+                                "content.mojom.ResourceUsageReporter",
+                                "IPC.mojom.ChannelBootstrap",
+                                "ui.ozone.mojom.DeviceCursor",
+                                "ui.ozone.mojom.DrmDevice",
+                                "ui.ozone.mojom.WaylandBufferManagerGpu",
+                                "ui.mojom.ScenicGpuService",
+                                "viz.mojom.CompositingModeReporter",
+                                "viz.mojom.VizMain",
+                            })
+          .RequireCapability("device", "device:power_monitor")
+          .RequireCapability(mojom::kSystemServiceName, "dwrite_font_proxy")
+          .RequireCapability(mojom::kSystemServiceName, "field_trials")
+          .RequireCapability(mojom::kSystemServiceName, "gpu")
+          .RequireCapability("ui", "discardable_memory")
+          .RequireCapability("*", "app")
+          .RequireCapability("metrics", "url_keyed_metrics")
+          .Build()};
+  return *manifest;
+}
+
+}  // namespace content

content/public/app/content_gpu_manifest.h

+// Copyright 2019 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.
+
+#ifndef CONTENT_PUBLIC_APP_CONTENT_GPU_MANIFEST_H_
+#define CONTENT_PUBLIC_APP_CONTENT_GPU_MANIFEST_H_
+
+#include "services/service_manager/public/cpp/manifest.h"
+
+namespace content {
+
+// Returns the service manifest for the "content_gpu" service. Every GPU process
+// is an instance of this service, so this manifest determines what capabilities
+// are directly exposed and required by GPU processes through the Service
+// Manager.
+const service_manager::Manifest& GetContentGpuManifest();
+
+}  // namespace content
+
+#endif  // CONTENT_PUBLIC_APP_CONTENT_GPU_MANIFEST_H_

content/public/app/content_plugin_manifest.cc

+// Copyright 2019 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/public/app/content_plugin_manifest.h"
+
+#include "base/no_destructor.h"
+#include "content/public/common/service_names.mojom.h"
+#include "services/service_manager/public/cpp/manifest_builder.h"
+
+namespace content {
+
+const service_manager::Manifest& GetContentPluginManifest() {
+  static base::NoDestructor<service_manager::Manifest> manifest{
+      service_manager::ManifestBuilder()
+          .WithServiceName(mojom::kPluginServiceName)
+          .WithDisplayName("Content (plugin process)")
+          .ExposeCapability("browser",
+                            std::set<const char*>{
+                                "content.mojom.Child",
+                                "content.mojom.ChildHistogramFetcher",
+                                "content.mojom.ChildHistogramFetcherFactory",
+                                "content.mojom.ChildProcess",
+                                "content.mojom.ResourceUsageReporter",
+                                "IPC.mojom.ChannelBootstrap",
+                            })
+          .RequireCapability("device", "device:power_monitor")
+          .RequireCapability(mojom::kSystemServiceName, "dwrite_font_proxy")
+          .RequireCapability(mojom::kSystemServiceName, "field_trials")
+          .RequireCapability(mojom::kSystemServiceName, "font_cache")
+          .RequireCapability(mojom::kSystemServiceName, "plugin")
+          .RequireCapability(mojom::kSystemServiceName, "sandbox_support")
+          .RequireCapability("ui", "discardable_memory")
+          .RequireCapability("*", "app")
+          .RequireCapability("font_service", "font_service")
+          .Build()};
+  return *manifest;
+}
+
+}  // namespace content

content/public/app/content_plugin_manifest.h

+// Copyright 2019 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.
+
+#ifndef CONTENT_PUBLIC_APP_CONTENT_PLUGIN_MANIFEST_H_
+#define CONTENT_PUBLIC_APP_CONTENT_PLUGIN_MANIFEST_H_
+
+#include "services/service_manager/public/cpp/manifest.h"
+
+namespace content {
+
+// Returns the service manifest for the "content_plugin" service. Every
+// plugin process is an instance of this service, so this manifest determines
+// what capabilities are directly exposed and required by plugin processes
+// through the Service Manager.
+const service_manager::Manifest& GetContentPluginManifest();
+
+}  // namespace content
+
+#endif  // CONTENT_PUBLIC_APP_CONTENT_PLUGIN_MANIFEST_H_

content/public/common/child_process_host.h

@@ -54,18 +54,11 @@ class CONTENT_EXPORT ChildProcessHost : public IPC::Sender {
   // This enum (given to |Create()|) determines how the ChildProcessHost uses
   // the pipe.
   enum class IpcMode {
-    // In this mode, the primordial pipe is a content.mojom.ChildProcess pipe.
-    // The ChildProcessHost is fully functional in this mode, and all new
-    // process hosts should prefer to use this mode.
-    kNormal,
-
     // In this mode, the primordial pipe is a service_manager.mojom.Service
     // pipe, and the owner of the ChildProcessHost is expected to pass the
     // Mojo invitation along to a content::ChildProcessConnection.
     //
     // In this mode, the ChildProcessHost is fully functional.
-    //
-    // DEPRECATED: Do not introduce new uses of this mode.
     kServiceManager,
 
     // In this mode, the primordial pipe is a legacy IPC Channel bootstrapping

content/public/common/service_names.mojom

@@ -15,10 +15,18 @@ const string kSystemServiceName = "content_system";
 // for that BrowserContext.
 const string kBrowserServiceName = "content_browser";
 
+// The default service name used to identify the gpu process when connecting it
+// to the Service Manager.
+const string kGpuServiceName = "content_gpu";
+
 // The service name used to identify the browser process's singleton service
 // instance which packages other browser-wide services.
 const string kPackagedServicesServiceName = "content_packaged_services";
 
+// The default service name used to identify plugin processes when connecting
+// them to the Service Manager.
+const string kPluginServiceName = "content_plugin";
+
 // The default service name used to identify render processes when connecting
 // them to the Service Manager.
 const string kRendererServiceName = "content_renderer";