Pepper: Nexe downloading out of the trusted plugin.

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 35 matching lines @@
 
 // Up to 20 seconds
 const int64_t kTimeSmallMin = 1;         // in ms
 const int64_t kTimeSmallMax = 20000;     // in ms
 const uint32_t kTimeSmallBuckets = 100;
 
 const int64_t kSizeKBMin = 1;
 const int64_t kSizeKBMax = 512*1024;     // very large .nexe
 const uint32_t kSizeKBBuckets = 100;
 
+// Converts a PP_FileHandle to a POSIX file descriptor.
+int32_t ConvertFileDescriptor(PP_FileHandle handle) {
+  PLUGIN_PRINTF(("ConvertFileDescriptor, handle=%d\n", handle));
+#if NACL_WINDOWS
+  int32_t file_desc = NACL_NO_FILE_DESC;
+  // On Windows, valid handles are 32 bit unsigned integers so this is safe.
+  file_desc = reinterpret_cast<intptr_t>(handle);
+  // Convert the Windows HANDLE from Pepper to a POSIX file descriptor.
+  int32_t posix_desc = _open_osfhandle(file_desc, _O_RDWR | _O_BINARY);
+  if (posix_desc == -1) {
+    // Close the Windows HANDLE if it can't be converted.
+    CloseHandle(reinterpret_cast<HANDLE>(file_desc));
+    return -1;
+  }
+  return posix_desc;
+#else
+  return handle;
+#endif
+}
+
+
 }  // namespace
 
 void Plugin::ShutDownSubprocesses() {
   PLUGIN_PRINTF(("Plugin::ShutDownSubprocesses (this=%p)\n",
                  static_cast<void*>(this)));
   PLUGIN_PRINTF(("Plugin::ShutDownSubprocesses (%s)\n",
                  main_subprocess_.detailed_description().c_str()));
 
   // Shut down service runtime. This must be done before all other calls so
   // they don't block forever when waiting for the upcall thread to exit.
@@ skipping 265 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),
-      nexe_open_time_(-1),
       manifest_id_(-1),
+      nexe_handle_(PP_kInvalidFileHandle),
       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
   // 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);
 }
@@ skipping 57 matching lines @@
 
 bool Plugin::HandleDocumentLoad(const pp::URLLoader& url_loader) {
   PLUGIN_PRINTF(("Plugin::HandleDocumentLoad (this=%p)\n",
                  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) {
-  NaClFileInfo tmp_info(nexe_downloader_.GetFileInfo());
-  NaClFileInfoAutoCloser info(&tmp_info);
-
-  int64_t nexe_bytes_read = -1;
-  if (pp_error == PP_OK && info.get_desc() != NACL_NO_FILE_DESC) {
-    struct stat stat_buf;
-    if (0 == fstat(info.get_desc(), &stat_buf))
-      nexe_bytes_read = stat_buf.st_size;
-  }
-
-  int64_t now = NaClGetTimeOfDayMicroseconds();
-  int64_t download_time;
-  if (now < nexe_open_time_)
-    download_time = 0;
-  else
-    download_time = now - nexe_open_time_;
-
-  nacl_interface_->NexeFileDidOpen(
-      pp_instance(),
-      pp_error,
-      info.get_desc(),
-      nexe_downloader_.status_code(),
-      nexe_bytes_read,
-      nexe_downloader_.url().c_str(),
-      download_time / 1000);
-
-  if (nexe_bytes_read == -1)
+  if (pp_error != PP_OK)
     return;
 
+  int32_t desc = ConvertFileDescriptor(nexe_handle_);
+  nexe_handle_ = PP_kInvalidFileHandle;  // Clear out nexe handle.
+
   nacl::scoped_ptr<nacl::DescWrapper>
-      wrapper(wrapper_factory()->MakeFileDesc(info.Release().desc, O_RDONLY));
+      wrapper(wrapper_factory()->MakeFileDesc(desc, O_RDONLY));
   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 82 matching lines @@
   HistogramSizeKB("NaCl.Perf.Size.Manifest",
                   static_cast<int32_t>(manifest_json.length() / 1024));
   if (!SetManifestObject(manifest_json))
     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)) {
-    std::string program_url = pp::Var(pp::PASS_REF, pp_program_url).AsString();
+    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());
+    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,
-                                            program_url,
+                                            program_url_,
                                             pnacl_options,
                                             translate_callback));
       return;
     } else {
-      nexe_open_time_ = NaClGetTimeOfDayMicroseconds();
-      // Try the fast path first. This will only block if the file is installed.
-      if (OpenURLFast(program_url, &nexe_downloader_)) {
-        NexeFileDidOpen(PP_OK);
-      } else {
-        pp::CompletionCallback open_callback =
-            callback_factory_.NewCallback(&Plugin::NexeFileDidOpen);
-        // Will always call the callback on success or failure.
-        CHECK(
-            nexe_downloader_.Open(program_url,
-                                  DOWNLOAD_TO_FILE,
-                                  open_callback,
-                                  true,
-                                  &UpdateDownloadProgress));
-      }
+      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_,
+                                    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);
   nacl_interface_->RequestNaClManifest(pp_instance(),
@@ skipping 87 matching lines @@
   // If true, will always call the callback on success or failure.
   return downloader->Open(url,
                           DOWNLOAD_TO_FILE,
                           open_callback,
                           true,
                           &UpdateDownloadProgress);
 }
 
 
 void Plugin::ReportLoadSuccess(uint64_t loaded_bytes, uint64_t total_bytes) {
-  const nacl::string& url = nexe_downloader_.url();
   nacl_interface_->ReportLoadSuccess(
-      pp_instance(), url.c_str(), loaded_bytes, total_bytes);
+      pp_instance(), program_url_.c_str(), loaded_bytes, total_bytes);
 }
 
 
 void Plugin::ReportLoadError(const ErrorInfo& error_info) {
   nacl_interface_->ReportLoadError(pp_instance(),
                                    error_info.error_code(),
                                    error_info.message().c_str(),
                                    error_info.console_message().c_str());
 }
 
