Pepper: Move exit_status to NexeLoadManager.

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 564 matching lines @@
 
 Plugin::Plugin(PP_Instance pp_instance)
     : pp::Instance(pp_instance),
       main_subprocess_("main subprocess", NULL, NULL),
       uses_nonsfi_mode_(false),
       wrapper_factory_(NULL),
       enable_dev_interfaces_(false),
       init_time_(0),
       nexe_size_(0),
       time_of_last_progress_event_(0),
-      exit_status_(-1),
       nacl_interface_(NULL),
       uma_interface_(this) {
   PLUGIN_PRINTF(("Plugin::Plugin (this=%p, pp_instance=%"
                  NACL_PRId32 ")\n", static_cast<void*>(this), pp_instance));
   callback_factory_.Initialize(this);
   nexe_downloader_.Initialize(this);
   nacl_interface_ = GetNaClInterface();
   CHECK(nacl_interface_ != NULL);
 
   // Notify PPB_NaCl_Private that the instance is created before altering any
@@ skipping 208 matching lines @@
 }
 
 void Plugin::NexeDidCrash(int32_t pp_error) {
   PLUGIN_PRINTF(("Plugin::NexeDidCrash (pp_error=%" NACL_PRId32 ")\n",
                  pp_error));
   if (pp_error != PP_OK) {
     PLUGIN_PRINTF(("Plugin::NexeDidCrash: CallOnMainThread callback with"
                    " non-PP_OK arg -- SHOULD NOT HAPPEN\n"));
   }
   PLUGIN_PRINTF(("Plugin::NexeDidCrash: crash event!\n"));
-  if (-1 != exit_status()) {
+  int exit_status = nacl_interface_->GetExitStatus(pp_instance());
+  if (exit_status != -1) {

[dmichael (off chromium), 2014/04/02 19:01:41]

Pardon the stupid question, but is -1 a viable exit status from a program? It
seems like we're using -1 as an indicator that it's never been set, and I just
want to make sure that actually makes sense.

If -1 is a code we might actually get from a program, we might want to fix it
later so we track whether the exit status has been set separately. (E.g., it
would be easy to fix after all the exit status usage is moved to the renderer).

     // The NaCl module voluntarily exited.  However, this is still a
     // crash from the point of view of Pepper, since PPAPI plugins are
     // event handlers and should never exit.
     PLUGIN_PRINTF((("Plugin::NexeDidCrash: nexe exited with status %d"
                     " so this is a \"controlled crash\".\n"),
-                   exit_status()));
+                   exit_status));
   }
   // If the crash occurs during load, we just want to report an error
   // that fits into our load progress event grammar.  If the crash
   // occurs after loaded/loadend, then we use ReportDeadNexe to send a
   // "crash" event.
   if (nacl_interface_->GetNexeErrorReported(pp_instance())) {
     PLUGIN_PRINTF(("Plugin::NexeDidCrash: error already reported;"
                    " suppressing\n"));
   } else {
     if (nacl_interface_->GetNaClReadyState(pp_instance()) ==
@@ skipping 534 matching lines @@
         callback_factory_.NewCallback(&Plugin::SetExitStatusOnMainThread,
                                       exit_status);
     core->CallOnMainThread(0, callback, 0);
   }
 }
 
 void Plugin::SetExitStatusOnMainThread(int32_t pp_error,
                                        int exit_status) {
   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());
+  nacl_interface_->SetExitStatus(pp_instance(), exit_status);
 }
 
 
 }  // namespace plugin