Pepper: Small cleanup in PNaClCoordinator.

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 89 matching lines @@
     const PP_PNaClOptions& pnacl_options,
     const pp::CompletionCallback& translate_notify_callback)
   : translate_finish_error_(PP_OK),
     plugin_(plugin),
     translate_notify_callback_(translate_notify_callback),
     translation_finished_reported_(false),
     pexe_url_(pexe_url),
     pnacl_options_(pnacl_options),
     architecture_attributes_(GetArchitectureAttributes(plugin)),
     split_module_count_(1),
-    num_object_files_opened_(0),
     is_cache_hit_(PP_FALSE),
     error_already_reported_(false),
     pnacl_init_time_(0),
     pexe_size_(0),
     pexe_bytes_compiled_(0),
     expected_pexe_size_(-1) {
   PLUGIN_PRINTF(("PnaclCoordinator::PnaclCoordinator (this=%p, plugin=%p)\n",
                  static_cast<void*>(this), static_cast<void*>(plugin)));
   callback_factory_.Initialize(this);
 }
 
 PnaclCoordinator::~PnaclCoordinator() {
   PLUGIN_PRINTF(("PnaclCoordinator::~PnaclCoordinator (this=%p, "
                  "translate_thread=%p\n",
                  static_cast<void*>(this), translate_thread_.get()));
   // Stopping the translate thread will cause the translate thread to try to
   // run translation_complete_callback_ on the main thread.  This destructor is
   // running from the main thread, and by the time it exits, callback_factory_
   // will have been destroyed.  This will result in the cancellation of
   // translation_complete_callback_, so no notification will be delivered.
-  if (translate_thread_.get() != NULL) {
+  if (translate_thread_.get() != NULL)
     translate_thread_->AbortSubprocesses();
-  }
   if (!translation_finished_reported_) {
     plugin_->nacl_interface()->ReportTranslationFinished(
         plugin_->pp_instance(),
         PP_FALSE, 0, 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);
-  // TODO(jvoung): use base/memory/scoped_vector.h to hold obj_files_.
-  for (int i = 0; i < num_object_files_opened_; i++) {
+  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();
 }
 
 void PnaclCoordinator::ReportNonPpapiError(PP_NaClError err_code,
                                            const nacl::string& message) {
   ErrorInfo error_info;
@@ skipping 238 matching lines @@
 
   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.
     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_));
-      int32_t pp_error = obj_files_[i]->Open(true);
+      nacl::scoped_ptr<TempFile> temp_file(new TempFile(plugin_));
+      int32_t pp_error = temp_file->Open(true);
       if (pp_error != PP_OK) {
         ReportPpapiError(PP_NACL_ERROR_PNACL_CREATE_TEMP,
                          pp_error,
                          "Failed to open scratch object file.");
+        return;
       } else {
-        num_object_files_opened_++;
+        obj_files_.push_back(temp_file.release());
       }
     }
     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 BeginStreaming 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_->BeginStreaming(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));
-    }
+    // 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 95 matching lines @@
                                   invalid_desc_wrapper_.get(),
                                   &error_info_,
                                   resources_.get(),
                                   &pnacl_options_,
                                   architecture_attributes_,
                                   this,
                                   plugin_);
 }
 
 }  // namespace plugin