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 uses_nonsfi_mode,
                                pp::CompletionCallback init_done_cb,
                                pp::CompletionCallback crash_cb)
     : plugin_(plugin),
       main_service_runtime_(main_service_runtime),
+      uses_nonsfi_mode_(uses_nonsfi_mode),
       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 (uses_nonsfi_mode_) {
+    // In non-SFI mode, open_resource() is not yet supported, so we 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
+    // for non-SFI mode, but also for SFI mode) (crbug.com/333950),
+    // and non-SFI mode will use Chrome IPC for open_resource() after the
+    // refactoring is 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 (uses_nonsfi_mode_) {
+    // 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 18 matching lines @@
     return;
   }
   pp::CompletionCallback internal_callback =
       callback_factory_.NewCallback(&ServiceRuntime::StartSelLdrContinuation,
                                     callback);
 
   tmp_subprocess->Start(plugin_->pp_instance(),
                         params.url.c_str(),
                         params.uses_irt,
                         params.uses_ppapi,
+                        params.uses_nonsfi_mode,
                         params.enable_dev_interfaces,
                         params.enable_dyncode_syscalls,
                         params.enable_exception_handling,
                         params.enable_crash_throttling,
                         &start_sel_ldr_error_message_,
                         internal_callback);
   subprocess_.reset(tmp_subprocess.release());
 }
 
 void ServiceRuntime::StartSelLdrContinuation(int32_t pp_error,
@@ skipping 144 matching lines @@
 
 nacl::string ServiceRuntime::GetCrashLogOutput() {
   if (NULL != subprocess_.get()) {
     return subprocess_->GetCrashLogOutput();
   } else {
     return std::string();
   }
 }
 
 }  // namespace plugin