PNaCl cleanup: Remove TempFile class and use base::File instead

components/nacl/renderer/plugin/pnacl_translate_thread.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/renderer/plugin/pnacl_translate_thread.h"
 
 #include <stddef.h>
 
 #include <iterator>
 #include <sstream>
 
 #include "base/logging.h"
 #include "components/nacl/renderer/plugin/plugin.h"
 #include "components/nacl/renderer/plugin/plugin_error.h"
-#include "components/nacl/renderer/plugin/temporary_file.h"
 #include "components/nacl/renderer/plugin/utility.h"
 #include "content/public/common/sandbox_init.h"
 #include "native_client/src/shared/platform/nacl_sync_raii.h"
 #include "ppapi/c/ppb_file_io.h"
 #include "ppapi/cpp/var.h"
 #include "ppapi/proxy/ppapi_messages.h"
 
 namespace plugin {
 namespace {
 
@@ skipping 50 matching lines @@
       ld_channel_peer_pid_(base::kNullProcessId) {
   NaClXMutexCtor(&subprocess_mu_);
   NaClXMutexCtor(&cond_mu_);
   NaClXCondVarCtor(&buffer_cond_);
 }
 
 void PnaclTranslateThread::SetupState(
     const pp::CompletionCallback& finish_callback,
     NaClSubprocess* compiler_subprocess,
     NaClSubprocess* ld_subprocess,
-    const std::vector<TempFile*>* obj_files,
+    std::vector<base::File>* obj_files,
     int num_threads,
-    TempFile* nexe_file,
+    base::File* nexe_file,
     ErrorInfo* error_info,
     PP_PNaClOptions* pnacl_options,
     const std::string& architecture_attributes,
     PnaclCoordinator* coordinator) {
   PLUGIN_PRINTF(("PnaclTranslateThread::SetupState)\n"));
   compiler_subprocess_ = compiler_subprocess;
   ld_subprocess_ = ld_subprocess;
   obj_files_ = obj_files;
   num_threads_ = num_threads;
   nexe_file_ = nexe_file;
@@ skipping 90 matching lines @@
 }
 
 void PnaclTranslateThread::EndStream() {
   NaClXMutexLock(&cond_mu_);
   done_ = true;
   NaClXCondVarSignal(&buffer_cond_);
   NaClXMutexUnlock(&cond_mu_);
 }
 
 ppapi::proxy::SerializedHandle PnaclTranslateThread::GetHandleForSubprocess(
-    TempFile* file, int32_t open_flags, base::ProcessId peer_pid) {
+    base::File* file, int32_t open_flags, base::ProcessId peer_pid) {
   IPC::PlatformFileForTransit file_for_transit;
 
+  DCHECK(file->IsValid());
 #if defined(OS_WIN)
   if (!content::BrokerDuplicateHandle(
-          file->GetFileHandle(),
+          file->GetPlatformFile(),
           peer_pid,
           &file_for_transit,
           0,  // desired_access is 0 since we're using DUPLICATE_SAME_ACCESS.
           DUPLICATE_SAME_ACCESS)) {
     return ppapi::proxy::SerializedHandle();
   }
 #else
-  file_for_transit = base::FileDescriptor(dup(file->GetFileHandle()), true);
+  file_for_transit = base::FileDescriptor(dup(file->GetPlatformFile()), true);
 #endif
 
   // Using 0 disables any use of quota enforcement for this file handle.
   PP_Resource file_io = 0;
 
   ppapi::proxy::SerializedHandle handle;
   handle.set_file_handle(file_for_transit, open_flags, file_io);
   return handle;
 }
 
 void WINAPI PnaclTranslateThread::DoCompileThread(void* arg) {
   PnaclTranslateThread* translator =
       reinterpret_cast<PnaclTranslateThread*>(arg);
   translator->DoCompile();
 }
 
 void PnaclTranslateThread::DoCompile() {
   {
     nacl::MutexLocker ml(&subprocess_mu_);
     // If the main thread asked us to exit in between starting the thread
     // and now, just leave now.
     if (!compiler_subprocess_active_)
       return;
   }
 
   std::vector<ppapi::proxy::SerializedHandle> compiler_output_files;
-  for (TempFile* obj_file : *obj_files_) {
+  for (base::File& obj_file : *obj_files_) {
     compiler_output_files.push_back(
-        GetHandleForSubprocess(obj_file, PP_FILEOPENFLAG_WRITE,
+        GetHandleForSubprocess(&obj_file, PP_FILEOPENFLAG_WRITE,
                                compiler_channel_peer_pid_));
   }
 
   PLUGIN_PRINTF(("DoCompile using subzero: %d\n", pnacl_options_->use_subzero));
 
   pp::Core* core = pp::Module::Get()->core();
   int64_t do_compile_start_time = NaClGetTimeOfDayMicroseconds();
 
   std::vector<std::string> args;
   if (pnacl_options_->use_subzero) {
@@ skipping 106 matching lines @@
 void PnaclTranslateThread::DoLink() {
   {
     nacl::MutexLocker ml(&subprocess_mu_);
     // If the main thread asked us to exit in between starting the thread
     // and now, just leave now.
     if (!ld_subprocess_active_)
       return;
   }
 
   // Reset object files for reading first.  We do this before duplicating
-  // handles/FDs to prevent any handle/FD leaks in case any of the Reset()
+  // handles/FDs to prevent any handle/FD leaks in case any of the Seek()
   // calls fail.
-  for (TempFile* obj_file : *obj_files_) {
-    if (!obj_file->Reset()) {
+  for (base::File& obj_file : *obj_files_) {
+    if (obj_file.Seek(base::File::FROM_BEGIN, 0) != 0) {
       TranslateFailed(PP_NACL_ERROR_PNACL_LD_SETUP,
                       "Link process could not reset object file");
       return;
     }
   }
 
   ppapi::proxy::SerializedHandle nexe_file =
       GetHandleForSubprocess(nexe_file_, PP_FILEOPENFLAG_WRITE,
                              ld_channel_peer_pid_);
   std::vector<ppapi::proxy::SerializedHandle> ld_input_files;
-  for (TempFile* obj_file : *obj_files_) {
+  for (base::File& obj_file : *obj_files_) {
     ld_input_files.push_back(
-        GetHandleForSubprocess(obj_file, PP_FILEOPENFLAG_READ,
+        GetHandleForSubprocess(&obj_file, PP_FILEOPENFLAG_READ,
                                ld_channel_peer_pid_));
   }
 
   int64_t link_start_time = NaClGetTimeOfDayMicroseconds();
   bool success = false;
   bool sent = ld_channel_filter_->Send(
       new PpapiMsg_PnaclTranslatorLink(ld_input_files, nexe_file, &success));
   if (!sent) {
     TranslateFailed(PP_NACL_ERROR_PNACL_LD_INTERNAL,
                     "link failed: reply not received from linker.");
@@ skipping 64 matching lines @@
   AbortSubprocesses();
   if (translate_thread_ != NULL)
     NaClThreadJoin(translate_thread_.get());
   PLUGIN_PRINTF(("~PnaclTranslateThread joined\n"));
   NaClCondVarDtor(&buffer_cond_);
   NaClMutexDtor(&cond_mu_);
   NaClMutexDtor(&subprocess_mu_);
 }
 
 } // namespace plugin