Non-SFI NaCl: Batch-open resource files

components/nacl/browser/nacl_process_host.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 "components/nacl/browser/nacl_process_host.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 217 matching lines @@
 
 void CloseFile(base::File file) {
   // The base::File destructor will close the file for us.
 }
 
 }  // namespace
 
 unsigned NaClProcessHost::keepalive_throttle_interval_milliseconds_ =
     ppapi::kKeepaliveThrottleIntervalDefaultMilliseconds;
 
-NaClProcessHost::NaClProcessHost(const GURL& manifest_url,
-                                 base::File nexe_file,
-                                 const NaClFileToken& nexe_token,
-                                 ppapi::PpapiPermissions permissions,
-                                 int render_view_id,
-                                 uint32 permission_bits,
-                                 bool uses_nonsfi_mode,
-                                 bool off_the_record,
-                                 NaClAppProcessType process_type,
-                                 const base::FilePath& profile_directory)
+NaClProcessHost::ResourceFileInfo::ResourceFileInfo()
+    : file_token_() {
+}
+
+NaClProcessHost::ResourceFileInfo::ResourceFileInfo(
+    base::File file,
+    const NaClFileToken& file_token,
+    const std::string& file_key)
+    : file_(file.Pass()),
+      file_token_(file_token),
+      file_key_(file_key) {
+}
+
+NaClProcessHost::ResourceFileInfo::~ResourceFileInfo() {
+}
+
+NaClProcessHost::ResourceFileInfo::ResourceFileInfo(RValue other)
+    : file_(other.object->file_.Pass()),
+      file_token_(other.object->file_token()),
+      file_key_(other.object->file_key()) {
+}
+
+NaClProcessHost::ResourceFileInfo&
+NaClProcessHost::ResourceFileInfo::operator=(RValue other) {
+  if (this != other.object) {
+    file_ = other.object->file_.Pass();
+    file_token_ = other.object->file_token();
+    file_key_ = other.object->file_key();
+  }
+  return *this;
+}
+
+NaClProcessHost::NaClProcessHost(
+    const GURL& manifest_url,
+    base::File nexe_file,
+    const NaClFileToken& nexe_token,
+    scoped_ptr<NaClProcessHost::ResourceFileInfo[]> resource_files_info,
+    size_t resource_files_info_len,
+    ppapi::PpapiPermissions permissions,
+    int render_view_id,
+    uint32 permission_bits,
+    bool uses_nonsfi_mode,
+    bool off_the_record,
+    NaClAppProcessType process_type,
+    const base::FilePath& profile_directory)
     : manifest_url_(manifest_url),
       nexe_file_(nexe_file.Pass()),
       nexe_token_(nexe_token),
+      resource_files_info_(resource_files_info.Pass()),
+      resource_files_info_len_(resource_files_info_len),
       permissions_(permissions),
 #if defined(OS_WIN)
       process_launched_by_broker_(false),
 #endif
       reply_msg_(NULL),
 #if defined(OS_WIN)
       debug_exception_handler_requested_(false),
 #endif
       uses_nonsfi_mode_(uses_nonsfi_mode),
       enable_debug_stub_(false),
@@ skipping 612 matching lines @@
   if (!crash_info_shmem_.ShareToProcess(process_->GetData().handle,
                                         &params.crash_info_shmem_handle)) {
     DLOG(ERROR) << "Failed to ShareToProcess() a shared memory buffer";
     return false;
   }
 
   base::FilePath file_path;
   // Don't retrieve the file path when using nonsfi mode; there's no validation
   // caching in that case, so it's unnecessary work, and would expose the file
   // path to the plugin.
-  if (!uses_nonsfi_mode_ &&
-      NaClBrowser::GetInstance()->GetFilePath(nexe_token_.lo,
-                                              nexe_token_.hi,
-                                              &file_path)) {
+  if (uses_nonsfi_mode_) {

[hidehiko, 2015/01/28 09:05:19]

nit:

if (nonsfi) {
  // Don't retrieve the file path ...
  ...
} else {
  if (NaClBrowser::GetInstance()->GetFilePath(...)) {
    // We have to ...
    if (base::PostTaskAndReplyWithResult(...)) {
      return true;
    }
  }
}

may be more understandable? Up to you.

[Yusuke Sato, 2015/02/04 02:00:28]

Done.

+    for (size_t i = 0; i < resource_files_info_len_; ++i) {

[hidehiko, 2015/01/28 09:05:19]

Could you add a short comment why this is needed only in non-sfi mode?

[Yusuke Sato, 2015/02/04 02:00:28]

Done.

+      IPC::PlatformFileForTransit file = IPC::TakeFileHandleForProcess(
+          resource_files_info_[i].file().Pass(), process_->GetData().handle);
+      std::string file_key = resource_files_info_[i].file_key();
+      params.resource_files.push_back(
+          // Pass an empty base::FilePath since Non-SFI mode does not use it.
+          NaClStartParams::ResourceFileInfo(file, base::FilePath(), file_key));
+    }
+  } else if (NaClBrowser::GetInstance()->GetFilePath(nexe_token_.lo,
+                                                     nexe_token_.hi,
+                                                     &file_path)) {
     // We have to reopen the file in the browser process; we don't want a
     // compromised renderer to pass an arbitrary fd that could get loaded
     // into the plugin process.
     if (base::PostTaskAndReplyWithResult(
            content::BrowserThread::GetBlockingPool(),
            FROM_HERE,
            base::Bind(OpenNaClReadExecImpl,
                       file_path,
                       true /* is_executable */),
            base::Bind(&NaClProcessHost::StartNaClFileResolved,
                       weak_factory_.GetWeakPtr(),
                       params,
                       file_path))) {
       return true;
     }
   }
 
   params.nexe_file = IPC::TakeFileHandleForProcess(nexe_file_.Pass(),
                                                    process_->GetData().handle);
+
+  params.CheckNumOfDescriptors();
   process_->Send(new NaClProcessMsg_Start(params));
   return true;
 }
 
 void NaClProcessHost::StartNaClFileResolved(
     NaClStartParams params,
     const base::FilePath& file_path,
     base::File checked_nexe_file) {
   if (checked_nexe_file.IsValid()) {
     // Release the file received from the renderer. This has to be done on a
@@ skipping 257 matching lines @@
         process_handle.Take(), info,
         base::MessageLoopProxy::current(),
         base::Bind(&NaClProcessHost::OnDebugExceptionHandlerLaunchedByBroker,
                    weak_factory_.GetWeakPtr()));
     return true;
   }
 }
 #endif
 
 }  // namespace nacl