Remove redundant use_nonsfi_mode from SelLdrStartParams.

ppapi/native_client/src/trusted/plugin/plugin.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 "ppapi/native_client/src/trusted/plugin/plugin.h"
 
 #include <sys/stat.h>
 #include <sys/types.h>
 
 #include <string>
@@ skipping 54 matching lines @@
                                       kTimeSmallMin, kTimeSmallMax,
                                       kTimeSmallBuckets);
 }
 
 bool Plugin::LoadNaClModuleFromBackgroundThread(
     PP_FileHandle file_handle,
     NaClSubprocess* subprocess,
     const SelLdrStartParams& params) {
   CHECK(!pp::Module::Get()->core()->IsMainThread());
   ServiceRuntime* service_runtime =
-      new ServiceRuntime(this, false, uses_nonsfi_mode_,
+      new ServiceRuntime(this,
+                         false,  // No main_service_runtime.
+                         false,  // No non-SFI mode (i.e. in SFI-mode).

[Mark Seaborn, 2014/06/17 15:16:55]

It's not obvious why it's OK to change this to 'false'.

Is it because LoadNaClModuleFromBackgroundThread() is only called from
LoadHelperNaClModule(), for the PNaCl translator?  It's not obvious, though,
that "from background thread" implies "for the PNaCl translator" and so "SFI
mode only".

Would it be worth adding a comment?

I suppose Non-SFI loading is covered by tests, so LGTM.  I'd like for Justin to
sign off on this, because he's more of an owner of this code than me.

[hidehiko, 2014/06/17 16:47:03]

Renamed the method name as Justin suggested. Also added short note that this is
for pnacl in the .h file.

                          pp::BlockUntilComplete(), pp::BlockUntilComplete());
   subprocess->set_service_runtime(service_runtime);
   PLUGIN_PRINTF(("Plugin::LoadNaClModuleFromBackgroundThread "
                  "(service_runtime=%p)\n",
                  static_cast<void*>(service_runtime)));
 
   // Now start the SelLdr instance.  This must be created on the main thread.
   bool service_runtime_started = false;
   pp::CompletionCallback sel_ldr_callback =
       callback_factory_.NewCallback(&Plugin::SignalStartSelLdrDone,
@@ skipping 77 matching lines @@
   // the ServiceRuntime object for an existing subprocess, and that any
   // associated listener threads do not go unjoined because if they
   // outlive the Plugin object, they will not be memory safe.
   ShutDownSubprocesses();
   pp::Var manifest_base_url =
       pp::Var(pp::PASS_REF, nacl_interface_->GetManifestBaseURL(pp_instance()));
   std::string manifest_base_url_str = manifest_base_url.AsString();
   SelLdrStartParams params(manifest_base_url_str,
                            true /* uses_irt */,
                            true /* uses_ppapi */,
-                           uses_nonsfi_mode,
                            enable_dyncode_syscalls,
                            enable_exception_handling,
                            enable_crash_throttling);
   ErrorInfo error_info;
-  ServiceRuntime* service_runtime =
-      new ServiceRuntime(this, true, uses_nonsfi_mode,
-                         init_done_cb, crash_cb);
+  ServiceRuntime* service_runtime = new ServiceRuntime(
+      this, true, uses_nonsfi_mode, init_done_cb, crash_cb);
   main_subprocess_.set_service_runtime(service_runtime);
   PLUGIN_PRINTF(("Plugin::LoadNaClModule (service_runtime=%p)\n",
                  static_cast<void*>(service_runtime)));
   if (NULL == service_runtime) {
     error_info.SetReport(
         PP_NACL_ERROR_SEL_LDR_INIT,
         "sel_ldr init failure " + main_subprocess_.description());
     ReportLoadError(error_info);
     return;
   }
@@ skipping 53 matching lines @@
     return NULL;
   }
 
   // Do not report UMA stats for translator-related nexes.
   // TODO(sehr): define new UMA stats for translator related nexe events.
   // NOTE: The PNaCl translator nexes are not built to use the IRT.  This is
   // done to save on address space and swap space.
   SelLdrStartParams params(helper_url,
                            false /* uses_irt */,
                            false /* uses_ppapi */,
-                           false /* uses_nonsfi_mode */,
                            false /* enable_dyncode_syscalls */,
                            false /* enable_exception_handling */,
                            true /* enable_crash_throttling */);
 
   // Helper NaCl modules always use the PNaCl manifest, as there is no
   // corresponding NMF.
   if (!LoadNaClModuleFromBackgroundThread(file_handle, nacl_subprocess.get(),
                                           params)) {
     return NULL;
   }
@@ skipping 264 matching lines @@
 
 void Plugin::SetExitStatusOnMainThread(int32_t pp_error,
                                        int exit_status) {
   DCHECK(pp::Module::Get()->core()->IsMainThread());
   DCHECK(nacl_interface_);
   nacl_interface_->SetExitStatus(pp_instance(), exit_status);
 }
 
 
 }  // namespace plugin