@@ skipping 15 matching lines @@
     // Rate limit progress events to a maximum of 100 per second.
     int64_t time = NaClGetTimeOfDayMicroseconds();
     int64_t elapsed = time - plugin->time_of_last_progress_event_;
     const int64_t kTenMilliseconds = 10000;
     if (elapsed > kTenMilliseconds) {
       plugin->time_of_last_progress_event_ = time;
 
       // Find the URL loader that sent this notification.
       const FileDownloader* file_downloader =
           plugin->FindFileDownloader(pp_resource);
-      // If not a streamed file, it must be the .nexe loader.
-      if (file_downloader == NULL)
-        file_downloader = &plugin->nexe_downloader_;
-      nacl::string url = file_downloader->url();
+      nacl::string url;
+      if (file_downloader)
+        url = file_downloader->url();
       LengthComputable length_computable = (total_bytes_to_be_received >= 0) ?
           LENGTH_IS_COMPUTABLE : LENGTH_IS_NOT_COMPUTABLE;
 
       plugin->EnqueueProgressEvent(PP_NACL_EVENT_PROGRESS,
                                    url,
                                    length_computable,
                                    bytes_received,
                                    total_bytes_to_be_received);
     }
   }
 }
 
 const FileDownloader* Plugin::FindFileDownloader(
     PP_Resource url_loader) const {
   const FileDownloader* file_downloader = NULL;
-  if (url_loader == nexe_downloader_.url_loader()) {
-    file_downloader = &nexe_downloader_;
-  } else {
-    std::set<FileDownloader*>::const_iterator it = url_downloaders_.begin();
-    while (it != url_downloaders_.end()) {
-      if (url_loader == (*it)->url_loader()) {
-        file_downloader = (*it);
-        break;
-      }
-      ++it;
+  std::set<FileDownloader*>::const_iterator it = url_downloaders_.begin();
+  while (it != url_downloaders_.end()) {
+    if (url_loader == (*it)->url_loader()) {
+      file_downloader = (*it);
+      break;
     }
+    ++it;
   }
   return file_downloader;
 }
 
 void Plugin::ReportSelLdrLoadStatus(int status) {
   HistogramEnumerateSelLdrLoadStatus(static_cast<NaClErrorCode>(status));
 }
 
 void Plugin::EnqueueProgressEvent(PP_NaClEventType event_type,
                                   const nacl::string& url,
@@ 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