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 249 matching lines @@
                            exit_code, exit_code);
     if (exit_code == 0) {
       VLOG(1) << message;
     } else {
       LOG(ERROR) << message;
     }
     NaClBrowser::GetInstance()->OnProcessEnd(process_->GetData().id);
   }
 
   // Note: this does not work on Windows, though we currently support this
-  // prefetching feature only on Non-SFI mode, which is supported only on
-  // Linux/ChromeOS, so it should be ok.
+  // prefetching feature only on POSIX platforms, so it should be ok.
 #if defined(OS_WIN)
   DCHECK(prefetched_resource_files_.empty());
 #else
   for (size_t i = 0; i < prefetched_resource_files_.size(); ++i) {
     // The process failed to launch for some reason. Close resource file
     // handles.
     base::File file(IPC::PlatformFileForTransitToFile(
         prefetched_resource_files_[i].file));
     content::BrowserThread::GetBlockingPool()->PostTask(
         FROM_HERE,
@@ skipping 582 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;
   }
 
+  // Pass the pre-opened resource files to the loader. We do not have to reopen
+  // resource files here even for SFI mode because the descriptors are not from
+  // a renderer.
+  for (size_t i = 0; i < prefetched_resource_files_.size(); ++i) {
+    params.prefetched_resource_files.push_back(
+        NaClResourcePrefetchResult(
+            prefetched_resource_files_[i].file,
+            // For the same reason as the comment below, always use an empty
+            // base::FilePath for non-SFI mode.
+            (uses_nonsfi_mode_ ? base::FilePath() :
+             prefetched_resource_files_[i].file_path_metadata),
+            prefetched_resource_files_[i].file_key));
+  }
+  prefetched_resource_files_.clear();
+
   base::FilePath file_path;
   if (uses_nonsfi_mode_) {
     // 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.
-
-    // Pass the pre-opened resource files to the loader. For the same reason
-    // as above, use an empty base::FilePath.
-    for (size_t i = 0; i < prefetched_resource_files_.size(); ++i) {
-      params.prefetched_resource_files.push_back(NaClResourcePrefetchResult(
-          prefetched_resource_files_[i].file,
-          base::FilePath(),
-          prefetched_resource_files_[i].file_key));
-    }
-    prefetched_resource_files_.clear();
   } 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;
       }
     }
-    // TODO(yusukes): Handle |prefetched_resource_files_| for SFI-NaCl.
-    DCHECK(prefetched_resource_files_.empty());
   }
 
   params.nexe_file = IPC::TakeFileHandleForProcess(nexe_file_.Pass(),
                                                    process_->GetData().handle);
   process_->Send(new NaClProcessMsg_Start(params));
   return true;
 }
 
 void NaClProcessHost::StartNaClFileResolved(
     NaClStartParams params,
@@ skipping 259 matching lines @@
         process.Pass(), info,
         base::MessageLoopProxy::current(),
         base::Bind(&NaClProcessHost::OnDebugExceptionHandlerLaunchedByBroker,
                    weak_factory_.GetWeakPtr()));
     return true;
   }
 }
 #endif
 
 }  // namespace nacl