Support non-SFI mode in NaCl manifest file.

ppapi/native_client/src/trusted/plugin/service_runtime.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.
  */
 
 #define NACL_LOG_MODULE_NAME "Plugin::ServiceRuntime"
 
 #include "ppapi/native_client/src/trusted/plugin/service_runtime.h"
 
@@ skipping 433 matching lines @@
   NaClLog(4, "PluginReverseInterface::AddTempQuotaManagedFile: "
           "(file_id='%s')\n", file_id.c_str());
   uint64_t file_key = STRTOULL(file_id.c_str(), NULL, 10);
   nacl::MutexLocker take(&mu_);
   quota_files_.insert(file_key);
 }
 
 ServiceRuntime::ServiceRuntime(Plugin* plugin,
                                const Manifest* manifest,
                                bool main_service_runtime,
+                               bool nonsfi_enabled,
                                pp::CompletionCallback init_done_cb,
                                pp::CompletionCallback crash_cb)
     : plugin_(plugin),
       main_service_runtime_(main_service_runtime),
+      nonsfi_enabled_(nonsfi_enabled),
       reverse_service_(NULL),
       anchor_(new nacl::WeakRefAnchor()),
       rev_interface_(new PluginReverseInterface(anchor_, plugin,
                                                 manifest,
                                                 this,
                                                 init_done_cb, crash_cb)),
       exit_status_(-1),
       start_sel_ldr_done_(false),
       callback_factory_(this) {
   NaClSrpcChannelInitialize(&command_channel_);
@@ skipping 17 matching lines @@
 
   if (!subprocess_->LoadModule(&command_channel_, nacl_desc)) {
     error_info->SetReport(PP_NACL_ERROR_SEL_LDR_COMMUNICATION_CMD_CHANNEL,
                           "ServiceRuntime: load module failed");
     return false;
   }
   return true;
 }
 
 bool ServiceRuntime::InitReverseService(ErrorInfo* error_info) {
+  if (nonsfi_enabled_) {
+    // In non-SFI mode, open_resource() has not yet been supported, so we

[Mark Seaborn, 2014/02/27 17:10:22]

"is not yet supported"

[hidehiko, 2014/02/28 06:41:54]

Done.

+    // do not need the reverse service. So, skip the initialization (with
+    // calling the completion callback).
+    // Note that there is on going work to replace SRPC by Chrome IPC (not only

[Mark Seaborn, 2014/02/27 17:10:22]

You might link to the issue here...

[hidehiko, 2014/02/28 06:41:54]

Done.

+    // for non-SFI mode, but also for SFI mode), and non-SFI mode will use
+    // Chrome IPC for open_resource() after the refacrogin is done.

[Mark Seaborn, 2014/02/27 17:10:22]

"refactoring"

[hidehiko, 2014/02/28 06:41:54]

Oops. Done.

+    rev_interface_->StartupInitializationComplete();
+    return true;
+  }
+
   // Hook up the reverse service channel.  We are the IMC client, but
   // provide SRPC service.
   NaClDesc* out_conn_cap;
   NaClSrpcResultCodes rpc_result =
       NaClSrpcInvokeBySignature(&command_channel_,
                                 "reverse_setup::h",
                                 &out_conn_cap);
 
   if (NACL_SRPC_RESULT_OK != rpc_result) {
     error_info->SetReport(PP_NACL_ERROR_SEL_LDR_COMMUNICATION_REV_SETUP,
@@ skipping 20 matching lines @@
     return false;
   }
   return true;
 }
 
 bool ServiceRuntime::StartModule(ErrorInfo* error_info) {
   // start the module.  otherwise we cannot connect for multimedia
   // subsystem since that is handled by user-level code (not secure!)
   // in libsrpc.
   int load_status = -1;
-  NaClSrpcResultCodes rpc_result =
-      NaClSrpcInvokeBySignature(&command_channel_,
-                                "start_module::i",
-                                &load_status);
+  if (nonsfi_enabled_) {
+    // In non-SFI mode, we don't need to call start_module SRPC to launch
+    // the plugin.
+    load_status = LOAD_OK;
+  } else {
+    NaClSrpcResultCodes rpc_result =
+        NaClSrpcInvokeBySignature(&command_channel_,
+                                  "start_module::i",
+                                  &load_status);
 
-  if (NACL_SRPC_RESULT_OK != rpc_result) {
-    error_info->SetReport(PP_NACL_ERROR_SEL_LDR_START_MODULE,
-                          "ServiceRuntime: could not start nacl module");
-    return false;
+    if (NACL_SRPC_RESULT_OK != rpc_result) {
+      error_info->SetReport(PP_NACL_ERROR_SEL_LDR_START_MODULE,
+                            "ServiceRuntime: could not start nacl module");
+      return false;
+    }
   }
-  NaClLog(4, "ServiceRuntime::StartModule (load_status=%d)\n",
-          load_status);
+
+  NaClLog(4, "ServiceRuntime::StartModule (load_status=%d)\n", load_status);
   if (main_service_runtime_) {
     plugin_->ReportSelLdrLoadStatus(load_status);
   }
   if (LOAD_OK != load_status) {
     error_info->SetReport(
         PP_NACL_ERROR_SEL_LDR_START_STATUS,
         NaClErrorString(static_cast<NaClErrorCode>(load_status)));
     return false;
   }
   return true;
@@ skipping 22 matching lines @@
                                     callback);
 
   tmp_subprocess->Start(plugin_->pp_instance(),
                         params.url.c_str(),
                         params.uses_irt,
                         params.uses_ppapi,
                         params.enable_dev_interfaces,
                         params.enable_dyncode_syscalls,
                         params.enable_exception_handling,
                         params.enable_crash_throttling,
+                        params.enable_nonsfi,
                         &start_sel_ldr_error_message_,
                         internal_callback);
   subprocess_.reset(tmp_subprocess.release());
 }
 
 void ServiceRuntime::StartSelLdrContinuation(int32_t pp_error,
                                              pp::CompletionCallback callback) {
   if (pp_error != PP_OK) {
     NaClLog(LOG_ERROR, "ServiceRuntime::StartSelLdrContinuation "
                        " (start failed)\n");
@@ skipping 140 matching lines @@
 
 nacl::string ServiceRuntime::GetCrashLogOutput() {
   if (NULL != subprocess_.get()) {
     return subprocess_->GetCrashLogOutput();
   } else {
     return std::string();
   }
 }
 
 }  // namespace plugin