Tell nacl_helper to use non SFI mode in HandleForkRequest

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 182 matching lines @@
   }
 
  private:
   // The listener never dies, otherwise this might be a dangling reference.
   NaClListener* listener_;
 };
 
 
 NaClListener::NaClListener() : shutdown_event_(true, false),
                                io_thread_("NaCl_IOThread"),
+                               uses_nonsfi_mode_(false),
 #if defined(OS_LINUX)
                                prereserved_sandbox_size_(0),
 #endif
 #if defined(OS_POSIX)
                                number_of_cores_(-1),  // unknown/error
 #endif
                                main_loop_(NULL) {
   io_thread_.StartWithOptions(
       base::Thread::Options(base::MessageLoop::TYPE_IO, 0));
 #if defined(OS_WIN)
@@ skipping 37 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) {
+#if !defined(OS_LINUX)
+  CHECK(!uses_nonsfi_mode_) << "Non-SFI NaCl is only supported on Linux";
+#endif
 #if defined(OS_LINUX) || defined(OS_MACOSX)
   int urandom_fd = dup(base::GetUrandomFD());
   if (urandom_fd < 0) {
     LOG(ERROR) << "Failed to dup() the urandom FD";
     return;
   }
   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;
   }
 
   IPC::ChannelHandle browser_handle;
   IPC::ChannelHandle ppapi_renderer_handle;
 
   if (params.enable_ipc_proxy) {
     browser_handle = IPC::Channel::GenerateVerifiedChannelID("nacl");
     ppapi_renderer_handle = IPC::Channel::GenerateVerifiedChannelID("nacl");
 
-#if defined(OS_LINUX)

[Mark Seaborn, 2014/04/02 00:22:22]

You can't remove these #ifs.  This code won't compile/link on Mac or Windows.

[hamaji, 2014/04/02 03:20:44]

Ah, I forgot sending a try job. Thanks for checking this.

-    if (params.uses_nonsfi_mode) {
+    if (uses_nonsfi_mode_) {
       // In non-SFI mode, we neither intercept nor rewrite the message using
       // NaClIPCAdapter, and the channels are connected between the plugin and
       // the hosts directly. So, the IPC::Channel instances will be created in
       // the plugin side, because the IPC::Listener needs to live on the
       // plugin's main thread. However, on initialization (i.e. before loading
       // the plugin binary), the FD needs to be passed to the hosts. So, here
       // we create raw FD pairs, and pass the client side FDs to the hosts,
       // and the server side FDs to the plugin.
       int browser_server_ppapi_fd;
       int browser_client_ppapi_fd;
@@ skipping 10 matching lines @@
       // Set the plugin IPC channel FDs.
       SetIPCFileDescriptors(
           browser_server_ppapi_fd, renderer_server_ppapi_fd);
 
       // Send back to the client side IPC channel FD to the host.
       browser_handle.socket =
           base::FileDescriptor(browser_client_ppapi_fd, true);
       ppapi_renderer_handle.socket =
           base::FileDescriptor(renderer_client_ppapi_fd, true);
     } else {
-#endif
       // Create the PPAPI IPC channels between the NaCl IRT and the host
       // (browser/renderer) processes. The IRT uses these channels to
       // communicate with the host and to initialize the IPC dispatchers.
       SetUpIPCAdapter(&browser_handle, io_thread_.message_loop_proxy(),
                       nap, NACL_CHROME_DESC_BASE);
       SetUpIPCAdapter(&ppapi_renderer_handle, io_thread_.message_loop_proxy(),
                       nap, NACL_CHROME_DESC_BASE + 1);
-#if defined(OS_LINUX)
     }
-#endif
   }
 
   // The argument passed to GenerateVerifiedChannelID() here MUST be "nacl".
   // Using an alternate channel name prevents the pipe from being created on
   // Windows when the sandbox is enabled.
   IPC::ChannelHandle trusted_renderer_handle =
       IPC::Channel::GenerateVerifiedChannelID("nacl");
   trusted_listener_ = new NaClTrustedListener(
       trusted_renderer_handle, io_thread_.message_loop_proxy(),
       &shutdown_event_);
@@ skipping 71 matching lines @@
       params.debug_stub_server_bound_socket);
 #endif
 #if defined(OS_WIN)
   args->broker_duplicate_handle_func = BrokerDuplicateHandle;
   args->attach_debug_exception_handler_func = AttachDebugExceptionHandler;
 #endif
 #if defined(OS_LINUX)
   args->prereserved_sandbox_size = prereserved_sandbox_size_;
 #endif
 
-#if defined(OS_LINUX)
-  if (params.uses_nonsfi_mode) {
+  if (uses_nonsfi_mode_) {
     nacl::nonsfi::MainStart(args->imc_bootstrap_handle);
     return;
   }
-#endif
   NaClChromeMainStartApp(nap, args);
   NOTREACHED();
 }