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

ipc/ipc_message.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.
 
 #ifndef IPC_IPC_MESSAGE_H_
 #define IPC_IPC_MESSAGE_H_
 
+#include <stdint.h>
+
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/memory/ref_counted.h"
 #include "base/pickle.h"
 #include "base/trace_event/trace_event.h"
 #include "ipc/ipc_export.h"
 
 #if !defined(NDEBUG)
 #define IPC_MESSAGE_LOG_ENABLED
@@ skipping 31 matching lines @@
     PUMPING_MSGS_BIT  = 0x40,
     HAS_SENT_TIME_BIT = 0x80,
   };
 
   ~Message() override;
 
   Message();
 
   // Initialize a message with a user-defined type, priority value, and
   // destination WebView ID.
-  Message(int32 routing_id, uint32 type, PriorityValue priority);
+  Message(int32_t routing_id, uint32_t type, PriorityValue priority);
 
   // Initializes a message from a const block of data.  The data is not copied;
   // instead the data is merely referenced by this message.  Only const methods
   // should be used on the message when initialized this way.
   Message(const char* data, int data_len);
 
   Message(const Message& other);
   Message& operator=(const Message& other);
 
   PriorityValue priority() const {
@@ skipping 49 matching lines @@
   }
 
   void set_dispatch_error() const {
     dispatch_error_ = true;
   }
 
   bool dispatch_error() const {
     return dispatch_error_;
   }
 
-  uint32 type() const {
+  uint32_t type() const {
     return header()->type;
   }
 
-  int32 routing_id() const {
+  int32_t routing_id() const {
     return header()->routing;
   }
 
-  void set_routing_id(int32 new_id) {
+  void set_routing_id(int32_t new_id) {
     header()->routing = new_id;
   }
 
-  uint32 flags() const {
+  uint32_t flags() const {
     return header()->flags;
   }
 
   // Sets all the given header values. The message should be empty at this
   // call.
-  void SetHeaderValues(int32 routing, uint32 type, uint32 flags);
+  void SetHeaderValues(int32_t routing, uint32_t type, uint32_t flags);
 
   template<class T, class S, class P>
   static bool Dispatch(const Message* msg, T* obj, S* sender, P* parameter,
                        void (T::*func)()) {
     (obj->*func)();
     return true;
   }
 
   template<class T, class S, class P>
   static bool Dispatch(const Message* msg, T* obj, S* sender, P* parameter,
@@ skipping 25 matching lines @@
   bool HasMojoHandles() const;
   // Whether the message has any brokerable attachments.
   bool HasBrokerableAttachments() const;
 
   void set_sender_pid(base::ProcessId id) { sender_pid_ = id; }
   base::ProcessId get_sender_pid() const { return sender_pid_; }
 
 #ifdef IPC_MESSAGE_LOG_ENABLED
   // Adds the outgoing time from Time::Now() at the end of the message and sets
   // a bit to indicate that it's been added.
-  void set_sent_time(int64 time);
-  int64 sent_time() const;
+  void set_sent_time(int64_t time);
+  int64_t sent_time() const;
 
-  void set_received_time(int64 time) const;
-  int64 received_time() const { return received_time_; }
+  void set_received_time(int64_t time) const;
+  int64_t received_time() const { return received_time_; }
   void set_output_params(const std::string& op) const { output_params_ = op; }
   const std::string& output_params() const { return output_params_; }
   // The following four functions are needed so we can log sync messages with
   // delayed replies.  We stick the log data from the sent message into the
   // reply message, so that when it's sent and we have the output parameters
   // we can log it.  As such, we set a flag on the sent message to not log it.
   void set_sync_log_data(LogData* data) const { log_data_ = data; }
   LogData* sync_log_data() const { return log_data_; }
   void set_dont_log() const { dont_log_ = true; }
   bool dont_log() const { return dont_log_; }
 #endif
 
  protected:
   friend class Channel;
   friend class ChannelMojo;
   friend class ChannelNacl;
   friend class ChannelPosix;
   friend class ChannelWin;
   friend class internal::ChannelReader;
   friend class MessageReplyDeserializer;
   friend class SyncMessage;
 
 #pragma pack(push, 4)
   struct Header : base::Pickle::Header {
-    int32 routing;  // ID of the view that this message is destined for
-    uint32 type;    // specifies the user-defined message type
-    uint32 flags;   // specifies control flags for the message
+    int32_t routing;  // ID of the view that this message is destined for
+    uint32_t type;    // specifies the user-defined message type
+    uint32_t flags;   // specifies control flags for the message
 #if defined(OS_POSIX)
-    uint16 num_fds; // the number of descriptors included with this message
-    uint16 pad;     // explicitly initialize this to appease valgrind
+    uint16_t num_fds; // the number of descriptors included with this message
+    uint16_t pad;     // explicitly initialize this to appease valgrind
 #endif
   };
 #pragma pack(pop)
 
   Header* header() {
     return headerT<Header>();
   }
   const Header* header() const {
     return headerT<Header>();
   }
@@ skipping 16 matching lines @@
   const MessageAttachmentSet* attachment_set() const {
     return attachment_set_.get();
   }
 
   // The process id of the sender of the message. This member is populated with
   // a valid value for every message dispatched to listeners.
   base::ProcessId sender_pid_;
 
 #ifdef IPC_MESSAGE_LOG_ENABLED
   // Used for logging.
-  mutable int64 received_time_;
+  mutable int64_t received_time_;
   mutable std::string output_params_;
   mutable LogData* log_data_;
   mutable bool dont_log_;
 #endif
 };
 
 //------------------------------------------------------------------------------
 
 }  // namespace IPC
 
 enum SpecialRoutingIDs {
   // indicates that we don't have a routing ID yet.
   MSG_ROUTING_NONE = -2,
 
   // indicates a general message not sent to a particular tab.
   MSG_ROUTING_CONTROL = kint32max,
 };
 
 #define IPC_REPLY_ID 0xFFFFFFF0  // Special message id for replies
 #define IPC_LOGGING_ID 0xFFFFFFF1  // Special message id for logging
 
 #endif  // IPC_IPC_MESSAGE_H_