Non-SFI NaCl: Batch-open resource files

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 99 matching lines @@
 }
 
 void Plugin::SignalStartSelLdrDone(int32_t pp_error,
                                    bool* started,
                                    ServiceRuntime* service_runtime) {
   *started = (pp_error == PP_OK);
   service_runtime->SignalStartSelLdrDone();
 }
 
 void Plugin::LoadNaClModule(PP_NaClFileInfo file_info,
+                            PP_NaClResourceFileHandle* resource_file_handles,
+                            uint32_t resource_file_handles_len,
                             bool uses_nonsfi_mode,
                             PP_NaClAppProcessType process_type,
                             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,
+                           resource_file_handles,
+                           resource_file_handles_len,
                            process_type);
   ErrorInfo error_info;
   ServiceRuntime* service_runtime = new ServiceRuntime(
       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);
@@ skipping 45 matching lines @@
                           "unable to allocate helper subprocess.");
     return NULL;
   }
 
   // Do not report UMA stats for translator-related nexes.
   // TODO(sehr): define new UMA stats for translator related nexe events.
   // NOTE: The PNaCl translator nexes are not built to use the IRT.  This is
   // done to save on address space and swap space.
   SelLdrStartParams params(helper_url,
                            file_info,
+                           NULL,
+                           0,
                            PP_PNACL_TRANSLATOR_PROCESS_TYPE);
 
   // Helper NaCl modules always use the PNaCl manifest, as there is no
   // corresponding NMF.
   if (!LoadHelperNaClModuleInternal(nacl_subprocess.get(), 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.
@@ skipping 31 matching lines @@
   nacl_interface_->RequestNaClManifest(pp_instance(),
                                        open_cb.pp_completion_callback());
   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),
+      resource_file_handles_(NULL),
+      resource_file_handles_len_(0),
       nacl_interface_(NULL),
       uma_interface_(this) {
   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);
   nexe_file_info_ = kInvalidNaClFileInfo;
@@ skipping 28 matching lines @@
   //
   // The main_subprocess object, which wraps the main service_runtime
   // object, is dtor'd implicitly after the explicit code below runs,
   // so the main service runtime object will not have been dtor'd,
   // though the Shutdown method may have been called, during the
   // lifetime of the service threads.
   ShutDownSubprocesses();
 
   delete wrapper_factory_;
 
+  for (uint32_t i = 0; i < resource_file_handles_len_; ++i) {
+    free(resource_file_handles_[i].key);
+  }
+  delete[] resource_file_handles_;
+
   HistogramTimeSmall(
       "NaCl.Perf.ShutdownTime.Total",
       (NaClGetTimeOfDayMicroseconds() - shutdown_start)
           / NACL_MICROS_PER_MILLI);
 }
 
 bool Plugin::HandleDocumentLoad(const pp::URLLoader& url_loader) {
   // We don't know if the plugin will handle the document load, but return
   // true in order to give it a chance to respond once the proxy is started.
   return true;
 }
 
 void Plugin::NexeFileDidOpen(int32_t pp_error) {
   if (pp_error != PP_OK)
     return;
   LoadNaClModule(
       nexe_file_info_,
+      resource_file_handles_,
+      resource_file_handles_len_,
       uses_nonsfi_mode_,
       PP_NATIVE_NACL_PROCESS_TYPE,
       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;"
@@ skipping 17 matching lines @@
 
   // 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,
+      NULL,
+      0,
       false, /* uses_nonsfi_mode */
       PP_PNACL_PROCESS_TYPE,
       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;
@@ skipping 29 matching lines @@
                                             program_url,
                                             pnacl_options,
                                             translate_callback));
       return;
     } else {
       pp::CompletionCallback open_callback =
           callback_factory_.NewCallback(&Plugin::NexeFileDidOpen);
       // Will always call the callback on success or failure.
       nacl_interface_->DownloadNexe(pp_instance(),
                                     program_url.c_str(),
+                                    // pre-open resource files on nonsfi mode
+                                    // TODO(yusukes): Enable the feature for
+                                    // SFI-NaCl too.
+                                    uses_nonsfi_mode,
                                     &nexe_file_info_,
+                                    &resource_file_handles_,
+                                    &resource_file_handles_len_,
                                     open_callback.pp_completion_callback());
       return;
     }
   }
 }
 
 void Plugin::ReportLoadError(const ErrorInfo& error_info) {
   nacl_interface_->ReportLoadError(pp_instance(),
                                    error_info.error_code(),
                                    error_info.message().c_str());
 }
 
 }  // namespace plugin