Add an interface for nacl to create delete-on-close temp files,

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 "native_client/src/trusted/plugin/pnacl_coordinator.h"
 
 #include <utility>
 #include <vector>
 
 #include "native_client/src/include/portability_io.h"
 #include "native_client/src/shared/platform/nacl_check.h"
 #include "native_client/src/trusted/plugin/local_temp_file.h"
 #include "native_client/src/trusted/plugin/manifest.h"
 #include "native_client/src/trusted/plugin/plugin.h"
 #include "native_client/src/trusted/plugin/plugin_error.h"
 #include "native_client/src/trusted/plugin/pnacl_streaming_translate_thread.h"
 #include "native_client/src/trusted/plugin/pnacl_translate_thread.h"
 #include "native_client/src/trusted/plugin/service_runtime.h"
+#include "native_client/src/trusted/plugin/temporary_file.h"
 #include "native_client/src/trusted/service_runtime/include/sys/stat.h"
 
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/ppb_file_io.h"
 #include "ppapi/cpp/file_io.h"
 
 namespace {
 const char kPnaclTempDir[] = "/.pnacl";
 }
 
@@ skipping 268 matching lines @@
   // Save the translate error code, and inspect after cleaning up junk files.
   // Note: If there was a surfaway and the file objects were actually
   // destroyed, then we are in trouble since the obj_file_, nexe_file_,
   // etc. may have been destroyed.
   // TODO(jvoung,sehr): Fix.
   // If there was an error already set (e.g. pexe load failure) then we want
   // to use the first one, (which might be something useful) rather than
   // the one from the compiler, (which is always just PP_ERROR_FAILED)
   if (translate_finish_error_ == PP_OK) translate_finish_error_ = pp_error;
 
-  // Close the object temporary file (regardless of error code).
-  pp::CompletionCallback cb =
-      callback_factory_.NewCallback(&PnaclCoordinator::ObjectFileWasClosed);
-  obj_file_->Close(cb);
-}
-
-void PnaclCoordinator::ObjectFileWasClosed(int32_t pp_error) {
-  PLUGIN_PRINTF(("PnaclCoordinator::ObjectFileWasClosed (pp_error=%"
-                 NACL_PRId32")\n", pp_error));
-  if (pp_error != PP_OK) {
-    ReportPpapiError(pp_error);
-    return;
-  }
-  // Delete the object temporary file.
-  pp::CompletionCallback cb =
-      callback_factory_.NewCallback(&PnaclCoordinator::ObjectFileWasDeleted);
-  obj_file_->Delete(cb);
-}
-
-void PnaclCoordinator::ObjectFileWasDeleted(int32_t pp_error) {
-  PLUGIN_PRINTF(("PnaclCoordinator::ObjectFileWasDeleted (pp_error=%"
-                 NACL_PRId32")\n", pp_error));
-  if (pp_error != PP_OK) {
-    ReportPpapiError(pp_error);
-    return;
-  }
   // Close the nexe temporary file.
   if (nexe_file_ != NULL) {
     pp::CompletionCallback cb =
       callback_factory_.NewCallback(&PnaclCoordinator::NexeFileWasClosed);
     nexe_file_->Close(cb);
   }
 }
 
 void PnaclCoordinator::NexeFileWasClosed(int32_t pp_error) {
   PLUGIN_PRINTF(("PnaclCoordinator::NexeFileWasClosed (pp_error=%"
@@ skipping 124 matching lines @@
   // is accepting SRPCs won't get dropped.
   translate_thread_.reset(new PnaclStreamingTranslateThread());
   if (translate_thread_ == NULL) {
     ReportNonPpapiError("could not allocate translation thread.");
     return;
   }
   // In the streaming case we also want to open the object file now so the
   // translator can start writing to it during streaming translation.
   // In the non-streaming case this can wait until the bitcode download is
   // finished.
-  obj_file_.reset(new LocalTempFile(plugin_, file_system_.get(),
-                                    nacl::string(kPnaclTempDir)));
+  obj_file_.reset(new TempFile(plugin_));
   pp::CompletionCallback obj_cb =
-      callback_factory_.NewCallback(&PnaclCoordinator::ObjectWriteDidOpen);
-  obj_file_->OpenWrite(obj_cb);
+    callback_factory_.NewCallback(&PnaclCoordinator::ObjectFileDidOpen);
+  obj_file_->Open(obj_cb);
 
   streaming_downloader_.reset(new FileDownloader());
   streaming_downloader_->Initialize(plugin_);
   pp::CompletionCallback cb =
       callback_factory_.NewCallback(
           &PnaclCoordinator::BitcodeStreamDidFinish);
 
   // TODO(dschuff): need to use url_util_->ResolveRelativeToURL?
   if (!streaming_downloader_->OpenStream(pexe_url_, cb, this)) {
     ReportNonPpapiError(nacl::string("failed to open stream ") + pexe_url_);
@@ skipping 22 matching lines @@
     static_cast<PnaclStreamingTranslateThread*>(translate_thread_.get());
   DCHECK(thread);
   thread->PutBytes(data, pp_error);
 }
 
 StreamCallback PnaclCoordinator::GetCallback() {
   return callback_factory_.NewCallbackWithOutput(
       &PnaclCoordinator::BitcodeStreamGotData);
 }
 
-void PnaclCoordinator::ObjectWriteDidOpen(int32_t pp_error) {
-  PLUGIN_PRINTF(("PnaclCoordinator::ObjectWriteDidOpen (pp_error=%"
+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_error);
     return;
-  }
-  pp::CompletionCallback cb =
-      callback_factory_.NewCallback(&PnaclCoordinator::ObjectReadDidOpen);
-  obj_file_->OpenRead(cb);
-}
-
-void PnaclCoordinator::ObjectReadDidOpen(int32_t pp_error) {
-  PLUGIN_PRINTF(("PnaclCoordinator::ObjectReadDidOpen (pp_error=%"
-                 NACL_PRId32")\n", pp_error));
-  if (pp_error != PP_OK) {
-    ReportPpapiError(pp_error);
-    return;
-  }
+  } 
   // Create the nexe file for connecting ld and sel_ldr.
   // Start translation when done with this last step of setup!
   nexe_file_.reset(new LocalTempFile(plugin_, file_system_.get(),
                                      nacl::string(kPnaclTempDir)));
   pp::CompletionCallback cb =
       callback_factory_.NewCallback(&PnaclCoordinator::RunTranslate);
   nexe_file_->OpenWrite(cb);
 }
 
 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_.get(),
                                   ld_manifest_.get(),
                                   obj_file_.get(),
                                   nexe_file_.get(),
                                   &error_info_,
                                   resources_.get(),
                                   plugin_);
 }
 
 }  // namespace plugin