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

ppapi/native_client/src/trusted/plugin/plugin.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.
 
 #ifdef _MSC_VER
 // Do not warn about use of std::copy with raw pointers.
 #pragma warning(disable : 4996)
 #endif
 
 #include "ppapi/native_client/src/trusted/plugin/plugin.h"
@@ skipping 613 matching lines @@
   // If the MIME type is foreign, then this NEXE is being used as a content
   // type handler rather than directly by an HTML document.
   return
       !mime_type().empty() &&
       mime_type() != kNaClMIMEType &&
       mime_type() != kPnaclMIMEType;
 }
 
 
 Plugin* Plugin::New(PP_Instance pp_instance) {
-  PLUGIN_PRINTF(("Plugin::New (pp_instance=%"NACL_PRId32")\n", pp_instance));
+  PLUGIN_PRINTF(("Plugin::New (pp_instance=%" NACL_PRId32 ")\n", pp_instance));
   Plugin* plugin = new Plugin(pp_instance);
   PLUGIN_PRINTF(("Plugin::New (plugin=%p)\n", static_cast<void*>(plugin)));
   if (plugin == NULL) {
     return NULL;
   }
   return plugin;
 }
 
 
 // All failures of this function will show up as "Missing Plugin-in", so
 // there is no need to log to JS console that there was an initialization
 // failure. Note that module loading functions will log their own errors.
 bool Plugin::Init(uint32_t argc, const char* argn[], const char* argv[]) {
-  PLUGIN_PRINTF(("Plugin::Init (argc=%"NACL_PRIu32")\n", argc));
+  PLUGIN_PRINTF(("Plugin::Init (argc=%" NACL_PRIu32 ")\n", argc));
   HistogramEnumerateOsArch(GetSandboxISA());
   init_time_ = NaClGetTimeOfDayMicroseconds();
 
   ScriptablePlugin* scriptable_plugin = ScriptablePlugin::NewPlugin(this);
   if (scriptable_plugin == NULL)
     return false;
 
   set_scriptable_plugin(scriptable_plugin);
   PLUGIN_PRINTF(("Plugin::Init (scriptable_handle=%p)\n",
                  static_cast<void*>(scriptable_plugin_)));
@@ skipping 74 matching lines @@
       nexe_error_reported_(false),
       wrapper_factory_(NULL),
       enable_dev_interfaces_(false),
       is_installed_(false),
       init_time_(0),
       ready_time_(0),
       nexe_size_(0),
       time_of_last_progress_event_(0),
       nacl_interface_(NULL) {
   PLUGIN_PRINTF(("Plugin::Plugin (this=%p, pp_instance=%"
-                 NACL_PRId32")\n", static_cast<void*>(this), pp_instance));
+                 NACL_PRId32 ")\n", static_cast<void*>(this), pp_instance));
   callback_factory_.Initialize(this);
   nexe_downloader_.Initialize(this);
   nacl_interface_ = GetNaClInterface();
   CHECK(nacl_interface_ != NULL);
 }
 
 
 Plugin::~Plugin() {
   int64_t shutdown_start = NaClGetTimeOfDayMicroseconds();
 
@@ skipping 83 matching lines @@
 
 void Plugin::HistogramStartupTimeMedium(const std::string& name, float dt) {
   if (nexe_size_ > 0) {
     float size_in_MB = static_cast<float>(nexe_size_) / (1024.f * 1024.f);
     HistogramTimeMedium(name, static_cast<int64_t>(dt));
     HistogramTimeMedium(name + "PerMB", static_cast<int64_t>(dt / size_in_MB));
   }
 }
 
 void Plugin::NexeFileDidOpen(int32_t pp_error) {
-  PLUGIN_PRINTF(("Plugin::NexeFileDidOpen (pp_error=%"NACL_PRId32")\n",
+  PLUGIN_PRINTF(("Plugin::NexeFileDidOpen (pp_error=%" NACL_PRId32 ")\n",
                  pp_error));
   struct NaClFileInfo info = nexe_downloader_.GetFileInfo();
-  PLUGIN_PRINTF(("Plugin::NexeFileDidOpen (file_desc=%"NACL_PRId32")\n",
+  PLUGIN_PRINTF(("Plugin::NexeFileDidOpen (file_desc=%" NACL_PRId32 ")\n",
                  info.desc));
   HistogramHTTPStatusCode(
       is_installed_ ?
           "NaCl.HttpStatusCodeClass.Nexe.InstalledApp" :
           "NaCl.HttpStatusCodeClass.Nexe.NotInstalledApp",
       nexe_downloader_.status_code());
   ErrorInfo error_info;
   if (pp_error != PP_OK || info.desc == NACL_NO_FILE_DESC) {
     if (pp_error == PP_ERROR_ABORTED) {
       ReportLoadAbort();
@@ skipping 85 matching lines @@
   PLUGIN_PRINTF(("LogLineToConsole: %s\n",
                  one_line.c_str()));
   plugin->AddToConsole(one_line);
 }
 
 void Plugin::CopyCrashLogToJsConsole() {
   nacl::string fatal_msg(main_service_runtime()->GetCrashLogOutput());
   size_t ix_start = 0;
   size_t ix_end;
 
-  PLUGIN_PRINTF(("Plugin::CopyCrashLogToJsConsole: got %"NACL_PRIuS" bytes\n",
+  PLUGIN_PRINTF(("Plugin::CopyCrashLogToJsConsole: got %" NACL_PRIuS " bytes\n",
                  fatal_msg.size()));
   while (nacl::string::npos != (ix_end = fatal_msg.find('\n', ix_start))) {
     LogLineToConsole(this, fatal_msg.substr(ix_start, ix_end - ix_start));
     ix_start = ix_end + 1;
   }
   if (ix_start != fatal_msg.size()) {
     LogLineToConsole(this, fatal_msg.substr(ix_start));
   }
 }
 
 void Plugin::NexeDidCrash(int32_t pp_error) {
-  PLUGIN_PRINTF(("Plugin::NexeDidCrash (pp_error=%"NACL_PRId32")\n",
+  PLUGIN_PRINTF(("Plugin::NexeDidCrash (pp_error=%" NACL_PRId32 ")\n",
                  pp_error));
   if (pp_error != PP_OK) {
     PLUGIN_PRINTF(("Plugin::NexeDidCrash: CallOnMainThread callback with"
                    " non-PP_OK arg -- SHOULD NOT HAPPEN\n"));
   }
   PLUGIN_PRINTF(("Plugin::NexeDidCrash: crash event!\n"));
   int exit_status = main_subprocess_.service_runtime()->exit_status();
   if (-1 != exit_status) {
     // The NaCl module voluntarily exited.  However, this is still a
     // crash from the point of view of Pepper, since PPAPI plugins are
@@ skipping 26 matching lines @@
   // In all cases, try to grab the crash log.  The first error
   // reported may have come from the start_module RPC reply indicating
   // a validation error or something similar, which wouldn't grab the
   // crash log.  In the event that this is called twice, the second
   // invocation will just be a no-op, since all the crash log will
   // have been received and we'll just get an EOF indication.
   CopyCrashLogToJsConsole();
 }
 
 void Plugin::BitcodeDidTranslate(int32_t pp_error) {
-  PLUGIN_PRINTF(("Plugin::BitcodeDidTranslate (pp_error=%"NACL_PRId32")\n",
+  PLUGIN_PRINTF(("Plugin::BitcodeDidTranslate (pp_error=%" NACL_PRId32 ")\n",
                  pp_error));
   if (pp_error != PP_OK) {
     // Error should have been reported by pnacl. Just return.
     PLUGIN_PRINTF(("Plugin::BitcodeDidTranslate error in Pnacl\n"));
     return;
   }
 
   // Inform JavaScript that we successfully translated the bitcode to a nexe.
   nacl::scoped_ptr<nacl::DescWrapper>
       wrapper(pnacl_coordinator_.get()->ReleaseTranslatedFD());
@@ skipping 47 matching lines @@
   // else ReportLoadError() and ReportAbortError() will be used by loading code
   // to provide error handling.
   //
   // NOTE: not all crashes during load will make it here.
   // Those in BrowserPpp::InitializeModule and creation of PPP interfaces
   // will just get reported back as PP_ERROR_FAILED.
 }
 
 void Plugin::NaClManifestBufferReady(int32_t pp_error) {
   PLUGIN_PRINTF(("Plugin::NaClManifestBufferReady (pp_error=%"
-                 NACL_PRId32")\n", pp_error));
+                 NACL_PRId32 ")\n", pp_error));
   ErrorInfo error_info;
   set_manifest_url(nexe_downloader_.url());
   if (pp_error != PP_OK) {
     if (pp_error == PP_ERROR_ABORTED) {
       ReportLoadAbort();
     } else {
       error_info.SetReport(ERROR_MANIFEST_LOAD_URL,
                            "could not load manifest url.");
       ReportLoadError(error_info);
     }
@@ skipping 16 matching lines @@
     return;
   }
   std::copy(buffer.begin(), buffer.begin() + buffer_size, &json_buffer[0]);
   json_buffer[buffer_size] = '\0';
 
   ProcessNaClManifest(json_buffer.get());
 }
 
 void Plugin::NaClManifestFileDidOpen(int32_t pp_error) {
   PLUGIN_PRINTF(("Plugin::NaClManifestFileDidOpen (pp_error=%"
-                 NACL_PRId32")\n", pp_error));
+                 NACL_PRId32 ")\n", pp_error));
   HistogramTimeSmall("NaCl.Perf.StartupTime.ManifestDownload",
                      nexe_downloader_.TimeSinceOpenMilliseconds());
   HistogramHTTPStatusCode(
       is_installed_ ?
           "NaCl.HttpStatusCodeClass.Manifest.InstalledApp" :
           "NaCl.HttpStatusCodeClass.Manifest.NotInstalledApp",
       nexe_downloader_.status_code());
   ErrorInfo error_info;
   // The manifest file was successfully opened.  Set the src property on the
   // plugin now, so that the full url is available to error handlers.
   set_manifest_url(nexe_downloader_.url());
   struct NaClFileInfo info = nexe_downloader_.GetFileInfo();
   PLUGIN_PRINTF(("Plugin::NaClManifestFileDidOpen (file_desc=%"
-                 NACL_PRId32")\n", info.desc));
+                 NACL_PRId32 ")\n", info.desc));
   if (pp_error != PP_OK || info.desc == NACL_NO_FILE_DESC) {
     if (pp_error == PP_ERROR_ABORTED) {
       ReportLoadAbort();
     } else if (pp_error == PP_ERROR_NOACCESS) {
       error_info.SetReport(ERROR_MANIFEST_NOACCESS_URL,
                            "access to manifest url was denied.");
       ReportLoadError(error_info);
     } else {
       error_info.SetReport(ERROR_MANIFEST_LOAD_URL,
                            "could not load manifest url.");
@@ skipping 161 matching lines @@
   if (!json_manifest->Init(manifest_json, error_info)) {
     return false;
   }
   manifest_.reset(json_manifest.release());
   return true;
 }
 
 void Plugin::UrlDidOpenForStreamAsFile(int32_t pp_error,
                                        FileDownloader*& url_downloader,
                                        PP_CompletionCallback callback) {
-  PLUGIN_PRINTF(("Plugin::UrlDidOpen (pp_error=%"NACL_PRId32
+  PLUGIN_PRINTF(("Plugin::UrlDidOpen (pp_error=%" NACL_PRId32
                  ", url_downloader=%p)\n", pp_error,
                  static_cast<void*>(url_downloader)));
   url_downloaders_.erase(url_downloader);
   nacl::scoped_ptr<FileDownloader> scoped_url_downloader(url_downloader);
   struct NaClFileInfo info = scoped_url_downloader->GetFileInfo();
 
   if (pp_error != PP_OK) {
     PP_RunCompletionCallback(&callback, pp_error);
   } else if (info.desc > NACL_NO_FILE_DESC) {
     url_file_info_map_[url_downloader->url_to_open()] = info;
@@ skipping 179 matching lines @@
                        Plugin::kUnknownBytes);
 }
 
 void Plugin::EnqueueProgressEvent(const char* event_type,
                                   const nacl::string& url,
                                   LengthComputable length_computable,
                                   uint64_t loaded_bytes,
                                   uint64_t total_bytes) {
   PLUGIN_PRINTF(("Plugin::EnqueueProgressEvent ("
                  "event_type='%s', url='%s', length_computable=%d, "
-                 "loaded=%"NACL_PRIu64", total=%"NACL_PRIu64")\n",
+                 "loaded=%" NACL_PRIu64 ", total=%" NACL_PRIu64 ")\n",
                  event_type,
                  url.c_str(),
                  static_cast<int>(length_computable),
                  loaded_bytes,
                  total_bytes));
 
   progress_events_.push(new ProgressEvent(event_type,
                                           url,
                                           length_computable,
                                           loaded_bytes,
                                           total_bytes));
   // Note that using callback_factory_ in this way is not thread safe.
   // If/when EnqueueProgressEvent is callable from another thread, this
   // will need to change.
   pp::CompletionCallback callback =
       callback_factory_.NewCallback(&Plugin::DispatchProgressEvent);
   pp::Core* core = pp::Module::Get()->core();
   core->CallOnMainThread(0, callback, 0);
 }
 
 void Plugin::ReportSelLdrLoadStatus(int status) {
   HistogramEnumerateSelLdrLoadStatus(static_cast<NaClErrorCode>(status),
                                      is_installed_);
 }
 
 void Plugin::DispatchProgressEvent(int32_t result) {
   PLUGIN_PRINTF(("Plugin::DispatchProgressEvent (result=%"
-                 NACL_PRId32")\n", result));
+                 NACL_PRId32 ")\n", result));
   if (result < 0) {
     return;
   }
   if (progress_events_.empty()) {
     PLUGIN_PRINTF(("Plugin::DispatchProgressEvent: no pending events\n"));
     return;
   }
   nacl::scoped_ptr<ProgressEvent> event(progress_events_.front());
   progress_events_.pop();
   PLUGIN_PRINTF(("Plugin::DispatchProgressEvent ("
                  "event_type='%s', url='%s', length_computable=%d, "
-                 "loaded=%"NACL_PRIu64", total=%"NACL_PRIu64")\n",
+                 "loaded=%" NACL_PRIu64 ", total=%" NACL_PRIu64 ")\n",
                  event->event_type(),
                  event->url(),
                  static_cast<int>(event->length_computable()),
                  event->loaded_bytes(),
                  event->total_bytes()));
 
   static const char* kEventClosureJS =
       "(function(target, type, url,"
       "          lengthComputable, loadedBytes, totalBytes) {"
       "    var progress_event = new ProgressEvent(type, {"
@@ skipping 115 matching lines @@
                                           static_cast<uint32_t>(text.size()));
   const PPB_Console* console_interface =
       static_cast<const PPB_Console*>(
           module->GetBrowserInterface(PPB_CONSOLE_INTERFACE));
   console_interface->LogWithSource(pp_instance(), PP_LOGLEVEL_LOG, prefix, str);
   var_interface->Release(prefix);
   var_interface->Release(str);
 }
 
 }  // namespace plugin