Create IPC channel to communicate with the renderer in NaClListener::OnStart().

components/nacl/loader/nacl_listener.cc

 // Copyright 2013 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 "components/nacl/loader/nacl_listener.h"
 
 #include <errno.h>
 #include <stdlib.h>
 
 #if defined(OS_POSIX)
@@ skipping 91 matching lines @@
   std::string info_string(reinterpret_cast<const char*>(info), info_size);
   bool result = false;
   if (!g_listener->Send(new NaClProcessMsg_AttachDebugExceptionHandler(
            info_string, &result)))
     return false;
   return result;
 }
 
 #endif
 
+// Creates the PPAPI IPC channel between the NaCl IRT and the host
+// (browser/renderer) process, and starts to listen it on the thread where
+// the given message_loop_proxy runs.
+// Also, creates and sets the corresponding NaClDesc to the given nap with
+// the FD #.
+void SetUpIPCAdapter(IPC::ChannelHandle* handle,
+                     scoped_refptr<base::MessageLoopProxy> message_loop_proxy,
+                     struct NaClApp* nap,
+                     int nacl_fd) {
+  scoped_refptr<NaClIPCAdapter> ipc_adapter(
+      new NaClIPCAdapter(*handle, message_loop_proxy.get()));
+  ipc_adapter->ConnectChannel();
+#if defined(OS_POSIX)
+  handle->socket =
+      base::FileDescriptor(ipc_adapter->TakeClientFileDescriptor(), true);
+#endif
+
+  // Pass a NaClDesc to the untrusted side. This will hold a ref to the
+  // NaClIPCAdapter.
+  NaClAppSetDesc(nap, nacl_fd, ipc_adapter->MakeNaClDesc());
+}
+
 }  // namespace
 
 class BrowserValidationDBProxy : public NaClValidationDB {
  public:
   explicit BrowserValidationDBProxy(NaClListener* listener)
       : listener_(listener) {
   }
 
   virtual bool QueryKnownToValidate(const std::string& signature) OVERRIDE {
     // Initialize to false so that if the Send fails to write to the return
@@ skipping 120 matching lines @@
   }
   NaClChromeMainSetUrandomFd(urandom_fd);
 #endif
 
   NaClChromeMainInit();
   struct NaClChromeMainArgs *args = NaClChromeMainArgsCreate();
   if (args == NULL) {
     LOG(ERROR) << "NaClChromeMainArgsCreate() failed";
     return;
   }
+
   struct NaClApp *nap = NaClAppCreate();
   if (nap == NULL) {
     LOG(ERROR) << "NaClAppCreate() failed";
     return;
   }
 
   if (params.enable_ipc_proxy) {
-    // Create the initial PPAPI IPC channel between the NaCl IRT and the
-    // browser process. The IRT uses this channel to communicate with the
-    // browser and to create additional IPC channels to renderer processes.
-    IPC::ChannelHandle handle =
+    // Create the PPAPI IPC channels between the NaCl IRT and the hosts
+    // (browser/renderer) processes. The IRT uses these channels to communicate
+    // with the host and to initialize the IPC dispatchers.
+    IPC::ChannelHandle browser_handle =
         IPC::Channel::GenerateVerifiedChannelID("nacl");
-    scoped_refptr<NaClIPCAdapter> ipc_adapter(
-        new NaClIPCAdapter(handle, io_thread_.message_loop_proxy().get()));
-    ipc_adapter->ConnectChannel();
+    SetUpIPCAdapter(&browser_handle, io_thread_.message_loop_proxy(),
+                    nap, NACL_CHROME_DESC_BASE);
 
-    // Pass a NaClDesc to the untrusted side. This will hold a ref to the
-    // NaClIPCAdapter.
-    NaClAppSetDesc(nap, NACL_CHROME_DESC_BASE, ipc_adapter->MakeNaClDesc());
-#if defined(OS_POSIX)
-    handle.socket = base::FileDescriptor(
-        ipc_adapter->TakeClientFileDescriptor(), true);
-#endif
-    if (!Send(new NaClProcessHostMsg_PpapiChannelCreated(handle)))
+    IPC::ChannelHandle renderer_handle =
+        IPC::Channel::GenerateVerifiedChannelID("nacl");
+    SetUpIPCAdapter(&renderer_handle, io_thread_.message_loop_proxy(),
+                    nap, NACL_CHROME_DESC_BASE + 1);
+
+    if (!Send(new NaClProcessHostMsg_PpapiChannelsCreated(
+            browser_handle, renderer_handle)))
       LOG(ERROR) << "Failed to send IPC channel handle to NaClProcessHost.";
   }
 
   std::vector<nacl::FileDescriptor> handles = params.handles;
 
 #if defined(OS_LINUX) || defined(OS_MACOSX)
   args->number_of_cores = number_of_cores_;
   args->create_memory_object_func = CreateMemoryObject;
 # if defined(OS_MACOSX)
   CHECK(handles.size() >= 1);
@@ skipping 61 matching lines @@
 #if defined(OS_LINUX)
   if (params.enable_nonsfi_mode) {
     nacl::nonsfi::MainStart(args->imc_bootstrap_handle);
     NOTREACHED();
     return;
   }
 #endif
   NaClChromeMainStartApp(nap, args);
   NOTREACHED();
 }