Add multiplexing of message pipes in the new EDK.

mojo/runner/host/child_process.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/host/child_process.h"
 
 #include "base/base_switches.h"
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
@@ skipping 106 matching lines @@
     base::Thread::Options io_thread_options(base::MessageLoop::TYPE_IO, 0);
     CHECK(io_thread_.StartWithOptions(io_thread_options));
     io_runner_ = io_thread_.task_runner().get();
     CHECK(io_runner_.get());
 
     // TODO(vtl): This should be SLAVE, not NONE.
     // This must be created before controller_thread_ since MessagePumpMojo will
     // create a message pipe which requires this code to be run first.
     embedder::InitIPCSupport(embedder::ProcessType::NONE, this, io_runner_,
                              embedder::ScopedPlatformHandle());
+  }
 
+  void StartControllerThread() {
     // Create and start our controller thread.
     base::Thread::Options controller_thread_options;
     controller_thread_options.message_loop_type =
         base::MessageLoop::TYPE_CUSTOM;
     controller_thread_options.message_pump_factory =
         base::Bind(&common::MessagePumpMojo::Create);
     CHECK(controller_thread_.StartWithOptions(controller_thread_options));
     controller_runner_ = controller_thread_.task_runner().get();
     CHECK(controller_runner_.get());
   }
@@ skipping 160 matching lines @@
   return sandbox.Pass();
 }
 #endif
 
 ScopedMessagePipeHandle InitializeHostMessagePipe(
     embedder::ScopedPlatformHandle platform_channel,
     scoped_refptr<base::TaskRunner> io_task_runner) {
   ScopedMessagePipeHandle host_message_pipe(embedder::CreateChannel(
       platform_channel.Pass(), base::Bind(&DidCreateChannel), io_task_runner));
 
-#if defined(OS_WIN)
   if (base::CommandLine::ForCurrentProcess()->HasSwitch("use-new-edk")) {
     // When using the new Mojo EDK, each message pipe is backed by a platform
     // handle. The one platform handle that comes on the command line is used
     // to bind to the ChildController interface. However we also want a
     // platform handle to setup the communication channel by which we exchange
     // handles to/from tokens, which is needed for sandboxed Windows
     // processes.
     char broker_handle[10];
     MojoHandleSignalsState state;
     MojoResult rv =
@@ skipping 13 matching lines @@
     embedder::SetParentPipeHandle(
         mojo::embedder::ScopedPlatformHandle(mojo::embedder::PlatformHandle(
             broker_channel.release().
 #if defined(OS_WIN)
                                     handle
 #else
                                     fd
 #endif
             )));
   }
-#else
-  // TODO(jam): hook up on POSIX
-#endif
 
   return host_message_pipe.Pass();
 }
 
 }  // namespace
 
 int ChildProcessMain() {
   DVLOG(2) << "ChildProcessMain()";
   const base::CommandLine& command_line =
       *base::CommandLine::ForCurrentProcess();
@@ skipping 23 matching lines @@
       embedder::PlatformChannelPair::PassClientHandleFromParentProcess(
           command_line);
   CHECK(platform_channel.is_valid());
 
   DCHECK(!base::MessageLoop::current());
 
   AppContext app_context;
   app_context.Init();
   ScopedMessagePipeHandle host_message_pipe = InitializeHostMessagePipe(
       platform_channel.Pass(), app_context.io_runner());
+  app_context.StartControllerThread();
   Blocker blocker;
   app_context.controller_runner()->PostTask(
       FROM_HERE,
       base::Bind(&ChildControllerImpl::Init, base::Unretained(&app_context),
                  base::Unretained(app_library),
                  base::Passed(&host_message_pipe), blocker.GetUnblocker()));
   // This will block, then run whatever the controller wants.
   blocker.Block();
 
   app_context.Shutdown();
 
   return 0;
 }
 
 }  // namespace runner
 }  // namespace mojo