Move PNaCl process startup back to the main thread.

components/nacl/renderer/plugin/pnacl_coordinator.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 "components/nacl/renderer/plugin/pnacl_coordinator.h"
 
 #include <algorithm>
 #include <sstream>
 #include <utility>
 
@@ skipping 79 matching lines @@
 
 PnaclCoordinator::PnaclCoordinator(
     Plugin* plugin,
     const std::string& pexe_url,
     const PP_PNaClOptions& pnacl_options,
     const pp::CompletionCallback& translate_notify_callback)
     : translate_finish_error_(PP_OK),
       plugin_(plugin),
       translate_notify_callback_(translate_notify_callback),
       translation_finished_reported_(false),
+      compiler_subprocess_("compiler.nexe", NULL, NULL),
+      ld_subprocess_("linker.nexe", NULL, NULL),
       pexe_url_(pexe_url),
       pnacl_options_(pnacl_options),
       architecture_attributes_(GetArchitectureAttributes(plugin)),
       split_module_count_(0),
       num_threads_(0),
       error_already_reported_(false),
       pexe_size_(0),
       pexe_bytes_compiled_(0),
       expected_pexe_size_(-1) {
   callback_factory_.Initialize(this);
@@ skipping 211 matching lines @@
       return;
     } else {
       obj_files_.push_back(temp_file.release());
     }
   }
   invalid_desc_wrapper_.reset(plugin_->wrapper_factory()->MakeInvalid());
 
   temp_nexe_file_.reset(new TempFile(plugin_, nexe_handle));
   // Open the nexe file for connecting ld and sel_ldr.
   // Start translation when done with this last step of setup!
-  RunTranslate(temp_nexe_file_->Open(true));
+  int32_t pp_error = temp_nexe_file_->Open(true);
+  if (pp_error != PP_OK) {
+    ReportNonPpapiError(
+        PP_NACL_ERROR_PNACL_CREATE_TEMP,
+        std::string(
+            "PnaclCoordinator: Got bad temp file handle from writing nexe"));
+    return;
+  }
+  LoadCompiler(PP_OK);
 }
 
 void PnaclCoordinator::BitcodeStreamGotData(const void* data, int32_t length) {
   DCHECK(translate_thread_.get());
 
   translate_thread_->PutBytes(data, length);
   if (data && length > 0)
     pexe_size_ += length;
 }
 
@@ skipping 55 matching lines @@
                                       expected_pexe_size_);
   }
 }
 
 pp::CompletionCallback PnaclCoordinator::GetCompileProgressCallback(
     int64_t bytes_compiled) {
   return callback_factory_.NewCallback(&PnaclCoordinator::BitcodeGotCompiled,
                                        bytes_compiled);
 }
 
