ipc: Convert int types from basictypes.h to the ones from stdint.h

ipc/ipc_message_macros.h

 // 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.
 
 // Defining IPC Messages
 //
 // Your IPC messages will be defined by macros inside of an XXX_messages.h
 // header file.  Most of the time, the system can automatically generate all
 // of messaging mechanism from these definitions, but sometimes some manual
 // coding is required.  In these cases, you will also have an XXX_messages.cc
@@ skipping 176 matching lines @@
 //   #undef IPC_MESSAGE_EXPORT
 //   #define IPC_MESSAGE_EXPORT VISIBILITY_MACRO
 // after including this header, but before using any of the macros below.
 // (This needs to be before the include guard.)
 #undef IPC_MESSAGE_EXPORT
 #define IPC_MESSAGE_EXPORT
 
 #ifndef IPC_IPC_MESSAGE_MACROS_H_
 #define IPC_IPC_MESSAGE_MACROS_H_
 
+#include <stdint.h>
+
 #include "base/profiler/scoped_profile.h"
 #include "ipc/ipc_message_utils.h"
 #include "ipc/param_traits_macros.h"
 
 #if defined(IPC_MESSAGE_IMPL)
 #include "ipc/ipc_message_utils_impl.h"
 #endif
 
 // Convenience macro for defining structs without inheritance. Should not need
 // to be subsequently redefined.
