Kill pnacl translation processes immediately on coordinator error and destruction

ppapi/native_client/src/trusted/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 "native_client/src/trusted/plugin/pnacl_coordinator.h"
 
 #include <utility>
 #include <vector>
 
 #include "native_client/src/include/portability_io.h"
@@ skipping 233 matching lines @@
 PnaclCoordinator::~PnaclCoordinator() {
   PLUGIN_PRINTF(("PnaclCoordinator::~PnaclCoordinator (this=%p, "
                  "translate_thread=%p\n",
                  static_cast<void*>(this), translate_thread_.get()));
   // Stopping the translate thread will cause the translate thread to try to
   // run translation_complete_callback_ on the main thread.  This destructor is
   // running from the main thread, and by the time it exits, callback_factory_
   // will have been destroyed.  This will result in the cancellation of
   // translation_complete_callback_, so no notification will be delivered.
   if (translate_thread_.get() != NULL) {
-    translate_thread_->SetSubprocessesShouldDie();
+    translate_thread_->AbortSubprocesses();
   }
 }
 
 void PnaclCoordinator::ReportNonPpapiError(const nacl::string& message) {
   error_info_.SetReport(ERROR_UNKNOWN,
                         nacl::string("PnaclCoordinator: ") + message);
   ReportPpapiError(PP_ERROR_FAILED);
 }
 
 void PnaclCoordinator::ReportPpapiError(int32_t pp_error,
@@ skipping 172 matching lines @@
   }
 
   // Create the translation thread object immediately. This ensures that any
   // pieces of the file that get downloaded before the compilation thread
   // is accepting SRPCs won't get dropped.
   translate_thread_.reset(new PnaclTranslateThread());
   if (translate_thread_ == NULL) {
     ReportNonPpapiError("could not allocate translation thread.");
     return;
   }
-  // In the streaming case we also want to open the object file now so the
+  // We also want to open the object file now so the
   // translator can start writing to it during streaming translation.
-  // In the non-streaming case this can wait until the bitcode download is
-  // finished.
   obj_file_.reset(new TempFile(plugin_));
   pp::CompletionCallback obj_cb =
     callback_factory_.NewCallback(&PnaclCoordinator::ObjectFileDidOpen);
   obj_file_->Open(obj_cb);
 
   streaming_downloader_.reset(new FileDownloader());
   streaming_downloader_->Initialize(plugin_);
   pp::CompletionCallback cb =
       callback_factory_.NewCallback(
           &PnaclCoordinator::BitcodeStreamDidFinish);
 
   // TODO(dschuff): need to use url_util_->ResolveRelativeToURL?
   if (!streaming_downloader_->OpenStream(pexe_url_, cb, this)) {
     ReportNonPpapiError(nacl::string("failed to open stream ") + pexe_url_);
   }
 }
 
 void PnaclCoordinator::BitcodeStreamDidFinish(int32_t pp_error) {
   PLUGIN_PRINTF(("PnaclCoordinator::BitcodeStreamDidFinish (pp_error=%"
                  NACL_PRId32")\n", pp_error));
   if (pp_error != PP_OK) {
     // Defer reporting the error and obj_file/nexe_file cleanup until after
     // the translation thread returns, because it may be accessing the
     // coordinator's objects or writing to the files.
     translate_finish_error_ = pp_error;
     error_info_.SetReport(ERROR_UNKNOWN,
                           nacl::string("PnaclCoordinator: pexe load failed."));
-    translate_thread_->SetSubprocessesShouldDie();
+    translate_thread_->AbortSubprocesses();
   }
 }
 
 void PnaclCoordinator::BitcodeStreamGotData(int32_t pp_error,
                                             FileStreamData data) {
   PLUGIN_PRINTF(("PnaclCoordinator::BitcodeStreamGotData (pp_error=%"
                  NACL_PRId32", data=%p)\n", pp_error, data ? &(*data)[0] : 0));
   DCHECK(translate_thread_.get());
   translate_thread_->PutBytes(data, pp_error);
 }
@@ skipping 32 matching lines @@
                                   manifest_.get(),
                                   ld_manifest_.get(),
                                   obj_file_.get(),
                                   nexe_file_.get(),
                                   &error_info_,
                                   resources_.get(),
                                   plugin_);
 }
 
 }  // namespace plugin