Pepper: Make StartSelLdr asynchronous.

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 466 matching lines @@
                                pp::CompletionCallback crash_cb)
     : plugin_(plugin),
       main_service_runtime_(main_service_runtime),
       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) {
+      start_sel_ldr_done_(false),
+      callback_factory_(this) {
   NaClSrpcChannelInitialize(&command_channel_);
   NaClXMutexCtor(&mu_);
   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),
@@ skipping 72 matching lines @@
   }
   if (LOAD_OK != load_status) {
     error_info->SetReport(
         ERROR_SEL_LDR_START_STATUS,
         NaClErrorString(static_cast<NaClErrorCode>(load_status)));
     return false;
   }
   return true;
 }
 
-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::Module::Get()->core()->CallOnMainThread(0, 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");
+  pp::CompletionCallback internal_callback =
+      callback_factory_.NewCallback(&ServiceRuntime::StartSelLdrContinuation,
+                                    callback.pp_completion_callback());

[dmichael (off chromium), 2014/02/10 23:31:16]

Did you try just passing the pp::CompletionCallback? I was thinking it was safe
to copy it, as long as it is only ever invoked once.

+
+  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_,
+                        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");
     if (main_service_runtime_) {
+      std::string error_message;
+      pp::Var var_error_message_cpp(pp::PASS_REF, start_sel_ldr_error_message_);
+      if (var_error_message_cpp.is_string()) {
+        error_message = var_error_message_cpp.AsString();
+      }
       ErrorInfo error_info;
       error_info.SetReportWithConsoleOnlyError(
           ERROR_SEL_LDR_LAUNCH,
           "ServiceRuntime: failed to start",
           error_message);
       plugin_->ReportLoadError(error_info);
     }
-    return false;
   }
-
-  subprocess_.reset(tmp_subprocess.release());
-  NaClLog(4, "ServiceRuntime::StartSelLdr (return 1)\n");
-  return true;
+  PP_RunCompletionCallback(&callback, pp_error);
 }
 
 void ServiceRuntime::WaitForSelLdrStart() {
   nacl::MutexLocker take(&mu_);
   while(!start_sel_ldr_done_) {
     NaClXCondVarWait(&cond_, &mu_);
   }
 }
 
 void ServiceRuntime::SignalStartSelLdrDone() {
@@ skipping 115 matching lines @@
 
 nacl::string ServiceRuntime::GetCrashLogOutput() {
   if (NULL != subprocess_.get()) {
     return subprocess_->GetCrashLogOutput();
   } else {
     return std::string();
   }
 }
 
 }  // namespace plugin