obsolete: 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 895 matching lines @@
     }
 #endif
   }
 
   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;
+  base::FilePath nexe_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_) {
     for (size_t i = 0; i < resource_files_info_len_; ++i) {
       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
+                                                     &nexe_file_path)) {
+    std::vector<base::FilePath> nexe_file_paths(resource_files_info_len_ + 1);
+    nexe_file_paths[0] = nexe_file_path;
+    for (size_t i = 0; i < resource_files_info_len_; ++i) {
+      if (!NaClBrowser::GetInstance()->GetFilePath(
+              resource_files_info_[i].file_token().lo,
+              resource_files_info_[i].file_token().hi,
+              &nexe_file_paths[i + 1])) {
+        nexe_file_paths.resize(1);  // We still need to open the main nexe file.
+        break;
+      }
+    }
+    // We have to reopen the files in the browser process; we don't want a
+    // compromised renderer to pass arbitrary fds that could get loaded
     // into the plugin process.
     if (base::PostTaskAndReplyWithResult(
            content::BrowserThread::GetBlockingPool(),
            FROM_HERE,
-           base::Bind(OpenNaClReadExecImpl,
-                      file_path,
+           base::Bind(OpenNaClFilesReadExecImpl,
+                      nexe_file_paths,
                       true /* is_executable */),
-           base::Bind(&NaClProcessHost::StartNaClFileResolved,
+           base::Bind(&NaClProcessHost::StartNaClFilesResolved,
                       weak_factory_.GetWeakPtr(),
                       params,
-                      file_path))) {
+                      nexe_file_paths.size()))) {
       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(
+void NaClProcessHost::StartNaClFilesResolved(
     NaClStartParams params,
-    const base::FilePath& file_path,
-    base::File checked_nexe_file) {
-  if (checked_nexe_file.IsValid()) {
+    size_t checked_nexe_files_len,
+    scoped_ptr<OpenNaClFileReadExecImplResult[]> checked_nexe_files) {
+  // The first element of the array is for the main nexe.
+  DCHECK(checked_nexe_files_len > 0);
+  if (checked_nexe_files[0].IsValid()) {
     // Release the file received from the renderer. This has to be done on a
     // thread where IO is permitted, though.
     content::BrowserThread::GetBlockingPool()->PostTask(
         FROM_HERE,
         base::Bind(&CloseFile, base::Passed(nexe_file_.Pass())));
-    params.nexe_file_path_metadata = file_path;
+    params.nexe_file_path_metadata = checked_nexe_files[0].file_path();
     params.nexe_file = IPC::TakeFileHandleForProcess(
-        checked_nexe_file.Pass(), process_->GetData().handle);
+        checked_nexe_files[0].file().Pass(), process_->GetData().handle);
   } else {
     params.nexe_file = IPC::TakeFileHandleForProcess(
         nexe_file_.Pass(), process_->GetData().handle);
   }
+
+  // The rest is for resource files.
+  for (size_t i = 1; i < checked_nexe_files_len; ++i) {
+    // Release the resource files received from the renderer too.
+    content::BrowserThread::GetBlockingPool()->PostTask(
+        FROM_HERE,
+        base::Bind(&CloseFile,
+                   base::Passed(resource_files_info_[i - 1].file().Pass())));
+    if (!checked_nexe_files[i].IsValid())
+      continue;
+    IPC::PlatformFileForTransit file = IPC::TakeFileHandleForProcess(
+        checked_nexe_files[i].file().Pass(), process_->GetData().handle);
+    std::string file_key = resource_files_info_[i - 1].file_key();
+    params.resource_files.push_back(NaClStartParams::ResourceFileInfo(
+        file, checked_nexe_files[i].file_path(), file_key));
+  }
+
+  params.CheckNumOfDescriptors();
   process_->Send(new NaClProcessMsg_Start(params));
 }
 
 // This method is called when NaClProcessHostMsg_PpapiChannelCreated is
 // received.
 void NaClProcessHost::OnPpapiChannelsCreated(
     const IPC::ChannelHandle& browser_channel_handle,
     const IPC::ChannelHandle& ppapi_renderer_channel_handle,
     const IPC::ChannelHandle& trusted_renderer_channel_handle,
     const IPC::ChannelHandle& manifest_service_channel_handle) {
@@ skipping 236 matching lines @@
         process_handle.Take(), info,
         base::MessageLoopProxy::current(),
         base::Bind(&NaClProcessHost::OnDebugExceptionHandlerLaunchedByBroker,
                    weak_factory_.GetWeakPtr()));
     return true;
   }
 }
 #endif
 
 }  // namespace nacl