Add PDF compositor service

content/browser/utility_process_host_impl.cc

 // Copyright (c) 2012 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/utility_process_host_impl.h"
 
+#include <memory>
 #include <utility>
 
 #include "base/base_switches.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/lazy_instance.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/process/process_handle.h"
 #include "base/run_loop.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "build/build_config.h"
+#include "components/discardable_memory/service/discardable_shared_memory_manager.h"
 #include "content/browser/browser_child_process_host_impl.h"
+#include "content/browser/browser_main_loop.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/service_manager/service_manager_context.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/utility_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/utility_process_host_client.h"
+#include "content/public/common/connection_filter.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/mojo_channel_switches.h"
 #include "content/public/common/process_type.h"
 #include "content/public/common/sandbox_type.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 "mojo/edk/embedder/embedder.h"
+#include "services/service_manager/public/cpp/binder_registry.h"
 #include "services/service_manager/public/cpp/interface_provider.h"
 #include "ui/base/ui_base_switches.h"
 
 #if defined(OS_POSIX) && !defined(OS_ANDROID) && !defined(OS_MACOSX)
 #include "content/public/browser/zygote_handle_linux.h"
 #endif  // defined(OS_POSIX) && !defined(OS_ANDROID) && !defined(OS_MACOSX)
 
 #if defined(OS_WIN)
 #include "sandbox/win/src/sandbox_policy.h"
 #include "sandbox/win/src/sandbox_types.h"
@@ skipping 74 matching lines @@
 #elif defined(OS_POSIX)
   base::EnvironmentMap env_;
 #if !defined(OS_MACOSX) && !defined(OS_ANDROID)
   bool no_sandbox_;
 #endif  // !defined(OS_MACOSX) && !defined(OS_ANDROID)
 #endif  // OS_WIN
 };
 
 UtilityMainThreadFactoryFunction g_utility_main_thread_factory = NULL;
 
+class UtilityProcessHost::ConnectionFilterImpl : public ConnectionFilter {
+ public:
+  ConnectionFilterImpl(
+      std::unique_ptr<service_manager::BinderRegistry> registry)
+      : registry_(std::move(registry)) {}
+
+ private:
+  // ConnectionFilter:
+  void OnBindInterface(const service_manager::ServiceInfo& source_info,
+                       const std::string& interface_name,
+                       mojo::ScopedMessagePipeHandle* interface_pipe,
+                       service_manager::Connector* connector) override {
+    if (registry_->CanBindInterface(interface_name)) {
+      registry_->BindInterface(source_info.identity, interface_name,
+                               std::move(*interface_pipe));
+    }
+  }
+
+  std::unique_ptr<service_manager::BinderRegistry> registry_;
+
+  DISALLOW_COPY_AND_ASSIGN(ConnectionFilterImpl);
+};
+
 UtilityProcessHost* UtilityProcessHost::Create(
     const scoped_refptr<UtilityProcessHostClient>& client,
     const scoped_refptr<base::SequencedTaskRunner>& client_task_runner) {
   return new UtilityProcessHostImpl(client, client_task_runner);
 }
 
 void UtilityProcessHostImpl::RegisterUtilityMainThreadFactory(
     UtilityMainThreadFactoryFunction create) {
   g_utility_main_thread_factory = create;
 }
@@ skipping 79 matching lines @@
   return StartProcess();
 }
 
 void UtilityProcessHostImpl::BindInterface(
     const std::string& interface_name,
     mojo::ScopedMessagePipeHandle interface_pipe) {
   process_->child_connection()->BindInterface(interface_name,
                                               std::move(interface_pipe));
 }
 
+void UtilityProcessHostImpl::RegisterMojoServicesOnUIThread(
+    service_manager::BinderRegistry* registry) {
+  if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
+    BrowserThread::GetTaskRunnerForThread(BrowserThread::UI)
+        ->PostTask(
+            FROM_HERE,
+            base::Bind(&UtilityProcessHostImpl::RegisterMojoServicesOnUIThread,
+                       base::Unretained(this), registry));
+  } else {
+    registry->AddInterface(
+        base::Bind(
+            &memory_instrumentation::CoordinatorImpl::BindCoordinatorRequest,
+            base::Unretained(
+                memory_instrumentation::CoordinatorImpl::GetInstance())),
+        BrowserThread::GetTaskRunnerForThread(BrowserThread::UI));
+
+    discardable_memory::DiscardableSharedMemoryManager* manager =
+        BrowserMainLoop::GetInstance()->discardable_shared_memory_manager();
+    registry->AddInterface(
+        base::Bind(&discardable_memory::DiscardableSharedMemoryManager::Bind,
+                   base::Unretained(manager)),
+        BrowserThread::GetTaskRunnerForThread(BrowserThread::UI));
+  }
+}
+
+void UtilityProcessHostImpl::RegisterMojoServices() {
+  auto registry = base::MakeUnique<service_manager::BinderRegistry>();
+  // May be null during test execution.
+  if (ServiceManagerConnection::GetForProcess()) {
+    RegisterMojoServicesOnUIThread(registry.get());

[Lei Zhang, 2017/04/27 22:42:21]

Does this have to finish on the UI thread, before AddConnectionFilter() ?
Assuming we are on the IO thread here, likely the actual execution order will be
PostTask(), AddConnectionFilter(), then whatever
RegisterMojoServicesOnUIThread() really needs to do.

[Wei Li, 2017/04/29 04:35:18]

The order shouldn't matter. I changed it anyway based on your previous comment.

+    ServiceManagerConnection::GetForProcess()->AddConnectionFilter(
+        base::MakeUnique<ConnectionFilterImpl>(std::move(registry)));
+  }
+}
+
 void UtilityProcessHostImpl::SetName(const base::string16& name) {
   name_ = name;
 }
 
 #if defined(OS_POSIX) && !defined(OS_ANDROID) && !defined(OS_MACOSX)
 // static
 void UtilityProcessHostImpl::EarlyZygoteLaunch() {
   DCHECK(!g_utility_zygote);
   g_utility_zygote = CreateZygote();
 }
@@ skipping 157 matching lines @@
     base::WeakPtr<UtilityProcessHostImpl> host,
     int error_code) {
   if (!host)
     return;
 
   host->OnProcessLaunchFailed(error_code);
   delete host.get();
 }
 
 }  // namespace content