Tell nacl_helper to use non SFI mode in HandleForkRequest

components/nacl/browser/nacl_process_host.cc

 // Copyright (c) 2012 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/browser/nacl_process_host.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 411 matching lines @@
   // We'll make sure this actually finished in StartWithLaunchedProcess, below.
   NaClBrowser* nacl_browser = NaClBrowser::GetInstance();
   nacl_browser->EnsureAllResourcesAvailable();
   if (!nacl_browser->IsOk()) {
     SendErrorToRenderer("could not find all the resources needed"
                         " to launch the process");
     delete this;
     return;
   }
 
+  if (uses_nonsfi_mode_) {
+#if defined(OS_LINUX)
+    const bool kNonSFIModeSupported = true;
+#else
+    const bool kNonSFIModeSupported = false;
+#endif
+    if (!kNonSFIModeSupported ||
+        !cmd->HasSwitch(switches::kEnableNaClNonSfiMode)) {
+      SendErrorToRenderer("NaCl non-SFI mode works only on Linux with"
+                          " --enable-nacl-nonsfi-mode specified");
+      delete this;
+      return;
+    }
+  }
+
   // Rather than creating a socket pair in the renderer, and passing
   // one side through the browser to sel_ldr, socket pairs are created
   // in the browser and then passed to the renderer and sel_ldr.
   //
   // This is mainly for the benefit of Windows, where sockets cannot
   // be passed in messages, but are copied via DuplicateHandle().
   // This means the sandboxed renderer cannot send handles to the
   // browser process.
 
   NaClHandle pair[2];
@@ skipping 143 matching lines @@
       env->SetVar(kPath, new_path);
     }
 #endif  // _DLL
   }
 #endif
 
   scoped_ptr<CommandLine> cmd_line(new CommandLine(exe_path));
   CopyNaClCommandLineArguments(cmd_line.get());
 
   cmd_line->AppendSwitchASCII(switches::kProcessType,
-                              switches::kNaClLoaderProcess);
+                              (uses_nonsfi_mode_ ?
+                               switches::kNaClLoaderNonSfiProcess :
+                               switches::kNaClLoaderProcess));
   cmd_line->AppendSwitchASCII(switches::kProcessChannelID, channel_id);
   if (NaClBrowser::GetDelegate()->DialogsAreSuppressed())
     cmd_line->AppendSwitch(switches::kNoErrorDialogs);
 
   // On Windows we might need to start the broker process to launch a new loader
 #if defined(OS_WIN)
   if (RunningOnWOW64()) {
     if (!NaClBrokerService::GetInstance()->LaunchLoader(
             weak_factory_.GetWeakPtr(), channel_id)) {
       SendErrorToRenderer("broker service did not launch process");
@@ skipping 164 matching lines @@
   params.validation_cache_enabled = nacl_browser->ValidationCacheIsEnabled();
   params.validation_cache_key = nacl_browser->GetValidationCacheKey();
   params.version = NaClBrowser::GetDelegate()->GetVersionString();
   params.enable_exception_handling = enable_exception_handling_;
   params.enable_debug_stub = enable_debug_stub_ &&
       NaClBrowser::GetDelegate()->URLMatchesDebugPatterns(manifest_url_);
   // Enable PPAPI proxy channel creation only for renderer processes.
   params.enable_ipc_proxy = enable_ppapi_proxy();
   params.uses_irt = uses_irt_;
   params.enable_dyncode_syscalls = enable_dyncode_syscalls_;
-  params.uses_nonsfi_mode = uses_nonsfi_mode_;
 
   const ChildProcessData& data = process_->GetData();
   if (!ShareHandleToSelLdr(data.handle,
                            internal_->socket_for_sel_ldr, true,
                            &params.handles)) {
     return false;
   }
 
   if (params.uses_irt) {
     base::PlatformFile irt_file = nacl_browser->IrtFile();
@@ skipping 29 matching lines @@
 #if defined(OS_POSIX)
   if (params.enable_debug_stub) {
     net::SocketDescriptor server_bound_socket = GetDebugStubSocketHandle();
     if (server_bound_socket != net::kInvalidSocket) {
       params.debug_stub_server_bound_socket =
           FileDescriptor(server_bound_socket, true);
     }
   }
 #endif
 
-  if (params.uses_nonsfi_mode) {
-#if defined(OS_LINUX)
-    const bool kNonSFIModeSupported = true;
-#else
-    const bool kNonSFIModeSupported = false;
-#endif
-    if (!kNonSFIModeSupported ||
-        !CommandLine::ForCurrentProcess()->HasSwitch(
-            switches::kEnableNaClNonSfiMode)) {
-      return false;
-    }
-  }
-
   process_->Send(new NaClProcessMsg_Start(params));
 
   internal_->socket_for_sel_ldr = NACL_INVALID_HANDLE;
   return true;
 }
 
 // This method is called when NaClProcessHostMsg_PpapiChannelCreated is
 // received.
 void NaClProcessHost::OnPpapiChannelsCreated(
     const IPC::ChannelHandle& browser_channel_handle,
@@ skipping 228 matching lines @@
         process_handle.Take(), info,
         base::MessageLoopProxy::current(),
         base::Bind(&NaClProcessHost::OnDebugExceptionHandlerLaunchedByBroker,
                    weak_factory_.GetWeakPtr()));
     return true;
   }
 }
 #endif
 
 }  // namespace nacl