Prototype: Use Chromium IPC for plugin LOAD_MODULE.

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 479 matching lines @@
   NaClXCondVarCtor(&cond_);
 }
 
 bool ServiceRuntime::LoadModule(nacl::DescWrapper* nacl_desc,
                                 ErrorInfo* error_info) {
   NaClLog(4, "ServiceRuntime::LoadModule"
           " (this=%p, subprocess=%p)\n",
           static_cast<void*>(this),
           static_cast<void*>(subprocess_.get()));
   CHECK(nacl_desc);
+
   // Create the command channel to the sel_ldr and load the nexe from nacl_desc.
   if (!subprocess_->SetupCommand(&command_channel_)) {
     error_info->SetReport(ERROR_SEL_LDR_COMMUNICATION_CMD_CHANNEL,
                           "ServiceRuntime: command channel creation failed");
     return false;
   }
+  struct NaClDesc *desc = nacl_desc->desc();
+  if (NACL_VTBL(NaClDesc, desc)->typeTag != NACL_DESC_HOST_IO)
+     return false;
+  PP_FileHandle h = ((struct NaClDescIoDesc *) desc)->hd->d;
+  uint32_t nacl_error_code;
+  PP_Bool ok = plugin_->nacl_interface()->LoadModule(
+      plugin_->pp_instance(), h, &nacl_error_code);
+  if (ok == PP_FALSE)
+    return false;
 
-  if (!subprocess_->LoadModule(&command_channel_, nacl_desc)) {
-    error_info->SetReport(ERROR_SEL_LDR_COMMUNICATION_CMD_CHANNEL,
-                          "ServiceRuntime: load module failed");
+  if (main_service_runtime_)
+    plugin_->ReportSelLdrLoadStatus(nacl_error_code);
+
+  if (LOAD_OK != nacl_error_code) {
+    error_info->SetReport(
+        ERROR_SEL_LDR_START_STATUS,
+        NaClErrorString(static_cast<NaClErrorCode>(nacl_error_code)));
     return false;
   }
+
+  fprintf(stderr, "LoadModule finished\n");
   return true;
 }
 
 bool ServiceRuntime::InitReverseService(ErrorInfo* error_info) {
   // 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",
@@ skipping 23 matching lines @@
                           "ServiceRuntime: starting reverse services failed");
     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 (NACL_SRPC_RESULT_OK != rpc_result) {
-    error_info->SetReport(ERROR_SEL_LDR_START_MODULE,
-                          "ServiceRuntime: could not start nacl module");
-    return false;
-  }
-  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(
-        ERROR_SEL_LDR_START_STATUS,
-        NaClErrorString(static_cast<NaClErrorCode>(load_status)));
-    return false;
-  }
-  return true;
+  PP_Bool ok = plugin_->nacl_interface()->StartModule(plugin_->pp_instance());
+  return PP_ToBool(ok);
 }
 
-bool ServiceRuntime::StartSelLdr(const SelLdrStartParams& params) {
+void ServiceRuntime::StartSelLdr(const SelLdrStartParams& params,
+                                 PP_CompletionCallback callback) {
   NaClLog(4, "ServiceRuntime::Start\n");
 
   nacl::scoped_ptr<SelLdrLauncherChrome>
       tmp_subprocess(new SelLdrLauncherChrome());
   if (NULL == tmp_subprocess.get()) {
     NaClLog(LOG_ERROR, "ServiceRuntime::Start (subprocess create failed)\n");
     if (main_service_runtime_) {
       ErrorInfo error_info;
       error_info.SetReport(
           ERROR_SEL_LDR_CREATE_LAUNCHER,
           "ServiceRuntime: failed to create sel_ldr launcher");
       plugin_->ReportLoadError(error_info);
     }
-    return false;
+    PP_RunCompletionCallback(&callback, PP_ERROR_FAILED);
+    return;
   }
-  nacl::string error_message;
-  bool started = 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,
-                                       &error_message);
-  if (!started) {
-    NaClLog(LOG_ERROR, "ServiceRuntime::Start (start failed)\n");
-    if (main_service_runtime_) {
-      ErrorInfo error_info;
-      error_info.SetReportWithConsoleOnlyError(
-          ERROR_SEL_LDR_LAUNCH,
-          "ServiceRuntime: failed to start",
-          error_message);
-      plugin_->ReportLoadError(error_info);
-    }
-    return false;
-  }
-
+  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,
+                        &start_sel_ldr_error_message_,  // FIXME: Use.
+                        callback);
   subprocess_.reset(tmp_subprocess.release());
-  NaClLog(4, "ServiceRuntime::StartSelLdr (return 1)\n");
-  return true;
 }
 
 void ServiceRuntime::WaitForSelLdrStart() {
   nacl::MutexLocker take(&mu_);
   while(!start_sel_ldr_done_) {
     NaClXCondVarWait(&cond_, &mu_);
   }
 }
 
 void ServiceRuntime::SignalStartSelLdrDone() {
   nacl::MutexLocker take(&mu_);
   start_sel_ldr_done_ = true;
   NaClXCondVarSignal(&cond_);
 }
 
 bool ServiceRuntime::LoadNexeAndStart(nacl::DescWrapper* nacl_desc,
                                       const pp::CompletionCallback& crash_cb) {
   NaClLog(4, "ServiceRuntime::LoadNexeAndStart (nacl_desc=%p)\n",
           reinterpret_cast<void*>(nacl_desc));
   ErrorInfo error_info;
   bool ok = LoadModule(nacl_desc, &error_info) &&
-            InitReverseService(&error_info) &&
+            InitReverseService(&error_info);
             StartModule(&error_info);
   if (!ok) {
     if (main_service_runtime_) {
       plugin_->ReportLoadError(error_info);
     }
     // On a load failure the service runtime does not crash itself to
     // avoid a race where the no-more-senders error on the reverse
     // channel esrvice thread might cause the crash-detection logic to
     // kick in before the start_module RPC reply has been received. So
     // we induce a service runtime crash here. We do not release
@@ skipping 93 matching lines @@
 
 nacl::string ServiceRuntime::GetCrashLogOutput() {
   if (NULL != subprocess_.get()) {
     return subprocess_->GetCrashLogOutput();
   } else {
     return std::string();
   }
 }
 
 }  // namespace plugin