Pepper: TempFile cleanup.

ppapi/native_client/src/trusted/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 "ppapi/native_client/src/trusted/plugin/pnacl_coordinator.h"
 
 #include <utility>
 #include <vector>
 
 #include "native_client/src/include/checked_cast.h"
@@ skipping 181 matching lines @@
   // 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);
   // TODO(jvoung): use base/memory/scoped_vector.h to hold obj_files_.
   for (int i = 0; i < num_object_files_opened_; i++) {
     delete obj_files_[i];
   }
 }
 
-nacl::DescWrapper* PnaclCoordinator::ReleaseTranslatedFD() {
+PP_FileHandle PnaclCoordinator::TakeTranslatedFileHandle() {
   DCHECK(temp_nexe_file_ != NULL);
-  return temp_nexe_file_->release_read_wrapper();
+  return temp_nexe_file_->TakeFileHandle();
 }
 
 void PnaclCoordinator::ReportNonPpapiError(PP_NaClError err_code,
                                            const nacl::string& message) {
   ErrorInfo error_info;
   error_info.SetReport(err_code, message);
   plugin_->ReportLoadError(error_info);
   ExitWithError();
 }
 
@@ skipping 218 matching lines @@
           temp_nexe_file_->existing_handle(),
           cb.pp_completion_callback());
   if (nexe_fd_err < PP_OK_COMPLETIONPENDING) {
     ReportPpapiError(PP_NACL_ERROR_PNACL_CREATE_TEMP, nexe_fd_err,
                      nacl::string("Call to GetNexeFd failed"));
   }
 }
 
 void PnaclCoordinator::NexeFdDidOpen(int32_t pp_error) {
   PLUGIN_PRINTF(("PnaclCoordinator::NexeFdDidOpen (pp_error=%"
-                 NACL_PRId32 ", hit=%d, handle=%d)\n", pp_error,
-                 is_cache_hit_ == PP_TRUE,
-                 *temp_nexe_file_->existing_handle()));
+                 NACL_PRId32 ", hit=%d)\n", pp_error,
+                 is_cache_hit_ == PP_TRUE));
   if (pp_error < PP_OK) {
     ReportPpapiError(PP_NACL_ERROR_PNACL_CREATE_TEMP, pp_error,
                      nacl::string("GetNexeFd failed"));
     return;
   }
 
   if (*temp_nexe_file_->existing_handle() == PP_kInvalidFileHandle) {
     ReportNonPpapiError(
         PP_NACL_ERROR_PNACL_CREATE_TEMP,
         nacl::string(
             "PnaclCoordinator: Got bad temp file handle from GetNexeFd"));
     return;
   }
   HistogramEnumerateTranslationCache(plugin_->uma_interface(), is_cache_hit_);
 
   if (is_cache_hit_ == PP_TRUE) {
     // Cache hit -- no need to stream the rest of the file.
     streaming_downloader_.reset(NULL);
     // Open it for reading as the cached nexe file.
-    pp::CompletionCallback cb =
-        callback_factory_.NewCallback(&PnaclCoordinator::NexeReadDidOpen);
-    temp_nexe_file_->Open(cb, false);
+    NexeReadDidOpen(temp_nexe_file_->Open(false));
   } else {
     // Open an object file first so the translator can start writing to it
     // during streaming translation.
     for (int i = 0; i < split_module_count_; i++) {
       obj_files_.push_back(new TempFile(plugin_));
-
-      pp::CompletionCallback obj_cb =
-          callback_factory_.NewCallback(&PnaclCoordinator::ObjectFileDidOpen);
-      obj_files_[i]->Open(obj_cb, true);
+      int32_t pp_error = obj_files_[i]->Open(true);
+      if (pp_error != PP_OK) {
+        ReportPpapiError(PP_NACL_ERROR_PNACL_CREATE_TEMP,
+                         pp_error,
+                         "Failed to open scratch object file.");
+      } else {
+        num_object_files_opened_++;
+      }
     }
     invalid_desc_wrapper_.reset(plugin_->wrapper_factory()->MakeInvalid());
 
     // Meanwhile, a miss means we know we need to stream the bitcode, so stream
     // the rest of it now. (Calling FinishStreaming means that the downloader
     // will begin handing data to the coordinator, which is safe any time after
     // the translate_thread_ object has been initialized).
     pp::CompletionCallback finish_cb = callback_factory_.NewCallback(
         &PnaclCoordinator::BitcodeStreamDidFinish);
     streaming_downloader_->FinishStreaming(finish_cb);
+
+    if (num_object_files_opened_ == split_module_count_) {
+      // Open the nexe file for connecting ld and sel_ldr.
+      // Start translation when done with this last step of setup!
+      RunTranslate(temp_nexe_file_->Open(true));
+    }
   }
 }
 
 void PnaclCoordinator::BitcodeStreamDidFinish(int32_t pp_error) {
   PLUGIN_PRINTF(("PnaclCoordinator::BitcodeStreamDidFinish (pp_error=%"
                  NACL_PRId32 ")\n", pp_error));
   if (pp_error != PP_OK) {
     // Defer reporting the error and cleanup until after the translation
     // thread returns, because it may be accessing the coordinator's
     // objects or writing to the files.
@@ skipping 86 matching lines @@
                                        event_name,
                                        microsecs);
 }
 
 void PnaclCoordinator::GetCurrentProgress(int64_t* bytes_loaded,
                                           int64_t* bytes_total) {
   *bytes_loaded = pexe_bytes_compiled_;
   *bytes_total = expected_pexe_size_;
 }
 
-void PnaclCoordinator::ObjectFileDidOpen(int32_t pp_error) {
-  PLUGIN_PRINTF(("PnaclCoordinator::ObjectFileDidOpen (pp_error=%"
-                 NACL_PRId32 ")\n", pp_error));
-  if (pp_error != PP_OK) {
-    ReportPpapiError(PP_NACL_ERROR_PNACL_CREATE_TEMP,
-                     pp_error,
-                     "Failed to open scratch object file.");
-    return;
-  }
-  num_object_files_opened_++;
-  if (num_object_files_opened_ == split_module_count_) {
-    // Open the nexe file for connecting ld and sel_ldr.
-    // Start translation when done with this last step of setup!
-    pp::CompletionCallback cb =
-        callback_factory_.NewCallback(&PnaclCoordinator::RunTranslate);
-    temp_nexe_file_->Open(cb, true);
-  }
-}
-
 void PnaclCoordinator::RunTranslate(int32_t pp_error) {
   PLUGIN_PRINTF(("PnaclCoordinator::RunTranslate (pp_error=%"
                  NACL_PRId32 ")\n", pp_error));
   // 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);
 
   CHECK(translate_thread_ != NULL);
   translate_thread_->RunTranslate(report_translate_finished,
                                   manifest_id_,
                                   &obj_files_,
                                   temp_nexe_file_.get(),
                                   invalid_desc_wrapper_.get(),
                                   &error_info_,
                                   resources_.get(),
                                   &pnacl_options_,
                                   architecture_attributes_,
                                   this,
                                   plugin_);
 }
 
 }  // namespace plugin