@@ skipping 377 matching lines @@
     enum { ID = IPC_MESSAGE_ID() };                                           \
     msg_class() : IPC::Message(MSG_ROUTING_CONTROL, ID, PRIORITY_NORMAL) {}   \
     static void Log(std::string* name, const Message* msg, std::string* l);   \
   };
 
 #define IPC_EMPTY_ROUTED_DECL(msg_class, in_cnt, out_cnt, in_list, out_list)  \
   class IPC_MESSAGE_EXPORT msg_class : public IPC::Message {                  \
    public:                                                                    \
     typedef IPC::Message Schema;                                              \
     enum { ID = IPC_MESSAGE_ID() };                                           \
-    msg_class(int32 routing_id)                                               \
+    msg_class(int32_t routing_id)                                             \
         : IPC::Message(routing_id, ID, PRIORITY_NORMAL) {}                    \
     static void Log(std::string* name, const Message* msg, std::string* l);   \
   };
 
 #define IPC_ASYNC_CONTROL_DECL(msg_class, in_cnt, out_cnt, in_list, out_list) \
   class IPC_MESSAGE_EXPORT msg_class : public IPC::Message {                  \
    public:                                                                    \
     typedef IPC::MessageSchema<IPC_TUPLE_IN_##in_cnt in_list> Schema;         \
     typedef Schema::Param Param;                                              \
     enum { ID = IPC_MESSAGE_ID() };                                           \
     msg_class(IPC_TYPE_IN_##in_cnt in_list);                                  \
     ~msg_class() override;                                                    \
     static bool Read(const Message* msg, Schema::Param* p);                   \
     static void Log(std::string* name, const Message* msg, std::string* l);   \
     IPC_ASYNC_MESSAGE_METHODS_##in_cnt                                        \
   };
 
 #define IPC_ASYNC_ROUTED_DECL(msg_class, in_cnt, out_cnt, in_list, out_list)  \
   class IPC_MESSAGE_EXPORT msg_class : public IPC::Message {                  \
    public:                                                                    \
     typedef IPC::MessageSchema<IPC_TUPLE_IN_##in_cnt in_list> Schema;         \
     typedef Schema::Param Param;                                              \
     enum { ID = IPC_MESSAGE_ID() };                                           \
-    msg_class(int32 routing_id IPC_COMMA_##in_cnt                             \
+    msg_class(int32_t routing_id IPC_COMMA_##in_cnt                           \
               IPC_TYPE_IN_##in_cnt in_list);                                  \
     ~msg_class() override;                                                    \
     static bool Read(const Message* msg, Schema::Param* p);                   \
     static void Log(std::string* name, const Message* msg, std::string* l);   \
     IPC_ASYNC_MESSAGE_METHODS_##in_cnt                                        \
   };
 
 #define IPC_SYNC_CONTROL_DECL(msg_class, in_cnt, out_cnt, in_list, out_list)  \
   class IPC_MESSAGE_EXPORT msg_class : public IPC::SyncMessage {              \
    public:                                                                    \
@@ skipping 15 matching lines @@
   };
 
 #define IPC_SYNC_ROUTED_DECL(msg_class, in_cnt, out_cnt, in_list, out_list)   \
   class IPC_MESSAGE_EXPORT msg_class : public IPC::SyncMessage {              \
    public:                                                                    \
     typedef IPC::SyncMessageSchema<IPC_TUPLE_IN_##in_cnt in_list,             \
                                    IPC_TUPLE_OUT_##out_cnt out_list> Schema;  \
     typedef Schema::ReplyParam ReplyParam;                                    \
     typedef Schema::SendParam SendParam;                                      \
     enum { ID = IPC_MESSAGE_ID() };                                           \
-    msg_class(int32 routing_id                                                \
+    msg_class(int32_t routing_id                                              \
               IPC_COMMA_OR_##in_cnt(IPC_COMMA_##out_cnt)                      \
               IPC_TYPE_IN_##in_cnt in_list                                    \
               IPC_COMMA_AND_##in_cnt(IPC_COMMA_##out_cnt)                     \
               IPC_TYPE_OUT_##out_cnt out_list);                               \
     ~msg_class() override;                                                    \
     static bool ReadSendParam(const Message* msg, Schema::SendParam* p);      \
     static bool ReadReplyParam(                                               \
         const Message* msg,                                                   \
         base::TupleTypes<ReplyParam>::ValueTuple* p);                         \
     static void Log(std::string* name, const Message* msg, std::string* l);   \
@@ skipping 18 matching lines @@
   msg_class::msg_class(IPC_TYPE_IN_##in_cnt in_list) :                        \
       IPC::Message(MSG_ROUTING_CONTROL, ID, PRIORITY_NORMAL) {                \
         Schema::Write(this, IPC_NAME_IN_##in_cnt in_list);                    \
       }                                                                       \
   msg_class::~msg_class() {}                                                  \
   bool msg_class::Read(const Message* msg, Schema::Param* p) {                \
     return Schema::Read(msg, p);                                              \
   }
 
 #define IPC_ASYNC_ROUTED_IMPL(msg_class, in_cnt, out_cnt, in_list, out_list)  \
-  msg_class::msg_class(int32 routing_id IPC_COMMA_##in_cnt                    \
+  msg_class::msg_class(int32_t routing_id IPC_COMMA_##in_cnt                  \
                        IPC_TYPE_IN_##in_cnt in_list) :                        \
       IPC::Message(routing_id, ID, PRIORITY_NORMAL) {                         \
         Schema::Write(this, IPC_NAME_IN_##in_cnt in_list);                    \
       }                                                                       \
   msg_class::~msg_class() {}                                                  \
   bool msg_class::Read(const Message* msg, Schema::Param* p) {                \
     return Schema::Read(msg, p);                                              \
   }
 
 #define IPC_SYNC_CONTROL_IMPL(msg_class, in_cnt, out_cnt, in_list, out_list)  \
   msg_class::msg_class(IPC_TYPE_IN_##in_cnt in_list                           \
                        IPC_COMMA_AND_##in_cnt(IPC_COMMA_##out_cnt)            \
                        IPC_TYPE_OUT_##out_cnt out_list) :                     \
       IPC::SyncMessage(MSG_ROUTING_CONTROL, ID, PRIORITY_NORMAL,              \
                        new IPC::ParamDeserializer<Schema::ReplyParam>(        \
                            IPC_NAME_OUT_##out_cnt out_list)) {                \
         Schema::Write(this, IPC_NAME_IN_##in_cnt in_list);                    \
       }                                                                       \
   msg_class::~msg_class() {}                                                  \
   bool msg_class::ReadSendParam(const Message* msg, Schema::SendParam* p) {   \
     return Schema::ReadSendParam(msg, p);                                     \
   }                                                                           \
   bool msg_class::ReadReplyParam(                                             \
       const Message* msg,                                                     \
       base::TupleTypes<ReplyParam>::ValueTuple* p) {                          \
     return Schema::ReadReplyParam(msg, p);                                    \
   }
 
 #define IPC_SYNC_ROUTED_IMPL(msg_class, in_cnt, out_cnt, in_list, out_list)   \
-  msg_class::msg_class(int32 routing_id                                       \
+  msg_class::msg_class(int32_t routing_id                                     \
                        IPC_COMMA_OR_##in_cnt(IPC_COMMA_##out_cnt)             \
                        IPC_TYPE_IN_##in_cnt in_list                           \
                        IPC_COMMA_AND_##in_cnt(IPC_COMMA_##out_cnt)            \
                        IPC_TYPE_OUT_##out_cnt out_list) :                     \
       IPC::SyncMessage(routing_id, ID, PRIORITY_NORMAL,                       \
                        new IPC::ParamDeserializer<Schema::ReplyParam>(        \
                            IPC_NAME_OUT_##out_cnt out_list)) {                \
         Schema::Write(this, IPC_NAME_IN_##in_cnt in_list);                    \
       }                                                                       \
   msg_class::~msg_class() {}                                                  \
@@ skipping 52 matching lines @@
 #ifndef IPC_LOG_TABLE_ADD_ENTRY
 #error You need to define IPC_LOG_TABLE_ADD_ENTRY(msg_id, logger)
 #endif
 
 // "Log table" inclusion produces extra logging registration code.
 #define IPC_MESSAGE_EXTRA(sync, kind, msg_class,                        \
                           in_cnt, out_cnt, in_list, out_list)           \
   class LoggerRegisterHelper##msg_class {                               \
  public:                                                                \
     LoggerRegisterHelper##msg_class() {                                 \
-      const uint32 msg_id = static_cast<uint32>(msg_class::ID);         \
+      const uint32_t msg_id = static_cast<uint32_t>(msg_class::ID);     \
       IPC_LOG_TABLE_ADD_ENTRY(msg_id, msg_class::Log);                  \
     }                                                                   \
   };                                                                    \
   LoggerRegisterHelper##msg_class g_LoggerRegisterHelper##msg_class;
 
 #else
 
 // Normal inclusion produces nothing extra.
 #define IPC_MESSAGE_EXTRA(sync, kind, msg_class,                \
                           in_cnt, out_cnt, in_list, out_list)
@@ skipping 166 matching lines @@
 // This corresponds to an enum value from IPCMessageStart.
 #define IPC_MESSAGE_CLASS(message) \
   IPC_MESSAGE_ID_CLASS(message.type())
 
 #endif  // IPC_IPC_MESSAGE_MACROS_H_
 
 // Clean up IPC_MESSAGE_START in this unguarded section so that the
 // XXX_messages.h files need not do so themselves.  This makes the
 // XXX_messages.h files easier to write.
 #undef IPC_MESSAGE_START