Set file tokens for NaCl main nexe if available to enable validation caching.

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"
 
 #include <sys/stat.h>
 #include <sys/types.h>
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
 #include "native_client/src/include/nacl_base.h"
 #include "native_client/src/include/nacl_macros.h"
 #include "native_client/src/include/nacl_scoped_ptr.h"
 #include "native_client/src/include/nacl_string.h"
 #include "native_client/src/include/portability.h"
 #include "native_client/src/include/portability_io.h"
 #include "native_client/src/include/portability_string.h"
+#include "native_client/src/public/nacl_file_info.h"
 #include "native_client/src/shared/platform/nacl_check.h"
 #include "native_client/src/trusted/desc/nacl_desc_wrapper.h"
 #include "native_client/src/trusted/nonnacl_util/sel_ldr_launcher.h"
 #include "native_client/src/trusted/service_runtime/nacl_error_code.h"
 
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/ppb_var.h"
 #include "ppapi/c/private/ppb_nacl_private.h"
 #include "ppapi/cpp/dev/url_util_dev.h"
 #include "ppapi/cpp/module.h"
@@ skipping 332 matching lines @@
   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);
+  memset(&nexe_file_info_, 0, sizeof nexe_file_info_);
+  nexe_file_info_.desc = -1;
 }
 
 
 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);
@@ skipping 51 matching lines @@
                  static_cast<void*>(this)));
   // 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;
 
-  int32_t desc = ConvertFileDescriptor(nexe_handle_);
+  nexe_file_info_.desc = ConvertFileDescriptor(nexe_handle_);

[teravest, 2014/05/21 16:49:42]

I'm a little confused why nexe_file_info_ needs to be a class member; it might
be simpler to just create the NaClFileInfo inline in this function, and have
Plugin class members for token_lo and token_hi.

I have a similar change for dealing with files downloaded for open_resource():
https://codereview.chromium.org/294633003/

...and ended up making a PP_NaClFileInfo type that I passed around, which seemed
to work alright.

[jvoung (off chromium), 2014/05/21 21:10:56]

It was mostly to avoid heap allocating the NaClFileInfo, but yeah I can make the
members token_lo and token_hi instead and only reconstitute the NaClFileInfo
here.
Should I leave the ppb_nacl interface having separate desc/tokens for now, and
switch to PP_NaClFileInfo later?

   nexe_handle_ = PP_kInvalidFileHandle;  // Clear out nexe handle.
 
+  NaClDesc *desc = NaClDescIoFromFileInfo(nexe_file_info_, O_RDONLY);
+  if (desc == NULL)
+    return;
+  // nexe_file_info_ is handed to desc, clear out old copy.
+  memset(&nexe_file_info_, 0, sizeof nexe_file_info_);
+  nexe_file_info_.desc = -1;
   nacl::scoped_ptr<nacl::DescWrapper>
-      wrapper(wrapper_factory()->MakeFileDesc(desc, O_RDONLY));
+      wrapper(wrapper_factory()->MakeGenericCleanup(desc));
   NaClLog(4, "NexeFileDidOpen: invoking LoadNaClModule\n");
   LoadNaClModule(
       wrapper.release(),
       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));
 }
@@ skipping 103 matching lines @@
                                             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(),
                                     &nexe_handle_,
+                                    &nexe_file_info_.file_token.lo,
+                                    &nexe_file_info_.file_token.hi,
                                     open_callback.pp_completion_callback());
       return;
     }
   }
 }
 
 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);
@@ skipping 225 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