Pepper: Make StartSelLdr asynchronous.

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.
 
 #ifdef _MSC_VER
 // Do not warn about use of std::copy with raw pointers.
 #pragma warning(disable : 4996)
 #endif
 
 #include "ppapi/native_client/src/trusted/plugin/plugin.h"
@@ skipping 284 matching lines @@
   ServiceRuntime* service_runtime =
       new ServiceRuntime(this, manifest, false,
                          pp::BlockUntilComplete(), pp::BlockUntilComplete());
   subprocess->set_service_runtime(service_runtime);
   PLUGIN_PRINTF(("Plugin::LoadNaClModuleFromBackgroundThread "
                  "(service_runtime=%p)\n",
                  static_cast<void*>(service_runtime)));
 
   // Now start the SelLdr instance.  This must be created on the main thread.
   bool service_runtime_started;
+  pp::CompletionCallback sel_ldr_callback =
+      callback_factory_.NewCallback(&Plugin::SignalStartSelLdrDone,
+                                    &service_runtime_started,
+                                    service_runtime);
   pp::CompletionCallback callback =
       callback_factory_.NewCallback(&Plugin::StartSelLdrOnMainThread,
                                     service_runtime, params,
-                                    &service_runtime_started);
+                                    sel_ldr_callback);
   pp::Module::Get()->core()->CallOnMainThread(0, callback, 0);
   service_runtime->WaitForSelLdrStart();
   PLUGIN_PRINTF(("Plugin::LoadNaClModuleFromBackgroundThread "
                  "(service_runtime_started=%d)\n",
                  service_runtime_started));
   if (!service_runtime_started) {
     return false;
   }
 
   // Now actually load the nexe, which can happen on a background thread.
   bool nexe_loaded = service_runtime->LoadNexeAndStart(
       wrapper, pp::BlockUntilComplete());
   PLUGIN_PRINTF(("Plugin::LoadNaClModuleFromBackgroundThread "
                  "(nexe_loaded=%d)\n",
                  nexe_loaded));
   return nexe_loaded;
 }
 
 void Plugin::StartSelLdrOnMainThread(int32_t pp_error,
                                      ServiceRuntime* service_runtime,
                                      const SelLdrStartParams& params,
-                                     bool* success) {
+                                     pp::CompletionCallback callback) {
   if (pp_error != PP_OK) {
     PLUGIN_PRINTF(("Plugin::StartSelLdrOnMainThread: non-PP_OK arg "
                    "-- SHOULD NOT HAPPEN\n"));
-    *success = false;
+    pp::Module::Get()->core()->CallOnMainThread(0, callback, pp_error);
     return;
   }
-  *success = service_runtime->StartSelLdr(params);
-  // Signal outside of StartSelLdr here, so that the write to *success
-  // is done before signaling.
+  service_runtime->StartSelLdr(params, callback);
+}
+
+void Plugin::SignalStartSelLdrDone(int32_t pp_error,
+                                   bool* started,
+                                   ServiceRuntime* service_runtime) {
+  *started = (pp_error == PP_OK);
   service_runtime->SignalStartSelLdrDone();
 }
 
 void Plugin::LoadNaClModule(nacl::DescWrapper* wrapper,
                             bool enable_dyncode_syscalls,
                             bool enable_exception_handling,
                             bool enable_crash_throttling,
                             const pp::CompletionCallback& init_done_cb,
                             const pp::CompletionCallback& crash_cb) {
+  nacl::scoped_ptr<nacl::DescWrapper> scoped_wrapper(wrapper);
   CHECK(pp::Module::Get()->core()->IsMainThread());
   // Before forking a new sel_ldr process, ensure that we do not leak
   // the ServiceRuntime object for an existing subprocess, and that any
   // associated listener threads do not go unjoined because if they
   // outlive the Plugin object, they will not be memory safe.
   ShutDownSubprocesses();
   SelLdrStartParams params(manifest_base_url(),
                            true /* uses_irt */,
                            true /* uses_ppapi */,
                            enable_dev_interfaces_,
                            enable_dyncode_syscalls,
                            enable_exception_handling,
                            enable_crash_throttling);
   ErrorInfo error_info;
   ServiceRuntime* service_runtime =
       new ServiceRuntime(this, manifest_.get(), true, init_done_cb, crash_cb);
   main_subprocess_.set_service_runtime(service_runtime);
   PLUGIN_PRINTF(("Plugin::LoadNaClModule (service_runtime=%p)\n",
                  static_cast<void*>(service_runtime)));
   if (NULL == service_runtime) {
     error_info.SetReport(
         ERROR_SEL_LDR_INIT,
         "sel_ldr init failure " + main_subprocess_.description());
     ReportLoadError(error_info);
     return;
   }
 
-  // Now start the SelLdr instance.  This must be created on the main thread.
-  bool service_runtime_started;
-  StartSelLdrOnMainThread(PP_OK, service_runtime, params,
-                          &service_runtime_started);
-  PLUGIN_PRINTF(("Plugin::LoadNaClModule (service_runtime_started=%d)\n",
-                 service_runtime_started));
-  if (!service_runtime_started) {
+  pp::CompletionCallback callback = callback_factory_.NewCallback(
+      &Plugin::LoadNexeAndStart, scoped_wrapper.release(), service_runtime,
+      crash_cb);
+  StartSelLdrOnMainThread(
+      static_cast<int32_t>(PP_OK), service_runtime, params, callback);
+}
+
+void Plugin::LoadNexeAndStart(int32_t pp_error,
+                              nacl::DescWrapper* wrapper,
+                              ServiceRuntime* service_runtime,
+                              const pp::CompletionCallback& crash_cb) {
+  nacl::scoped_ptr<nacl::DescWrapper> scoped_wrapper(wrapper);
+  if (pp_error != PP_OK)
     return;
-  }
 
   // Now actually load the nexe, which can happen on a background thread.
   bool nexe_loaded = service_runtime->LoadNexeAndStart(wrapper, crash_cb);
   PLUGIN_PRINTF(("Plugin::LoadNaClModule (nexe_loaded=%d)\n",
                  nexe_loaded));
   if (nexe_loaded) {
     PLUGIN_PRINTF(("Plugin::LoadNaClModule (%s)\n",
                    main_subprocess_.detailed_description().c_str()));
   }
 }
