Add limitation that LoadNexeAndStart must be called on the main thread.

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 400 matching lines @@
   // return success.
   return true;
 }
 
 void PluginReverseInterface::ReportCrash() {
   NaClLog(4, "PluginReverseInterface::ReportCrash\n");
 
   if (crash_cb_.pp_completion_callback().func != NULL) {
     NaClLog(4, "PluginReverseInterface::ReportCrash: invoking CB\n");
     pp::Module::Get()->core()->CallOnMainThread(0, crash_cb_, PP_OK);
+    // Clear the callback to avoid it gets invoked twice.
+    crash_cb_ = pp::CompletionCallback();
   } else {
     NaClLog(1,
             "PluginReverseInterface::ReportCrash:"
             " crash_cb_ not valid, skipping\n");
   }
 }
 
 void PluginReverseInterface::ReportExitStatus(int exit_status) {
   service_runtime_->set_exit_status(exit_status);
 }
@@ skipping 245 matching lines @@
   nexe_started_ = false;
 }
 
 void ServiceRuntime::SignalNexeStarted() {
   nacl::MutexLocker take(&mu_);
   nexe_started_ = true;
   NaClXCondVarSignal(&cond_);
 }
 
 void ServiceRuntime::LoadNexeAndStart(PP_NaClFileInfo file_info,
-                                      const pp::CompletionCallback& started_cb,
-                                      const pp::CompletionCallback& crash_cb) {
+                                      const pp::CompletionCallback& callback) {
   NaClLog(4, "ServiceRuntime::LoadNexeAndStart (handle_valid=%d "
              "token_lo=%" NACL_PRIu64 " token_hi=%" NACL_PRIu64 ")\n",
       file_info.handle != PP_kInvalidFileHandle,
       file_info.token_lo,
       file_info.token_hi);
 
   bool ok = SetupCommandChannel() &&
             InitReverseService() &&
             LoadModule(file_info) &&
             StartModule();
-  if (!ok) {
+  if (ok) {
+    NaClLog(4, "ServiceRuntime::LoadNexeAndStart (return 1)\n");
+  } else {
     // 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
     // subprocess_ since it's needed to collect crash log output after
     // the error is reported.
     Log(LOG_FATAL, "reap logs");
     if (NULL == reverse_service_) {
       // No crash detector thread.
       NaClLog(LOG_ERROR, "scheduling to get crash log\n");
-      pp::Module::Get()->core()->CallOnMainThread(0, crash_cb, PP_OK);
+      // Invoking rev_interface's method is workaround to avoid crash_cb
+      // gets called twice or more. We should clean this up later.
+      rev_interface_->ReportCrash();
       NaClLog(LOG_ERROR, "should fire soon\n");
     } else {
       NaClLog(LOG_ERROR, "Reverse service thread will pick up crash log\n");
     }
-    pp::Module::Get()->core()->CallOnMainThread(0, started_cb, PP_ERROR_FAILED);
-    return;
   }
-
-  NaClLog(4, "ServiceRuntime::LoadNexeAndStart (return 1)\n");
-  pp::Module::Get()->core()->CallOnMainThread(0, started_cb, PP_OK);
+  pp::Module::Get()->core()->CallOnMainThread(
+      0, callback, ok ? PP_OK : PP_ERROR_FAILED);
 }
 
 SrpcClient* ServiceRuntime::SetupAppChannel() {
   NaClLog(4, "ServiceRuntime::SetupAppChannel (subprocess_=%p)\n",
           reinterpret_cast<void*>(subprocess_.get()));
   nacl::DescWrapper* connect_desc = subprocess_->socket_addr()->Connect();
   if (NULL == connect_desc) {
     NaClLog(LOG_ERROR, "ServiceRuntime::SetupAppChannel (connect failed)\n");
     return NULL;
   } else {
@@ skipping 66 matching lines @@
 
 nacl::string ServiceRuntime::GetCrashLogOutput() {
   if (NULL != subprocess_.get()) {
     return subprocess_->GetCrashLogOutput();
   } else {
     return std::string();
   }
 }
 
 }  // namespace plugin