Add an IPC channel between the NaCl loader process and the renderer.

chrome/browser/nacl_host/nacl_process_host.cc

Index: chrome/browser/nacl_host/nacl_process_host.cc
===================================================================
--- chrome/browser/nacl_host/nacl_process_host.cc	(revision 143037)
+++ chrome/browser/nacl_host/nacl_process_host.cc	(working copy)
@@ -110,6 +110,7 @@
 struct NaClProcessHost::NaClInternal {
   std::vector<nacl::Handle> sockets_for_renderer;
   std::vector<nacl::Handle> sockets_for_sel_ldr;
+  std::vector<nacl::FileDescriptor> handles_for_renderer;
 };
 
 // -----------------------------------------------------------------------------
@@ -537,6 +538,8 @@
     IPC_MESSAGE_HANDLER_DELAY_REPLY(NaClProcessMsg_AttachDebugExceptionHandler,
                                     OnAttachDebugExceptionHandler)
 #endif
+    IPC_MESSAGE_HANDLER(NaClProcessHostMsg_PpapiChannelCreated,
+                        OnPpapiChannelCreated)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
@@ -556,8 +559,7 @@
   }
 }
 
-bool NaClProcessHost::ReplyToRenderer() {

[Mark Seaborn, 2012/06/20 19:24:40]

Why do you need to merge ReplyToRenderer() and StartNaClExecution()?  When
enable_ipc_proxy is true, you can just defer the call to ReplyToRenderer() until
OnPpapiChannelCreated().  That would avoid a handle lifetime/cleanup issue
below...

[bbudge, 2012/06/21 00:00:46]

I merged these because we now have to wait for the asynchronous reply from
sel_ldr before replying to the renderer. This was the cleanest way I could see
to do this. The non-IPC case looks a little strange but I favored the IPC proxy
case because we'll remove the old path in the near future. See my comment about
handle cleanup below.

[Mark Seaborn, 2012/06/21 15:30:03]

I understand why you've done it, but I don't think you need to move all this
code around.  I think you can do something like this:

bool NaClProcessHost::SendStart() {
  if (!enable_ipc_proxy_) {
    if (!ReplyToRenderer(IPC::ChannelHandle()))
      return false;
    }
  }
  return StartNaClExecution();
}

void NaClProcessHost::OnPpapiChannelCreated(
    const IPC::ChannelHandle& channel_handle) {
  DCHECK(enable_ipc_proxy_);
  ReplyToRenderer(channel_handle);
}

+ add a ChannelHandle arg to ReplyToRenderer()

[bbudge, 2012/06/21 18:16:53]

Done. Good idea, it's a much smaller change this way.

-  std::vector<nacl::FileDescriptor> handles_for_renderer;
+bool NaClProcessHost::SendStart() {
   for (size_t i = 0; i < internal_->sockets_for_renderer.size(); i++) {
 #if defined(OS_WIN)
     // Copy the handle into the renderer process.
@@ -573,7 +575,7 @@
       DLOG(ERROR) << "DuplicateHandle() failed";
       return false;
     }
-    handles_for_renderer.push_back(
+    internal_->handles_for_renderer.push_back(
         reinterpret_cast<nacl::FileDescriptor>(handle_in_renderer));
 #else
     // No need to dup the imc_handle - we don't pass it anywhere else so
@@ -581,10 +583,11 @@
     nacl::FileDescriptor imc_handle;
     imc_handle.fd = internal_->sockets_for_renderer[i];
     imc_handle.auto_close = true;
-    handles_for_renderer.push_back(imc_handle);
+    internal_->handles_for_renderer.push_back(imc_handle);
 #endif
   }
 
+  const ChildProcessData& data = process_->GetData();
 #if defined(OS_WIN)
   // If we are on 64-bit Windows, the NaCl process's sandbox is
   // managed by a different process from the renderer's sandbox.  We
@@ -592,23 +595,13 @@
   // that the renderer can send handles to the NaCl process using
   // BrokerDuplicateHandle().
   if (RunningOnWOW64()) {
-    if (!content::BrokerAddTargetPeer(process_->GetData().handle)) {
+    if (!content::BrokerAddTargetPeer(data.handle)) {
       DLOG(ERROR) << "Failed to add NaCl process PID";
       return false;
     }
   }
 #endif
 
-  ChromeViewHostMsg_LaunchNaCl::WriteReplyParams(
-      reply_msg_, handles_for_renderer);
-  chrome_render_message_filter_->Send(reply_msg_);
-  chrome_render_message_filter_ = NULL;
-  reply_msg_ = NULL;
-  internal_->sockets_for_renderer.clear();

[Mark Seaborn, 2012/06/20 19:24:40]

Removing this call isn't quite right.  If NaClProcessHost() gets destroyed, it
will try to close handles in sockets_for_renderer that have already been closed
(via DUPLICATE_CLOSE_SOURCE), which is unsafe.  The code isn't right before this
change, but the change increases the window in which things can go wrong.

[bbudge, 2012/06/21 00:00:46]

I'm adding a TODO to fix this. I think we should clean up here at the point of
failure.

-  return true;
-}
-
-bool NaClProcessHost::StartNaClExecution() {
   NaClBrowser* nacl_browser = NaClBrowser::GetInstance();
 
   nacl::NaClStartParams params;
@@ -618,11 +611,12 @@
   params.enable_exception_handling = enable_exception_handling_;
   params.enable_debug_stub =
       CommandLine::ForCurrentProcess()->HasSwitch(switches::kEnableNaClDebug);
+  params.enable_ipc_proxy = CommandLine::ForCurrentProcess()->HasSwitch(
+                                switches::kEnableNaClIPCProxy);
 
   base::PlatformFile irt_file = nacl_browser->IrtFile();
   CHECK_NE(irt_file, base::kInvalidPlatformFileValue);
 
-  const ChildProcessData& data = process_->GetData();
   for (size_t i = 0; i < internal_->sockets_for_sel_ldr.size(); i++) {
     if (!ShareHandleToSelLdr(data.handle,
                              internal_->sockets_for_sel_ldr[i], true,
@@ -658,14 +652,36 @@
   params.handles.push_back(memory_fd);
 #endif
 
+  // The start message should only be sent once we are sure we won't delete
+  // ourselves.
   process_->Send(new NaClProcessMsg_Start(params));
 
   internal_->sockets_for_sel_ldr.clear();
+
+  // If we aren't creating the IPC channel, send the reply message without
+  // waiting for the NaCl process to signal that it's ready.
+  // TODO(bbudge) remove this after we switch to the IPC proxy.
+  if (!params.enable_ipc_proxy) {
+    OnPpapiChannelCreated(IPC::ChannelHandle());
+  }
+
   return true;
 }
 
-bool NaClProcessHost::SendStart() {
-  return ReplyToRenderer() && StartNaClExecution();
+void NaClProcessHost::OnPpapiChannelCreated(
+    const IPC::ChannelHandle& channel_handle) {
+  // Now that the server end of the channel has been created, send the reply to
+  // the renderer.
+  base::ProcessId nacl_process_id = base::GetProcId(process_->GetData().handle);
+  ChromeViewHostMsg_LaunchNaCl::WriteReplyParams(
+      reply_msg_, internal_->handles_for_renderer, channel_handle,
+      nacl_process_id);
+  chrome_render_message_filter_->Send(reply_msg_);
+  chrome_render_message_filter_ = NULL;
+  reply_msg_ = NULL;
+
+  internal_->sockets_for_renderer.clear();
+  internal_->handles_for_renderer.clear();
 }
 
 bool NaClProcessHost::StartWithLaunchedProcess() {