-void PnaclCoordinator::RunTranslate(int32_t pp_error) {
-  PLUGIN_PRINTF(("PnaclCoordinator::RunTranslate (pp_error=%"
-                 NACL_PRId32 ")\n", pp_error));
+void PnaclCoordinator::LoadCompiler(int32_t pp_error) {

[Derek Schuff, 2015/05/08 22:45:59]

is LoadCompiler ever used as a callback? does it actually need a pp_error now?

[jvoung (off chromium), 2015/05/08 23:59:31]

No -- and I added the check of temp_nexe_file_->Open()'s return value earlier.
Removed the pp_error param.

+  PLUGIN_PRINTF(("PnaclCoordinator::LoadCompiler (pp_error=%" NACL_PRId32 ")\n",
+                 pp_error));
+  // If previous setup failed we would not have invoked LoadCompiler.
+  // So we only expect PP_OK here.
+  DCHECK(pp_error == PP_OK);
+  if (pp_error != PP_OK) {
+    return;
+  }
+  int64_t compiler_load_start_time = NaClGetTimeOfDayMicroseconds();
+  pp::CompletionCallback load_finished = callback_factory_.NewCallback(
+      &PnaclCoordinator::RunCompile, compiler_load_start_time);
+  PnaclResources::ResourceType compiler_type = pnacl_options_.use_subzero
+                                                   ? PnaclResources::SUBZERO
+                                                   : PnaclResources::LLC;
+  // On success, ownership of file_info is transferred.
+  PP_NaClFileInfo file_info = resources_->TakeFileInfo(compiler_type);
+  const std::string& url = resources_->GetUrl(compiler_type);
+  plugin_->LoadHelperNaClModule(url, file_info, &compiler_subprocess_,
+                                load_finished);
+}
+
+void PnaclCoordinator::RunCompile(int32_t pp_error,
+                                  int64_t compiler_load_start_time) {
+  PLUGIN_PRINTF(
+      ("PnaclCoordinator::RunCompile (pp_error=%" NACL_PRId32 ")\n", pp_error));
+  if (pp_error != PP_OK) {
+    ReportNonPpapiError(
+        PP_NACL_ERROR_PNACL_LLC_SETUP,
+        "PnaclCoordinator: Compiler process could not be created.");
+    return;
+  }
+  int64_t compiler_load_time_total =
+      NaClGetTimeOfDayMicroseconds() - compiler_load_start_time;
+  GetNaClInterface()->LogTranslateTime("NaCl.Perf.PNaClLoadTime.LoadCompiler",
+                                       compiler_load_time_total);
+  GetNaClInterface()->LogTranslateTime(
+      pnacl_options_.use_subzero
+          ? "NaCl.Perf.PNaClLoadTime.LoadCompiler.Subzero"
+          : "NaCl.Perf.PNaClLoadTime.LoadCompiler.LLC",
+      compiler_load_time_total);
+
   // Invoke llc followed by ld off the main thread.  This allows use of
   // blocking RPCs that would otherwise block the JavaScript main thread.
   pp::CompletionCallback report_translate_finished =
       callback_factory_.NewCallback(&PnaclCoordinator::TranslateFinished);
+  pp::CompletionCallback compile_finished =
+      callback_factory_.NewCallback(&PnaclCoordinator::LoadLinker);
+  CHECK(translate_thread_ != NULL);
+  translate_thread_->SetupState(
+      report_translate_finished, &compiler_subprocess_, &ld_subprocess_,
+      &obj_files_, num_threads_, temp_nexe_file_.get(),
+      invalid_desc_wrapper_.get(), &error_info_, &pnacl_options_,
+      architecture_attributes_, this);
+  translate_thread_->RunCompile(compile_finished);
+}
 
-  CHECK(translate_thread_ != NULL);
-  translate_thread_->RunTranslate(report_translate_finished, &obj_files_,
-                                  num_threads_, temp_nexe_file_.get(),
-                                  invalid_desc_wrapper_.get(), &error_info_,
-                                  resources_.get(), &pnacl_options_,
-                                  architecture_attributes_, this, plugin_);
+void PnaclCoordinator::LoadLinker(int32_t pp_error) {
+  PLUGIN_PRINTF(
+      ("PnaclCoordinator::LoadLinker (pp_error=%" NACL_PRId32 ")\n", pp_error));
+  // Errors in the previous step would have skipped to TranslateFinished
+  // so we only expect PP_OK here.
+  DCHECK(pp_error == PP_OK);
+  if (pp_error != PP_OK) {
+    return;
+  }
+  ErrorInfo error_info;
+  int64_t ld_load_start_time = NaClGetTimeOfDayMicroseconds();
+  pp::CompletionCallback load_finished = callback_factory_.NewCallback(
+      &PnaclCoordinator::RunLink, ld_load_start_time);
+  PP_NaClFileInfo ld_file_info = resources_->TakeFileInfo(PnaclResources::LD);
+  // On success, ownership of ld_file_info is transferred.
+  plugin_->LoadHelperNaClModule(resources_->GetUrl(PnaclResources::LD),
+                                ld_file_info, &ld_subprocess_, load_finished);
+}
+
+void PnaclCoordinator::RunLink(int32_t pp_error, int64_t ld_load_start_time) {
+  PLUGIN_PRINTF(
+      ("PnaclCoordinator::RunLink (pp_error=%" NACL_PRId32 ")\n", pp_error));
+  if (pp_error != PP_OK) {
+    ReportNonPpapiError(
+        PP_NACL_ERROR_PNACL_LD_SETUP,
+        "PnaclCoordinator: Linker process could not be created.");
+    return;
+  }
+  GetNaClInterface()->LogTranslateTime(
+      "NaCl.Perf.PNaClLoadTime.LoadLinker",
+      NaClGetTimeOfDayMicroseconds() - ld_load_start_time);
+  translate_thread_->RunLink();
 }
 
 }  // namespace plugin