@@ skipping 384 matching lines @@
                        nexe_downloader_.url_to_open(),
                        LENGTH_IS_COMPUTABLE,
                        nexe_bytes_read,
                        nexe_bytes_read);
 
   load_start_ = NaClGetTimeOfDayMicroseconds();
   nacl::scoped_ptr<nacl::DescWrapper>
       wrapper(wrapper_factory()->MakeFileDesc(file_desc_ok_to_close, O_RDONLY));
   NaClLog(4, "NexeFileDidOpen: invoking LoadNaClModule\n");
   LoadNaClModule(
-      wrapper.get(),
+      wrapper.release(),
       true, /* enable_dyncode_syscalls */
       true, /* enable_exception_handling */
       false, /* enable_crash_throttling */
       callback_factory_.NewCallback(&Plugin::NexeFileDidOpenContinuation),
       callback_factory_.NewCallback(&Plugin::NexeDidCrash));
 }
 
 void Plugin::NexeFileDidOpenContinuation(int32_t pp_error) {
   ErrorInfo error_info;
   bool was_successful;
@@ skipping 96 matching lines @@
   if (pp_error != PP_OK) {
     // Error should have been reported by pnacl. Just return.
     PLUGIN_PRINTF(("Plugin::BitcodeDidTranslate error in Pnacl\n"));
     return;
   }
 
   // Inform JavaScript that we successfully translated the bitcode to a nexe.
   nacl::scoped_ptr<nacl::DescWrapper>
       wrapper(pnacl_coordinator_.get()->ReleaseTranslatedFD());
   LoadNaClModule(
-      wrapper.get(),
+      wrapper.release(),
       false, /* enable_dyncode_syscalls */
       false, /* enable_exception_handling */
       true, /* enable_crash_throttling */
       callback_factory_.NewCallback(&Plugin::BitcodeDidTranslateContinuation),
       callback_factory_.NewCallback(&Plugin::NexeDidCrash));
 }
 
 void Plugin::BitcodeDidTranslateContinuation(int32_t pp_error) {
   ErrorInfo error_info;
   bool was_successful = LoadNaClModuleContinuationIntern(&error_info);
@@ skipping 598 matching lines @@
   DCHECK(pp::Module::Get()->core()->IsMainThread());
   DCHECK(nacl_interface_);
   exit_status_ = exit_status;
   nacl_interface_->SetReadOnlyProperty(pp_instance(),
                                        pp::Var("exitStatus").pp_var(),
                                        pp::Var(exit_status_).pp_var());
 }
 
 
 }  // namespace plugin