Add a Mojo EDK for Chrome that uses one OS pipe per message pipe.

mojo/runner/child_process_host.cc

 // Copyright 2014 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 "mojo/runner/child_process_host.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/process/kill.h"
 #include "base/process/launch.h"
 #include "base/task_runner.h"
 #include "base/task_runner_util.h"
 #include "base/thread_task_runner_handle.h"
-#include "mojo/edk/embedder/embedder.h"
 #include "mojo/public/cpp/bindings/interface_ptr_info.h"
 #include "mojo/public/cpp/system/core.h"
 #include "mojo/runner/context.h"
 #include "mojo/runner/switches.h"
 #include "mojo/runner/task_runners.h"
 
+#if defined(USE_CHROME_EDK)
+#include "mojo/edk/embedder/embedder.h"
+#else
+#include "third_party/mojo/src/mojo/edk/embedder/embedder.h"
+#endif
+
 #if defined(OS_LINUX) && !defined(OS_ANDROID)
 #include "sandbox/linux/services/namespace_sandbox.h"
 #endif
 
 namespace mojo {
 namespace runner {
 
 ChildProcessHost::ChildProcessHost(Context* context,
                                    bool start_sandboxed,
                                    const base::FilePath& app_path)
     : context_(context),
       start_sandboxed_(start_sandboxed),
-      app_path_(app_path),
-      channel_info_(nullptr) {
+      app_path_(app_path)
+#if !defined(USE_CHROME_EDK)
+      ,
+      channel_info_(nullptr)
+#endif
+{
   platform_channel_ = platform_channel_pair_.PassServerHandle();
   CHECK(platform_channel_.is_valid());
 }
 
 ChildProcessHost::~ChildProcessHost() {
   if (child_process_.IsValid()) {
     LOG(WARNING) << "Destroying ChildProcessHost with unjoined child";
     child_process_.Close();
   }
 }
 
 void ChildProcessHost::Start() {
   DCHECK(!child_process_.IsValid());
   DCHECK(platform_channel_.is_valid());
 
+#if defined(USE_CHROME_EDK)
+  ScopedMessagePipeHandle handle(
+      edk::CreateMessagePipe(platform_channel_.Pass()));
+#else
   ScopedMessagePipeHandle handle(embedder::CreateChannel(
       platform_channel_.Pass(),
       base::Bind(&ChildProcessHost::DidCreateChannel, base::Unretained(this)),
       base::ThreadTaskRunnerHandle::Get()));
+#endif
 
   controller_.Bind(InterfacePtrInfo<ChildController>(handle.Pass(), 0u));
 
   CHECK(base::PostTaskAndReplyWithResult(
       context_->task_runners()->blocking_pool(), FROM_HERE,
       base::Bind(&ChildProcessHost::DoLaunch, base::Unretained(this)),
       base::Bind(&ChildProcessHost::DidStart, base::Unretained(this))));
 }
 
 int ChildProcessHost::Join() {
@@ skipping 35 matching lines @@
 bool ChildProcessHost::DoLaunch() {
   const base::CommandLine* parent_command_line =
       base::CommandLine::ForCurrentProcess();
   base::CommandLine child_command_line(parent_command_line->GetProgram());
   child_command_line.AppendArguments(*parent_command_line, false);
   child_command_line.AppendSwitchPath(switches::kChildProcess, app_path_);
 
   if (start_sandboxed_)
     child_command_line.AppendSwitch(switches::kEnableSandbox);
 
+#if defined(USE_CHROME_EDK)
+  edk::HandlePassingInformation handle_passing_info;
+  platform_channel_pair_.PrepareToPassClientHandleToChildProcess(
+      &child_command_line, &handle_passing_info);
+#else
   embedder::HandlePassingInformation handle_passing_info;
   platform_channel_pair_.PrepareToPassClientHandleToChildProcess(
       &child_command_line, &handle_passing_info);
+#endif
 
   base::LaunchOptions options;
 #if defined(OS_WIN)
   options.handles_to_inherit = &handle_passing_info;
 #elif defined(OS_POSIX)
   handle_passing_info.push_back(std::make_pair(STDIN_FILENO, STDIN_FILENO));
   handle_passing_info.push_back(std::make_pair(STDOUT_FILENO, STDOUT_FILENO));
   handle_passing_info.push_back(std::make_pair(STDERR_FILENO, STDERR_FILENO));
   options.fds_to_remap = &handle_passing_info;
 #endif
@@ skipping 20 matching lines @@
 }
 
 void ChildProcessHost::AppCompleted(int32_t result) {
   if (!on_app_complete_.is_null()) {
     auto on_app_complete = on_app_complete_;
     on_app_complete_.reset();
     on_app_complete.Run(result);
   }
 }
 
+#if !defined(USE_CHROME_EDK)
 void ChildProcessHost::DidCreateChannel(embedder::ChannelInfo* channel_info) {
   DVLOG(2) << "AppChildProcessHost::DidCreateChannel()";
 
   CHECK(channel_info);
   channel_info_ = channel_info;
 }
+#endif
 
 }  // namespace runner
 }  // namespace mojo