Make inttypes.h and similar macro usage C++11-friendly.

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 323 matching lines @@
     translate_notify_callback_.Run(PP_ERROR_FAILED);
   } else {
     PLUGIN_PRINTF(("PnaclCoordinator::ExitWithError an earlier error was "
                    "already reported -- Skipping.\n"));
   }
 }
 
 // Signal that Pnacl translation completed normally.
 void PnaclCoordinator::TranslateFinished(int32_t pp_error) {
   PLUGIN_PRINTF(("PnaclCoordinator::TranslateFinished (pp_error=%"
-                 NACL_PRId32")\n", pp_error));
+                 NACL_PRId32 ")\n", pp_error));
   // Bail out if there was an earlier error (e.g., pexe load failure).
   if (translate_finish_error_ != PP_OK) {
     ExitWithError();
     return;
   }
   // Bail out if there is an error from the translation thread.
   if (pp_error != PP_OK) {
     ExitWithError();
     return;
   }
@@ skipping 113 matching lines @@
   char buf[kCopyBufSize];
   int32_t num_read =
     nacl::assert_cast<int32_t>(read_wrapper->Read(buf, sizeof buf));
   // Hit EOF or something.
   if (num_read == 0) {
     NexeWasCopiedToCache(PP_OK);
     return;
   }
   if (num_read < 0) {
     PLUGIN_PRINTF(("PnaclCoordinator::CachedNexeOpenedForWrite read failed "
-                   "(error=%"NACL_PRId32")\n", num_read));
+                   "(error=%" NACL_PRId32 ")\n", num_read));
     NexeWasCopiedToCache(PP_ERROR_FAILED);
     return;
   }
   pp::CompletionCallback cb = callback_factory_.NewCallback(
       &PnaclCoordinator::DidCopyNexeToCachePartial, num_read, cur_offset);
   cached_nexe_file_->write_file_io()->Write(cur_offset, buf, num_read, cb);
 }
 
 void PnaclCoordinator::DidCopyNexeToCachePartial(int32_t pp_error,
                                                  int32_t num_read_prev,
                                                  int64_t cur_offset) {
   PLUGIN_PRINTF(("PnaclCoordinator::DidCopyNexeToCachePartial "
-                 "(pp_error=%"NACL_PRId32", num_read_prev=%"NACL_PRId32""
-                 ", cur_offset=%"NACL_PRId64").\n",
+                 "(pp_error=%" NACL_PRId32 ", num_read_prev=%" NACL_PRId32
+                 ", cur_offset=%" NACL_PRId64 ").\n",
                  pp_error, num_read_prev, cur_offset));
   // Assume we are done.
   if (pp_error == PP_OK) {
     NexeWasCopiedToCache(PP_OK);
     return;
   }
   if (pp_error < PP_OK) {
     PLUGIN_PRINTF(("PnaclCoordinator::DidCopyNexeToCachePartial failed (err=%"
-                   NACL_PRId32")\n", pp_error));
+                   NACL_PRId32 ")\n", pp_error));
     NexeWasCopiedToCache(pp_error);
     return;
   }
 
   // Check if we wrote as much as we read.
   nacl::DescWrapper* read_wrapper = temp_nexe_file_->read_wrapper();
   if (pp_error != num_read_prev) {
     PLUGIN_PRINTF(("PnaclCoordinator::DidCopyNexeToCachePartial partial "
-                   "write (bytes_written=%"NACL_PRId32" vs "
-                   "read=%"NACL_PRId32")\n", pp_error, num_read_prev));
+                   "write (bytes_written=%" NACL_PRId32 " vs "
+                   "read=%" NACL_PRId32 ")\n", pp_error, num_read_prev));
     CHECK(pp_error < num_read_prev);
     // Seek back to re-read the bytes that were not written.
     nacl_off64_t seek_result =
         read_wrapper->Seek(pp_error - num_read_prev, SEEK_CUR);
     if (seek_result < 0) {
       PLUGIN_PRINTF(("PnaclCoordinator::DidCopyNexeToCachePartial seek failed "
-                     "(err=%"NACL_PRId64")\n", seek_result));
+                     "(err=%" NACL_PRId64 ")\n", seek_result));
       NexeWasCopiedToCache(PP_ERROR_FAILED);
       return;
     }
   }
 
   int64_t next_offset = cur_offset + pp_error;
   char buf[kCopyBufSize];
   int32_t num_read =
     nacl::assert_cast<int32_t>(read_wrapper->Read(buf, sizeof buf));
   PLUGIN_PRINTF(("PnaclCoordinator::DidCopyNexeToCachePartial read (bytes=%"
-                 NACL_PRId32")\n", num_read));
+                 NACL_PRId32 ")\n", num_read));
   // Hit EOF or something.
   if (num_read == 0) {
     NexeWasCopiedToCache(PP_OK);
     return;
   }
   if (num_read < 0) {
     PLUGIN_PRINTF(("PnaclCoordinator::DidCopyNexeToCachePartial read failed "
-                   "(error=%"NACL_PRId32")\n", num_read));
+                   "(error=%" NACL_PRId32 ")\n", num_read));
     NexeWasCopiedToCache(PP_ERROR_FAILED);
     return;
   }
   pp::CompletionCallback cb = callback_factory_.NewCallback(
       &PnaclCoordinator::DidCopyNexeToCachePartial, num_read, next_offset);
   PLUGIN_PRINTF(("PnaclCoordinator::CopyNexeToCache Writing ("
-                 "bytes=%"NACL_PRId32", buf=%p, file_io=%p)\n", num_read, buf,
+                 "bytes=%" NACL_PRId32 ", buf=%p, file_io=%p)\n", num_read, buf,
                  cached_nexe_file_->write_file_io()));
   cached_nexe_file_->write_file_io()->Write(next_offset, buf, num_read, cb);
 }
 
 void PnaclCoordinator::NexeWasCopiedToCache(int32_t pp_error) {
   if (pp_error != PP_OK) {
     // Try to delete the partially written not-yet-committed cache file before
     // returning. We pass the current pp_error along so that it can be reported
     // before returning.
     pp::CompletionCallback cb = callback_factory_.NewCallback(
         &PnaclCoordinator::CorruptCacheFileWasDeleted, pp_error);
     cached_nexe_file_->Delete(cb);
     return;
   }
   // Rename the cached_nexe_file_ file to the cache id, to finalize.
   pp::CompletionCallback cb =
       callback_factory_.NewCallback(&PnaclCoordinator::NexeFileWasRenamed);
   cached_nexe_file_->Rename(pnacl_options_.GetCacheKey(), cb);
 }
 
 void PnaclCoordinator::CorruptCacheFileWasDeleted(int32_t delete_pp_error,
                                                   int32_t orig_pp_error) {
   if (delete_pp_error != PP_OK) {
     // The cache file was certainly already opened by the time we tried
     // to write to it, so it should certainly be deletable.
     PLUGIN_PRINTF(("PnaclCoordinator::CorruptCacheFileWasDeleted "
-                   "delete failed with pp_error=%"NACL_PRId32"\n",
+                   "delete failed with pp_error=%" NACL_PRId32 "\n",
                    delete_pp_error));
     // fall through and report the original error.
   }
   // Report the original error that caused us to consider the
   // cache file corrupted.
   if (orig_pp_error == PP_ERROR_NOQUOTA) {
     ReportPpapiError(ERROR_PNACL_CACHE_FINALIZE_COPY_NOQUOTA,
                      orig_pp_error,
                      "Failed to copy translated nexe to cache (no quota).");
     return;
   }
   if (orig_pp_error == PP_ERROR_NOSPACE) {
     ReportPpapiError(ERROR_PNACL_CACHE_FINALIZE_COPY_NOSPACE,
                      orig_pp_error,
                      "Failed to copy translated nexe to cache (no space).");
       return;
   }
   ReportPpapiError(ERROR_PNACL_CACHE_FINALIZE_COPY_OTHER,
                    orig_pp_error,
                    "Failed to copy translated nexe to cache.");
   return;
 }
 
 void PnaclCoordinator::NexeFileWasRenamed(int32_t pp_error) {
   PLUGIN_PRINTF(("PnaclCoordinator::NexeFileWasRenamed (pp_error=%"
-                 NACL_PRId32")\n", pp_error));
+                 NACL_PRId32 ")\n", pp_error));
   if (pp_error != PP_OK) {
     if (pp_error == PP_ERROR_NOACCESS) {
       ReportPpapiError(ERROR_PNACL_CACHE_FINALIZE_RENAME_NOACCESS,
                        pp_error,
                        "Failed to finalize cached translation (no access).");
       return;
     } else if (pp_error != PP_ERROR_FILEEXISTS) {
       ReportPpapiError(ERROR_PNACL_CACHE_FINALIZE_RENAME_OTHER,
                        pp_error,
                        "Failed to finalize cached translation.");
@@ skipping 20 matching lines @@
                     total_time / 1000000.0);
 
   // Open the cache file for reading.
   pp::CompletionCallback cb =
       callback_factory_.NewCallback(&PnaclCoordinator::NexeReadDidOpen);
   cached_nexe_file_->OpenRead(cb);
 }
 
 void PnaclCoordinator::NexeReadDidOpen(int32_t pp_error) {
   PLUGIN_PRINTF(("PnaclCoordinator::NexeReadDidOpen (pp_error=%"
-                 NACL_PRId32")\n", pp_error));
+                 NACL_PRId32 ")\n", pp_error));
   if (pp_error != PP_OK) {
     if (pp_error == PP_ERROR_FILENOTFOUND) {
       ReportPpapiError(ERROR_PNACL_CACHE_FETCH_NOTFOUND,
                        pp_error,
                        "Failed to open translated nexe (not found).");
       return;
     }
     if (pp_error == PP_ERROR_NOACCESS) {
       ReportPpapiError(ERROR_PNACL_CACHE_FETCH_NOACCESS,
                        pp_error,
@@ skipping 10 matching lines @@
   if (cached_nexe_file_ != NULL) {
     translated_fd_.reset(cached_nexe_file_->release_read_wrapper());
   } else {
     translated_fd_.reset(temp_nexe_file_->release_read_wrapper());
   }
   translate_notify_callback_.Run(pp_error);
 }
 
 void PnaclCoordinator::ResourceInfoWasRead(int32_t pp_error) {
   PLUGIN_PRINTF(("PluginCoordinator::ResourceInfoWasRead (pp_error=%"
-                NACL_PRId32")\n", pp_error));
+                NACL_PRId32 ")\n", pp_error));
   // Second step of loading resources: call StartLoad.
   pp::CompletionCallback resources_cb =
       callback_factory_.NewCallback(&PnaclCoordinator::ResourcesDidLoad);
   resources_->StartLoad(resources_cb);
 }
 
 void PnaclCoordinator::ResourcesDidLoad(int32_t pp_error) {
   PLUGIN_PRINTF(("PnaclCoordinator::ResourcesDidLoad (pp_error=%"
-                 NACL_PRId32")\n", pp_error));
+                 NACL_PRId32 ")\n", pp_error));
   if (pp_error != PP_OK) {
     // Finer-grained error code should have already been reported by
     // the PnaclResources class.
     return;
   }
 
   if (!off_the_record_) {
     if (use_new_cache_) {
       OpenBitcodeStream();
     } else {
@@ skipping 21 matching lines @@
       }
     }
   } else {
     // We don't have a cache, so do the non-cached codepath.
     OpenBitcodeStream();
   }
 }
 
 void PnaclCoordinator::FileSystemDidOpen(int32_t pp_error) {
   PLUGIN_PRINTF(("PnaclCoordinator::FileSystemDidOpen (pp_error=%"
-                 NACL_PRId32")\n", pp_error));
+                 NACL_PRId32 ")\n", pp_error));
   if (pp_error != PP_OK) {
     if (pp_error == PP_ERROR_NOACCESS) {
       ReportPpapiError(
           ERROR_PNACL_CACHE_OPEN_NOACCESS,
           pp_error,
           "File system for PNaCl translation cache failed to open "
           "(no access).");
       return;
     }
     if (pp_error == PP_ERROR_NOQUOTA) {
@@ skipping 18 matching lines @@
   }
   dir_ref_.reset(new pp::FileRef(*file_system_, kPnaclTempDir));
   // Attempt to create the directory.
   pp::CompletionCallback cb =
       callback_factory_.NewCallback(&PnaclCoordinator::DirectoryWasCreated);
   dir_ref_->MakeDirectory(cb);
 }
 
 void PnaclCoordinator::DirectoryWasCreated(int32_t pp_error) {
   PLUGIN_PRINTF(("PnaclCoordinator::DirectoryWasCreated (pp_error=%"
-                 NACL_PRId32")\n", pp_error));
+                 NACL_PRId32 ")\n", pp_error));
   if (pp_error != PP_ERROR_FILEEXISTS && pp_error != PP_OK) {
     // Directory did not exist and could not be created.
     if (pp_error == PP_ERROR_NOACCESS) {
       ReportPpapiError(
           ERROR_PNACL_CACHE_DIRECTORY_CREATE,
           pp_error,
           "PNaCl translation cache directory creation/check failed "
           "(no access).");
       return;
     }
@@ skipping 101 matching lines @@
       cached_nexe_file_->OpenRead(cb);
     }
   } else {
     // No cache case.
     CachedFileDidOpen(PP_ERROR_FAILED);
   }
 }
 
 void PnaclCoordinator::NexeFdDidOpen(int32_t pp_error) {
   PLUGIN_PRINTF(("PnaclCoordinator::NexeFdDidOpen (pp_error=%"
-                 NACL_PRId32", hit=%d, handle=%d)\n", pp_error,
+                 NACL_PRId32 ", hit=%d, handle=%d)\n", pp_error,
                  is_cache_hit_ == PP_TRUE,
                  nexe_handle_));
   if (pp_error < PP_OK) {
     ReportPpapiError(ERROR_PNACL_CREATE_TEMP, pp_error,
                      nacl::string("GetNexeFd failed"));
     return;
   }
   temp_nexe_file_.reset(new TempFile(plugin_));
   if (!temp_nexe_file_->SetExistingFd(nexe_handle_)) {
     ReportNonPpapiError(
@@ skipping 24 matching lines @@
     // 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);
   }
 }
 
 void PnaclCoordinator::CachedFileDidOpen(int32_t pp_error) {
   PLUGIN_PRINTF(("PnaclCoordinator::CachedFileDidOpen (pp_error=%"
-                 NACL_PRId32")\n", pp_error));
+                 NACL_PRId32 ")\n", pp_error));
   if (pp_error == PP_OK) {
     // Cache hit -- no need to stream the rest of the file.
     streaming_downloader_.reset(NULL);
     HistogramEnumerateTranslationCache(true);
     NexeReadDidOpen(PP_OK);
     return;
   }
   // Otherwise, the cache file is missing so we must translate.
   HistogramEnumerateTranslationCache(false);
 
   // Continue streaming.
   pp::CompletionCallback cb =
       callback_factory_.NewCallback(&PnaclCoordinator::BitcodeStreamDidFinish);
   streaming_downloader_->FinishStreaming(cb);
 }
 
 void PnaclCoordinator::BitcodeStreamDidFinish(int32_t pp_error) {
   PLUGIN_PRINTF(("PnaclCoordinator::BitcodeStreamDidFinish (pp_error=%"
-                 NACL_PRId32")\n", 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.
     translate_finish_error_ = pp_error;
     if (pp_error == PP_ERROR_ABORTED) {
       error_info_.SetReport(ERROR_PNACL_PEXE_FETCH_ABORTED,
                             "PnaclCoordinator: pexe load failed (aborted).");
     }
     if (pp_error == PP_ERROR_NOACCESS) {
       error_info_.SetReport(ERROR_PNACL_PEXE_FETCH_NOACCESS,
                             "PnaclCoordinator: pexe load failed (no access).");
     } else {
       nacl::stringstream ss;
       ss << "PnaclCoordinator: pexe load failed (pp_error=" << pp_error << ").";
       error_info_.SetReport(ERROR_PNACL_PEXE_FETCH_OTHER, ss.str());
     }
     translate_thread_->AbortSubprocesses();
   } else {
     // Compare download completion pct (100% now), to compile completion pct.
     HistogramRatio("NaCl.Perf.PNaClLoadTime.PctCompiledWhenFullyDownloaded",
                    pexe_bytes_compiled_, pexe_size_);
   }
 }
 
 void PnaclCoordinator::BitcodeStreamGotData(int32_t pp_error,
                                             FileStreamData data) {
   PLUGIN_PRINTF(("PnaclCoordinator::BitcodeStreamGotData (pp_error=%"
-                 NACL_PRId32", data=%p)\n", pp_error, data ? &(*data)[0] : 0));
+                 NACL_PRId32 ", data=%p)\n", pp_error, data ? &(*data)[0] : 0));
   DCHECK(translate_thread_.get());
 
   translate_thread_->PutBytes(data, pp_error);
   // If pp_error > 0, then it represents the number of bytes received.
   if (data && pp_error > 0) {
     pexe_size_ += pp_error;
   }
 }
 
 StreamCallback PnaclCoordinator::GetCallback() {
@@ skipping 37 matching lines @@
 }
 
 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));
+                 NACL_PRId32 ")\n", pp_error));
   if (pp_error != PP_OK) {
     ReportPpapiError(ERROR_PNACL_CREATE_TEMP,
                      pp_error,
                      "Failed to open scratch object file.");
     return;
   }
   // Open the nexe file for connecting ld and sel_ldr.
   // Start translation when done with this last step of setup!
   if (!use_new_cache_)
     // In the new cache case, the TempFile has already been created.
     temp_nexe_file_.reset(new TempFile(plugin_));
 
   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));
+                 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(),
                                   obj_file_.get(),
                                   temp_nexe_file_.get(),
                                   &error_info_,
                                   resources_.get(),
                                   &pnacl_options_,
                                   this,
                                   plugin_);
 }
 
 }  // namespace plugin