PNaCl cleanup: Simplify error checking when opening temp files

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>
 
@@ skipping 129 matching lines @@
 }
 
 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();
 }
 
-void PnaclCoordinator::ReportPpapiError(PP_NaClError err_code,
-                                        int32_t pp_error,
-                                        const std::string& message) {
-  std::stringstream ss;
-  ss << "PnaclCoordinator: " << message << " (pp_error=" << pp_error << ").";
-  ErrorInfo error_info;
-  error_info.SetReport(err_code, ss.str());
-  plugin_->ReportLoadError(error_info);
-  ExitWithError();
-}
-
 void PnaclCoordinator::ExitWithError() {
   PLUGIN_PRINTF(("PnaclCoordinator::ExitWithError\n"));
   // Free all the intermediate callbacks we ever created.
   // Note: this doesn't *cancel* the callbacks from the factories attached
   // to the various helper classes (e.g., pnacl_resources). Thus, those
   // callbacks may still run asynchronously.  We let those run but ignore
   // any other errors they may generate so that they do not end up running
   // translate_notify_callback_, which has already been freed.
   callback_factory_.CancelAll();
   if (!error_already_reported_) {
@@ skipping 35 matching lines @@
   temp_nexe_file_->Reset();
 
   // 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(PP_OK);
+  NexeReadDidOpen(true);
 }
 
-void PnaclCoordinator::NexeReadDidOpen(int32_t pp_error) {
-  PLUGIN_PRINTF(("PnaclCoordinator::NexeReadDidOpen (pp_error=%"
-                 NACL_PRId32 ")\n", pp_error));
-  if (pp_error != PP_OK) {
-    if (pp_error == PP_ERROR_FILENOTFOUND) {
-      ReportPpapiError(PP_NACL_ERROR_PNACL_CACHE_FETCH_NOTFOUND,
-                       pp_error,
-                       "Failed to open translated nexe (not found).");
-      return;
-    }
-    if (pp_error == PP_ERROR_NOACCESS) {
-      ReportPpapiError(PP_NACL_ERROR_PNACL_CACHE_FETCH_NOACCESS,
-                       pp_error,
-                       "Failed to open translated nexe (no access).");
-      return;
-    }
-    ReportPpapiError(PP_NACL_ERROR_PNACL_CACHE_FETCH_OTHER,
-                     pp_error,
-                     "Failed to open translated nexe.");
+void PnaclCoordinator::NexeReadDidOpen(bool success) {
+  if (!success) {

[bbudge, 2016/01/20 21:25:57]

Could you just test temp_nexe_file_->IsValid() here and avoid the parameter
altogether?

[Mark Seaborn, 2016/01/20 21:49:47]

Good point!  Done.

+    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
   // thread object immediately. This ensures that any pieces of the file
   // that get downloaded before the compilation thread is accepting
@@ skipping 15 matching lines @@
   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.
-  NexeReadDidOpen(temp_nexe_file_->CheckValidity());
+  NexeReadDidOpen(temp_nexe_file_->IsValid());
 }
 
 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
   // can load the resources (e.g. llc and ld nexes).
@@ skipping 17 matching lines @@
                       "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));
-    int32_t pp_error = temp_file->CheckValidity();
-    if (pp_error != PP_OK) {
-      ReportPpapiError(PP_NACL_ERROR_PNACL_CREATE_TEMP,
-                       pp_error,
-                       "Failed to open scratch object file.");
+    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());
     }
   }
 
   temp_nexe_file_.reset(new TempFile(plugin_, nexe_handle));
   // Open the nexe file for connecting ld and sel_ldr.
   // Start translation when done with this last step of setup!
-  int32_t pp_error = temp_nexe_file_->CheckValidity();
-  if (pp_error != PP_OK) {
+  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 146 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