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

ppapi/native_client/src/trusted/plugin/plugin.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.
 
 #include "ppapi/native_client/src/trusted/plugin/plugin.h"
 
 #include <sys/stat.h>
 #include <sys/types.h>
 
 #include <string>
@@ skipping 95 matching lines @@
   info.handle = file_handle;
   info.token_lo = 0;
   info.token_hi = 0;
 
   // Now actually load the nexe, which can happen on a background thread.
   //
   // We can't use pp::BlockUntilComplete() inside an in-process plugin, so we
   // have to roll our own blocking logic, similar to WaitForSelLdrStart()
   // above, except without timeout logic.
   bool nexe_started = false;
-  pp::CompletionCallback started_cb = callback_factory_.NewCallback(
+  pp::CompletionCallback nexe_started_callback = callback_factory_.NewCallback(
       &Plugin::SignalNexeStarted, &nexe_started, service_runtime);
-  service_runtime->LoadNexeAndStart(info, started_cb);
+  pp::Module::Get()->core()->CallOnMainThread(
+      0,
+      callback_factory_.NewCallback(
+          &Plugin::LoadNexeAndStart,
+          service_runtime, info, nexe_started_callback));
   service_runtime->WaitForNexeStart();
+
   return nexe_started;
 }
 
 void Plugin::StartSelLdrOnMainThread(int32_t pp_error,
                                      ServiceRuntime* service_runtime,
                                      const SelLdrStartParams& params,
                                      pp::CompletionCallback callback) {
   if (pp_error != PP_OK) {
     PLUGIN_PRINTF(("Plugin::StartSelLdrOnMainThread: non-PP_OK arg "
                    "-- SHOULD NOT HAPPEN\n"));
@@ skipping 48 matching lines @@
   PLUGIN_PRINTF(("Plugin::LoadNaClModule (service_runtime=%p)\n",
                  static_cast<void*>(service_runtime)));
   if (NULL == service_runtime) {
     error_info.SetReport(
         PP_NACL_ERROR_SEL_LDR_INIT,
         "sel_ldr init failure " + main_subprocess_.description());
     ReportLoadError(error_info);
     return;
   }
 
+  // We don't take any action once nexe loading has completed, so pass an empty
+  // callback here for |callback|.
   pp::CompletionCallback callback = callback_factory_.NewCallback(
-      &Plugin::LoadNexeAndStart, file_info, service_runtime);
+      &Plugin::LoadNexeAndStart,
+      service_runtime, file_info, pp::CompletionCallback());
   StartSelLdrOnMainThread(
       static_cast<int32_t>(PP_OK), service_runtime, params, callback);
 }
 
 void Plugin::LoadNexeAndStart(int32_t pp_error,
+                              ServiceRuntime* service_runtime,
                               PP_NaClFileInfo file_info,
-                              ServiceRuntime* service_runtime) {
+                              const pp::CompletionCallback& callback) {
+  CHECK(pp::Module::Get()->core()->IsMainThread());
   if (pp_error != PP_OK)
     return;
-
-  // We don't take any action once nexe loading has completed, so pass an empty
-  // callback here for |loaded_cb|.
-  service_runtime->LoadNexeAndStart(file_info, pp::CompletionCallback());
+  service_runtime->LoadNexeAndStart(file_info, callback);
 }
 
 bool Plugin::LoadNaClModuleContinuationIntern() {
   ErrorInfo error_info;
   if (!uses_nonsfi_mode_) {
     if (!main_subprocess_.StartSrpcServices()) {
       // The NaCl process probably crashed. On Linux, a crash causes this
       // error, while on other platforms, the error is detected below, when we
       // attempt to start the proxy. Report a module initialization error here,
       // to make it less confusing for developers.
@@ skipping 310 matching lines @@
 
 void Plugin::SetExitStatusOnMainThread(int32_t pp_error,
                                        int exit_status) {
   DCHECK(pp::Module::Get()->core()->IsMainThread());
   DCHECK(nacl_interface_);
   nacl_interface_->SetExitStatus(pp_instance(), exit_status);
 }
 
 
 }  // namespace plugin