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)
 #include <unistd.h>
 #endif
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/rand_util.h"
 #include "components/nacl/common/nacl_messages.h"
 #include "components/nacl/loader/nacl_ipc_adapter.h"
 #include "components/nacl/loader/nacl_validation_db.h"
 #include "components/nacl/loader/nacl_validation_query.h"
 #include "ipc/ipc_channel_handle.h"
 #include "ipc/ipc_switches.h"
 #include "ipc/ipc_sync_channel.h"
 #include "ipc/ipc_sync_message_filter.h"
+#include "native_client/src/public/nacl_app.h"

[teravest, 2014/02/04 22:21:06]

Presumably this is gated on some change to native_client?

[hidehiko, 2014/02/05 06:30:16]

Yes, this is based on crrev.com/153453002, and I'll wait for the NaCl roll with
it.

 #include "native_client/src/trusted/service_runtime/sel_main_chrome.h"
 #include "native_client/src/trusted/validator/nacl_file_info.h"
 
 #if defined(OS_POSIX)
 #include "base/file_descriptor_posix.h"
 #endif
 
 #if defined(OS_LINUX)
 #include "components/nacl/loader/nonsfi/nonsfi_main.h"
 #include "content/public/common/child_process_sandbox_support_linux.h"
@@ skipping 64 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
+
+  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 105 matching lines @@
 bool NaClListener::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(NaClListener, msg)
       IPC_MESSAGE_HANDLER(NaClProcessMsg_Start, OnStart)
       IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void NaClListener::OnStart(const nacl::NaClStartParams& params) {
-  struct NaClChromeMainArgs *args = NaClChromeMainArgsCreate();
+  NaClChromeMainInit();
+
+  struct NaClChromeMainArgs* args = NaClChromeMainArgsCreate();
   if (args == NULL) {
     LOG(ERROR) << "NaClChromeMainArgsCreate() failed";
     return;
   }
 
+  struct NaClApp* nap = NaClAppMake();
+  DCHECK(nap != NULL);

[teravest, 2014/02/04 22:21:06]

I think you want to LOG(ERROR) and return if nap is NULL here, instead of
DCHECK().

[hidehiko, 2014/02/05 06:30:16]

Done, but the method won't seem to return NULL (i.e., if failed it would crash)?

   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.
-    args->initial_ipc_desc = 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->urandom_fd = dup(base::GetUrandomFD());
   if (args->urandom_fd < 0) {
     LOG(ERROR) << "Failed to dup() the urandom FD";
     return;
@@ skipping 63 matching lines @@
   args->prereserved_sandbox_size = prereserved_sandbox_size_;
 #endif
 
 #if defined(OS_LINUX)
   if (params.enable_nonsfi_mode) {
     nacl::nonsfi::MainStart(args->imc_bootstrap_handle);
     NOTREACHED();
     return;
   }
 #endif
-  NaClChromeMainStart(args);
+  NaClChromeMainStartApp(nap, args);
   NOTREACHED();
 }