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

components/nacl/renderer/plugin/pnacl_coordinator.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_coordinator.h"
 
 #include <algorithm>
 #include <sstream>
 #include <utility>
 
 #include "base/logging.h"
 #include "components/nacl/renderer/plugin/plugin.h"
 #include "components/nacl/renderer/plugin/plugin_error.h"
 #include "components/nacl/renderer/plugin/pnacl_translate_thread.h"
 #include "components/nacl/renderer/plugin/service_runtime.h"
-#include "components/nacl/renderer/plugin/temporary_file.h"
 #include "ppapi/c/pp_bool.h"
 #include "ppapi/c/pp_errors.h"
 
 namespace plugin {
 
 namespace {
 
 std::string GetArchitectureAttributes(Plugin* plugin) {
   pp::Var attrs_var(pp::PASS_REF,
                     plugin->nacl_interface()->GetCpuFeatureAttrs());
@@ skipping 94 matching lines @@
   if (!translation_finished_reported_) {
     plugin_->nacl_interface()->ReportTranslationFinished(
         plugin_->pp_instance(), PP_FALSE, pnacl_options_.opt_level,
         pnacl_options_.use_subzero, 0, 0, 0);
   }
   // Force deleting the translate_thread now. It must be deleted
   // before any scoped_* fields hanging off of PnaclCoordinator
   // since the thread may be accessing those fields.
   // It will also be accessing obj_files_.
   translate_thread_.reset(NULL);
-  for (size_t i = 0; i < obj_files_.size(); i++)
-    delete obj_files_[i];
 }
 
 PP_FileHandle PnaclCoordinator::TakeTranslatedFileHandle() {
-  DCHECK(temp_nexe_file_ != NULL);
-  return temp_nexe_file_->TakeFileHandle();
+  DCHECK(temp_nexe_file_.IsValid());
+  return temp_nexe_file_.TakePlatformFile();
 }
 
 void PnaclCoordinator::ReportNonPpapiError(PP_NaClError err_code,
                                            const std::string& message) {
   ErrorInfo error_info;
   error_info.SetReport(err_code, message);
   plugin_->ReportLoadError(error_info);
   ExitWithError();
 }
 
@@ skipping 32 matching lines @@
   // that were delayed (see the delay inserted in BitcodeGotCompiled).
   if (expected_pexe_size_ != -1) {
     pexe_bytes_compiled_ = expected_pexe_size_;
     GetNaClInterface()->DispatchEvent(plugin_->pp_instance(),
                                       PP_NACL_EVENT_PROGRESS,
                                       pexe_url_.c_str(),
                                       PP_TRUE,
                                       pexe_bytes_compiled_,
                                       expected_pexe_size_);
   }
-  int64_t nexe_size = temp_nexe_file_->GetLength();
-  // The nexe is written to the temp_nexe_file_.  We must Reset() the file
+  int64_t nexe_size = temp_nexe_file_.GetLength();
+  // The nexe is written to the temp_nexe_file_.  We must reset the file
   // pointer to be able to read it again from the beginning.
-  temp_nexe_file_->Reset();
+  temp_nexe_file_.Seek(base::File::FROM_BEGIN, 0);
 
   // Report to the browser that translation finished. The browser will take
   // care of storing the nexe in the cache.
   translation_finished_reported_ = true;
   plugin_->nacl_interface()->ReportTranslationFinished(
       plugin_->pp_instance(), PP_TRUE, pnacl_options_.opt_level,
       pnacl_options_.use_subzero, nexe_size, pexe_size_,
       translate_thread_->GetCompileTime());
 
   NexeReadDidOpen();
 }
 
 void PnaclCoordinator::NexeReadDidOpen() {
-  if (!temp_nexe_file_->IsValid()) {
+  if (!temp_nexe_file_.IsValid()) {
     ReportNonPpapiError(PP_NACL_ERROR_PNACL_CACHE_FETCH_OTHER,
                         "Failed to open translated nexe.");
     return;
   }
 
   translate_notify_callback_.Run(PP_OK);
 }
 
 void PnaclCoordinator::OpenBitcodeStream() {
   // Even though we haven't started downloading, create the translation
@@ skipping 15 matching lines @@
 
 void PnaclCoordinator::BitcodeStreamCacheHit(PP_FileHandle handle) {
   if (handle == PP_kInvalidFileHandle) {
     ReportNonPpapiError(
         PP_NACL_ERROR_PNACL_CREATE_TEMP,
         std::string(
             "PnaclCoordinator: Got bad temp file handle from GetNexeFd"));
     BitcodeStreamDidFinish(PP_ERROR_FAILED);
     return;
   }
-  temp_nexe_file_.reset(new TempFile(plugin_, handle));
-  // Open it for reading as the cached nexe file.
+  temp_nexe_file_ = base::File(handle);
   NexeReadDidOpen();
 }
 
 void PnaclCoordinator::BitcodeStreamCacheMiss(int64_t expected_pexe_size,
                                               PP_FileHandle nexe_handle) {
   // IMPORTANT: Make sure that PnaclResources::StartLoad() is only
   // called after you receive a response to a request for a .pexe file.
   //
   // The component updater's resource throttles + OnDemand update/install
   // should block the URL request until the compiler is present. Now we
@@ skipping 15 matching lines @@
         PP_NACL_ERROR_PNACL_RESOURCE_FETCH,
         std::string("The Portable Native Client (pnacl) component is not "
                      "installed. Please consult chrome://components for more "
                       "information."));
     return;
   }
 
   expected_pexe_size_ = expected_pexe_size;
 
   for (int i = 0; i < split_module_count_; i++) {
-    PP_FileHandle obj_handle =
-        plugin_->nacl_interface()->CreateTemporaryFile(plugin_->pp_instance());
-    scoped_ptr<TempFile> temp_file(new TempFile(plugin_, obj_handle));
-    if (!temp_file->IsValid()) {
+    base::File temp_file(
+        plugin_->nacl_interface()->CreateTemporaryFile(plugin_->pp_instance()));
+    if (!temp_file.IsValid()) {
       ReportNonPpapiError(PP_NACL_ERROR_PNACL_CREATE_TEMP,
                           "Failed to open scratch object file.");
       return;
-    } else {
-      obj_files_.push_back(temp_file.release());
     }
+    obj_files_.push_back(std::move(temp_file));
   }
 
-  temp_nexe_file_.reset(new TempFile(plugin_, nexe_handle));
+  temp_nexe_file_ = base::File(nexe_handle);
   // Open the nexe file for connecting ld and sel_ldr.
   // Start translation when done with this last step of setup!
-  if (!temp_nexe_file_->IsValid()) {
+  if (!temp_nexe_file_.IsValid()) {
     ReportNonPpapiError(
         PP_NACL_ERROR_PNACL_CREATE_TEMP,
         std::string(
             "PnaclCoordinator: Got bad temp file handle from writing nexe"));
     return;
   }
   LoadCompiler();
 }
 
 void PnaclCoordinator::BitcodeStreamGotData(const void* data, int32_t length) {
@@ skipping 106 matching lines @@
 
   // Invoke llc followed by ld off the main thread.  This allows use of
   // blocking RPCs that would otherwise block the JavaScript main thread.
   pp::CompletionCallback report_translate_finished =
       callback_factory_.NewCallback(&PnaclCoordinator::TranslateFinished);
   pp::CompletionCallback compile_finished =
       callback_factory_.NewCallback(&PnaclCoordinator::LoadLinker);
   CHECK(translate_thread_ != NULL);
   translate_thread_->SetupState(
       report_translate_finished, &compiler_subprocess_, &ld_subprocess_,
-      &obj_files_, num_threads_, temp_nexe_file_.get(),
+      &obj_files_, num_threads_, &temp_nexe_file_,
       &error_info_, &pnacl_options_, architecture_attributes_, this);
   translate_thread_->RunCompile(compile_finished);
 }
 
 void PnaclCoordinator::LoadLinker(int32_t pp_error) {
   PLUGIN_PRINTF(
       ("PnaclCoordinator::LoadLinker (pp_error=%" NACL_PRId32 ")\n", pp_error));
   // Errors in the previous step would have skipped to TranslateFinished
   // so we only expect PP_OK here.
   DCHECK(pp_error == PP_OK);
@@ skipping 19 matching lines @@
         "PnaclCoordinator: Linker process could not be created.");
     return;
   }
   GetNaClInterface()->LogTranslateTime(
       "NaCl.Perf.PNaClLoadTime.LoadLinker",
       NaClGetTimeOfDayMicroseconds() - ld_load_start_time);
   translate_thread_->RunLink();
 }
 
 }  // namespace plugin