NaCl: clean up nexe loading logic in trusted plugin.

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 93 matching lines @@
   PP_NaClFileInfo info;
   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 nexe_started_callback = callback_factory_.NewCallback(
-      &Plugin::SignalNexeStarted, &nexe_started, service_runtime);
   pp::Module::Get()->core()->CallOnMainThread(
       0,
       callback_factory_.NewCallback(
           &Plugin::LoadNexeAndStart,
-          service_runtime, info, nexe_started_callback));
-  service_runtime->WaitForNexeStart();
-
-  return nexe_started;
+          service_runtime,
+          info

[hidehiko, 2014/06/18 05:07:04]

nit: )); should be in this line.
There is no specific statement in the style guide,
but most code in chromium and style guide follows it, so it'd be better to
follow it.

cf) http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml

[Nick Bray (chromium), 2014/06/18 18:29:44]

Done.

+      )
+  );
+  return service_runtime->WaitForNexeStart();
 }
 
 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"));
     pp::Module::Get()->core()->CallOnMainThread(0, callback, pp_error);
     return;
   }
   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::SignalNexeStarted(int32_t pp_error,
-                               bool* started,
-                               ServiceRuntime* service_runtime) {
-  *started = (pp_error == PP_OK);
-  service_runtime->SignalNexeStarted();
-}
-
 void Plugin::LoadNaClModule(PP_NaClFileInfo file_info,
                             bool uses_nonsfi_mode,
                             bool enable_dyncode_syscalls,
                             bool enable_exception_handling,
                             bool enable_crash_throttling,
                             const pp::CompletionCallback& init_done_cb,
                             const pp::CompletionCallback& crash_cb) {
   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
@@ skipping 21 matching lines @@
     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,
-      service_runtime, file_info, pp::CompletionCallback());
+      &Plugin::LoadNexeAndStart, service_runtime, file_info);
   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,
-                              const pp::CompletionCallback& callback) {
+                              PP_NaClFileInfo file_info) {
   CHECK(pp::Module::Get()->core()->IsMainThread());
   if (pp_error != PP_OK)
     return;
-  service_runtime->LoadNexeAndStart(file_info, callback);
+  service_runtime->LoadNexeAndStart(file_info);
 }
 
 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