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

ppapi/native_client/src/trusted/weak_ref/call_on_main_thread.h

 /* -*- c++ -*- */
 /*
  * Copyright (c) 2011 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.
  */
 
 // EXAMPLE USAGE
 //
 // class PluginReverseInterface {
@@ skipping 147 matching lines @@
  public:
   WeakRefMemberFuncBinder(E* object,
                           void (E::*raw_callback_fn)(R* raw_data,
                                                      int32_t err),
                           R* raw_data)
       : object_(object),
         raw_callback_fn_(raw_callback_fn),
         data_(raw_data) {}
   void Invoke(int32_t err) {
     NaClLog2(kPpWeakRefModuleName, 4,
-             ("WeakRefMemberFuncBinder: Invoke obj 0x%"NACL_PRIxPTR
-              ", err%"NACL_PRId32"\n"),
+             ("WeakRefMemberFuncBinder: Invoke obj 0x%" NACL_PRIxPTR
+              ", err%" NACL_PRId32 "\n"),
              reinterpret_cast<uintptr_t>(object_), err);
     (object_->*raw_callback_fn_)(data_.get(), err);
     NaClLog2(kPpWeakRefModuleName, 4,
              "WeakRefMemberFuncBinder: done\n");
   }
  private:
   E* object_;
   void (E::*raw_callback_fn_)(R* raw_data, int32_t err);
   nacl::scoped_ptr<R> data_;
 };
 
 template <typename R, typename E>
 void WeakRefMemberFuncInvoker(
     WeakRefMemberFuncBinder<R, E> *binder, int32_t err) {
   NaClLog2(kPpWeakRefModuleName, 4,
-           "WeakRefMemberFuncInvoker: %"NACL_PRIxPTR" %"NACL_PRId32"\n",
+           "WeakRefMemberFuncInvoker: %" NACL_PRIxPTR " %" NACL_PRId32 "\n",
            (uintptr_t) binder,
            err);
   binder->Invoke(err);
   // delete binder not needed, since WeakRefAutoAbandoner holds binder
   // in a scoped_ptr and will automatically delete on scope exit.
 }
 
 
 // A typesafe utility to schedule a completion callback using weak
 // references, where the callback function is a member function.  The
 // member function must take only a raw argument data pointer and a
 // completion status as formal parameters.  The lifetime of the
 // |object| and |raw_callback_fn| must be at least that of |anchor|.
 // Typically |object| is just the object that controls the |anchor|,
 // though it may be some sub-object that is contained within the
 // actual controlling object.  If the |anchor| is abandoned, the
 // |raw_data| argument is deleted and the |raw_callback_fn| will not
 // be invoked.
 template <typename R, typename E>
 pp::CompletionCallback WeakRefNewCallback(
     nacl::WeakRefAnchor* anchor,
     E* object,
     void (E::*raw_callback_fn)(R* raw_data, int32_t err),
     R* raw_data) {
   NaClLog2(kPpWeakRefModuleName, 4,
            "Entered WeakRefNewCallback\n");
   NaClLog2(kPpWeakRefModuleName, 4,
-           "object 0x%"NACL_PRIxPTR"\n",
+           "object 0x%" NACL_PRIxPTR "\n",
            reinterpret_cast<uintptr_t>(object));
   WeakRefMemberFuncBinder<R, E>* binder =
       new WeakRefMemberFuncBinder<R, E>(object,
                                         raw_callback_fn,
                                         raw_data);
   CHECK(binder != NULL);
   NaClLog2(kPpWeakRefModuleName, 4,
-           "WeakRefNewCallback: binder %"NACL_PRIxPTR"\n",
+           "WeakRefNewCallback: binder %" NACL_PRIxPTR "\n",
            (uintptr_t) binder);
   void (*weak_ref_member_func_invoker_ptr)(
       WeakRefMemberFuncBinder<R, E>* binder,
       int32_t err) = WeakRefMemberFuncInvoker<R, E>;
   return WeakRefNewCallback(anchor, weak_ref_member_func_invoker_ptr,
                              binder);
 }
 
 template <typename R, typename E> void WeakRefCallOnMainThread(
     nacl::WeakRefAnchor* anchor,
@@ skipping 11 matching lines @@
       delay_in_milliseconds,
       cc,
       PP_OK);
   NaClLog2(kPpWeakRefModuleName, 4,
            "WeakRefCallOnMainThread: invoked PP_CallOnMainThread\n");
 }
 
 }  // namespace plugin
 
 #endif