Pepper: Manifest ID cleanup.

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 75 matching lines @@
   // Gather data to see if being installed changes load outcomes.
   const char* name = nacl_interface_->GetIsInstalled(pp_instance()) ?
       "NaCl.LoadStatus.SelLdr.InstalledApp" :
       "NaCl.LoadStatus.SelLdr.NotInstalledApp";
   uma_interface_.HistogramEnumeration(name, error_code, NACL_ERROR_CODE_MAX);
 }
 
 bool Plugin::LoadNaClModuleFromBackgroundThread(
     PP_FileHandle file_handle,
     NaClSubprocess* subprocess,
-    int32_t manifest_id,
     const SelLdrStartParams& params) {
   CHECK(!pp::Module::Get()->core()->IsMainThread());
   ServiceRuntime* service_runtime =
-      new ServiceRuntime(this, manifest_id, false, uses_nonsfi_mode_,
+      new ServiceRuntime(this, false, uses_nonsfi_mode_,
                          pp::BlockUntilComplete(), pp::BlockUntilComplete());
   subprocess->set_service_runtime(service_runtime);
   PLUGIN_PRINTF(("Plugin::LoadNaClModuleFromBackgroundThread "
                  "(service_runtime=%p)\n",
                  static_cast<void*>(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,
@@ skipping 70 matching lines @@
   SelLdrStartParams params(manifest_base_url_str,
                            true /* uses_irt */,
                            true /* uses_ppapi */,
                            uses_nonsfi_mode,
                            enable_dev_interfaces,
                            enable_dyncode_syscalls,
                            enable_exception_handling,
                            enable_crash_throttling);
   ErrorInfo error_info;
   ServiceRuntime* service_runtime =
-      new ServiceRuntime(this, manifest_id_, true, uses_nonsfi_mode,
+      new ServiceRuntime(this, true, uses_nonsfi_mode,
                          init_done_cb, crash_cb);
   main_subprocess_.set_service_runtime(service_runtime);
   PLUGIN_PRINTF(("Plugin::LoadNaClModule (service_runtime=%p)\n",
                  static_cast<void*>(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;
@@ skipping 71 matching lines @@
                            false /* uses_irt */,
                            false /* uses_ppapi */,
                            false /* uses_nonsfi_mode */,
                            enable_dev_interfaces,
                            false /* enable_dyncode_syscalls */,
                            false /* enable_exception_handling */,
                            true /* enable_crash_throttling */);
 
   // Helper NaCl modules always use the PNaCl manifest, as there is no
   // corresponding NMF.
-  int32_t manifest_id = nacl_interface_->CreatePnaclManifest(pp_instance());
   if (!LoadNaClModuleFromBackgroundThread(file_handle, nacl_subprocess.get(),
-                                          manifest_id, params)) {
+                                          params)) {
     return NULL;
   }
   // We need not wait for the init_done callback.  We can block
   // here in StartSrpcServices, since helper NaCl modules
   // are spawned from a private thread.
   //
   // TODO(bsy): if helper module crashes, we should abort.
   // crash_cb is not used here, so we are relying on crashes
   // being detected in StartSrpcServices or later.
   //
@@ skipping 28 matching lines @@
     RequestNaClManifest(manifest_url.AsString());
   return true;
 }
 
 Plugin::Plugin(PP_Instance pp_instance)
     : pp::Instance(pp_instance),
       main_subprocess_("main subprocess", NULL, NULL),
       uses_nonsfi_mode_(false),
       wrapper_factory_(NULL),
       time_of_last_progress_event_(0),
-      manifest_id_(-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);
   nacl_interface_ = GetNaClInterface();
   CHECK(nacl_interface_ != NULL);
 
   // Notify PPB_NaCl_Private that the instance is created before altering any
   // state that it tracks.
   nacl_interface_->InstanceCreated(pp_instance);
   // We call set_exit_status() here to ensure that the 'exitStatus' property is
   // set. This can only be called when nacl_interface_ is not NULL.
   set_exit_status(-1);
   nexe_file_info_.handle = PP_kInvalidFileHandle;
   nexe_file_info_.token_lo = 0;
   nexe_file_info_.token_hi = 0;
 }
 
 
 Plugin::~Plugin() {
   int64_t shutdown_start = NaClGetTimeOfDayMicroseconds();
 
   PLUGIN_PRINTF(("Plugin::~Plugin (this=%p)\n",
                  static_cast<void*>(this)));
   // Destroy the coordinator while the rest of the data is still there
   pnacl_coordinator_.reset(NULL);
 
-  // Clean up accounting for our instance inside the NaCl interface.
-  if (manifest_id_ != -1)
-    nacl_interface_->DestroyManifest(pp_instance(), manifest_id_);
   nacl_interface_->InstanceDestroyed(pp_instance());
 
   // ShutDownSubprocesses shuts down the main subprocess, which shuts
   // down the main ServiceRuntime object, which kills the subprocess.
   // As a side effect of the subprocess being killed, the reverse
   // services thread(s) will get EOF on the reverse channel(s), and
   // the thread(s) will exit.  In ServiceRuntime::Shutdown, we invoke
   // ReverseService::WaitForServiceThreadsToExit(), so that there will
   // not be an extent thread(s) hanging around.  This means that the
   // ~Plugin will block until this happens.  This is a requirement,
@@ skipping 116 matching lines @@
     int64_t loaded;
     int64_t total;
     pnacl_coordinator_->GetCurrentProgress(&loaded, &total);
     ReportLoadSuccess(loaded, total);
   }
 }
 
 void Plugin::NaClManifestFileDidOpen(int32_t pp_error) {
   PLUGIN_PRINTF(("Plugin::NaClManifestFileDidOpen (pp_error=%"
                  NACL_PRId32 ")\n", pp_error));
-  if (pp_error != PP_OK || manifest_id_ == -1)
+  if (pp_error != PP_OK)
     return;
 
   PP_Var pp_program_url;
   PP_PNaClOptions pnacl_options = {PP_FALSE, PP_FALSE, 2};
   PP_Bool uses_nonsfi_mode;
-  if (nacl_interface_->GetManifestProgramURL(pp_instance(),
-          manifest_id_, &pp_program_url, &pnacl_options, &uses_nonsfi_mode)) {
+  if (nacl_interface_->GetManifestProgramURL(
+          pp_instance(), &pp_program_url, &pnacl_options, &uses_nonsfi_mode)) {
     program_url_ = pp::Var(pp::PASS_REF, pp_program_url).AsString();
     // TODO(teravest): Make ProcessNaClManifest take responsibility for more of
     // this function.
     nacl_interface_->ProcessNaClManifest(pp_instance(), program_url_.c_str());
     uses_nonsfi_mode_ = PP_ToBool(uses_nonsfi_mode);
     if (pnacl_options.translate) {
       pp::CompletionCallback translate_callback =
           callback_factory_.NewCallback(&Plugin::BitcodeDidTranslate);
       pnacl_coordinator_.reset(
           PnaclCoordinator::BitcodeToNative(this,
@@ skipping 13 matching lines @@
     }
   }
 }
 
 void Plugin::RequestNaClManifest(const nacl::string& url) {
   PLUGIN_PRINTF(("Plugin::RequestNaClManifest (url='%s')\n", url.c_str()));
   pp::CompletionCallback open_callback =
       callback_factory_.NewCallback(&Plugin::NaClManifestFileDidOpen);
   nacl_interface_->RequestNaClManifest(pp_instance(),
                                        url.c_str(),
-                                       &manifest_id_,
                                        open_callback.pp_completion_callback());
 }
 
 void Plugin::ReportLoadSuccess(uint64_t loaded_bytes, uint64_t total_bytes) {
   nacl_interface_->ReportLoadSuccess(
       pp_instance(), program_url_.c_str(), loaded_bytes, total_bytes);
 }
 
 
 void Plugin::ReportLoadError(const ErrorInfo& error_info) {
@@ skipping 55 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