NaCl: Detect plugin crashes via EOF on Chromium IPC.

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 54 matching lines @@
 }
 
 bool Plugin::LoadHelperNaClModuleInternal(NaClSubprocess* subprocess,
                                           const SelLdrStartParams& params) {
   CHECK(!pp::Module::Get()->core()->IsMainThread());
   ServiceRuntime* service_runtime =
       new ServiceRuntime(this,
                          pp_instance(),
                          false,  // No main_service_runtime.
                          false,  // No non-SFI mode (i.e. in SFI-mode).
-                         pp::BlockUntilComplete(),
                          pp::BlockUntilComplete());
   subprocess->set_service_runtime(service_runtime);
 
   // Now start the SelLdr instance.  This must be created on the main thread.
   bool service_runtime_started = false;
   pp::CompletionCallback sel_ldr_callback =
       callback_factory_.NewCallback(&Plugin::SignalStartSelLdrDone,
                                     &service_runtime_started,
                                     service_runtime);
   pp::CompletionCallback callback =
@@ skipping 35 matching lines @@
                                    ServiceRuntime* service_runtime) {
   *started = (pp_error == PP_OK);
   service_runtime->SignalStartSelLdrDone();
 }
 
 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) {
+                            const pp::CompletionCallback& init_done_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
   // associated listener threads do not go unjoined because if they
   // outlive the Plugin object, they will not be memory safe.
   ShutDownSubprocesses();
   pp::Var manifest_base_url =
       pp::Var(pp::PASS_REF, nacl_interface_->GetManifestBaseURL(pp_instance()));
   std::string manifest_base_url_str = manifest_base_url.AsString();
 
   SelLdrStartParams params(manifest_base_url_str,
                            file_info,
                            true /* uses_irt */,
                            true /* uses_ppapi */,
                            enable_dyncode_syscalls,
                            enable_exception_handling,
                            enable_crash_throttling);
   ErrorInfo error_info;
   ServiceRuntime* service_runtime = new ServiceRuntime(
-      this, pp_instance(), true, uses_nonsfi_mode, init_done_cb, crash_cb);
+      this, pp_instance(), true, uses_nonsfi_mode, init_done_cb);
   main_subprocess_.set_service_runtime(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
@@ skipping 166 matching lines @@
 
 void Plugin::NexeFileDidOpen(int32_t pp_error) {
   if (pp_error != PP_OK)
     return;
   LoadNaClModule(
       nexe_file_info_,
       uses_nonsfi_mode_,
       true, /* enable_dyncode_syscalls */
       true, /* enable_exception_handling */
       false, /* enable_crash_throttling */
-      callback_factory_.NewCallback(&Plugin::NexeFileDidOpenContinuation),
-      callback_factory_.NewCallback(&Plugin::NexeDidCrash));
+      callback_factory_.NewCallback(&Plugin::NexeFileDidOpenContinuation));
 }
 
 void Plugin::NexeFileDidOpenContinuation(int32_t pp_error) {
   UNREFERENCED_PARAMETER(pp_error);
   NaClLog(4, "Entered NexeFileDidOpenContinuation\n");
   if (LoadNaClModuleContinuationIntern()) {
     NaClLog(4, "NexeFileDidOpenContinuation: success;"
             " setting histograms\n");
     int64_t nexe_size = nacl_interface_->GetNexeSize(pp_instance());
     nacl_interface_->ReportLoadSuccess(
         pp_instance(), nexe_size, nexe_size);
   } else {
     NaClLog(4, "NexeFileDidOpenContinuation: failed.");
   }
   NaClLog(4, "Leaving NexeFileDidOpenContinuation\n");
 }
 
-void Plugin::NexeDidCrash(int32_t pp_error) {
-  PLUGIN_PRINTF(("Plugin::NexeDidCrash (pp_error=%" NACL_PRId32 ")\n",
-                 pp_error));
-  nacl_interface_->NexeDidCrash(pp_instance());
-}
-
 void Plugin::BitcodeDidTranslate(int32_t pp_error) {
   PLUGIN_PRINTF(("Plugin::BitcodeDidTranslate (pp_error=%" NACL_PRId32 ")\n",
                  pp_error));
   if (pp_error != PP_OK) {
     // Error should have been reported by pnacl. Just return.
     return;
   }
 
   // Inform JavaScript that we successfully translated the bitcode to a nexe.
   PP_FileHandle handle = pnacl_coordinator_->TakeTranslatedFileHandle();
 
   PP_NaClFileInfo info;
   info.handle = handle;
   info.token_lo = 0;
   info.token_hi = 0;
   LoadNaClModule(
       info,
       false, /* uses_nonsfi_mode */
       false, /* enable_dyncode_syscalls */
       false, /* enable_exception_handling */
       true, /* enable_crash_throttling */
-      callback_factory_.NewCallback(&Plugin::BitcodeDidTranslateContinuation),
-      callback_factory_.NewCallback(&Plugin::NexeDidCrash));
+      callback_factory_.NewCallback(&Plugin::BitcodeDidTranslateContinuation));
 }
 
 void Plugin::BitcodeDidTranslateContinuation(int32_t pp_error) {
   NaClLog(4, "Entered BitcodeDidTranslateContinuation\n");
   UNREFERENCED_PARAMETER(pp_error);
   if (LoadNaClModuleContinuationIntern()) {
     int64_t loaded;
     int64_t total;
     // TODO(teravest): Tighten this up so we can get rid of
     // GetCurrentProgress(). loaded should always equal total.
@@ skipping 46 matching lines @@
                                    error_info.message().c_str());
 }
 
 bool Plugin::DocumentCanRequest(const std::string& url) {
   CHECK(pp::Module::Get()->core()->IsMainThread());
   CHECK(pp::URLUtil_Dev::Get() != NULL);
   return pp::URLUtil_Dev::Get()->DocumentCanRequest(this, pp::Var(url));
 }
 
 }  // namespace plugin