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

ipc/ipc_message_utils.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 "ipc/ipc_message_utils.h"
 
 #include "base/files/file_path.h"
 #include "base/json/json_writer.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/nullable_string16.h"
@@ skipping 296 matching lines @@
 
 void ParamTraits<int>::Log(const param_type& p, std::string* l) {
   l->append(base::IntToString(p));
 }
 
 void ParamTraits<unsigned int>::Log(const param_type& p, std::string* l) {
   l->append(base::UintToString(p));
 }
 
 void ParamTraits<long>::Log(const param_type& p, std::string* l) {
-  l->append(base::Int64ToString(static_cast<int64>(p)));
+  l->append(base::Int64ToString(static_cast<int64_t>(p)));
 }
 
 void ParamTraits<unsigned long>::Log(const param_type& p, std::string* l) {
-  l->append(base::Uint64ToString(static_cast<uint64>(p)));
+  l->append(base::Uint64ToString(static_cast<uint64_t>(p)));
 }
 
 void ParamTraits<long long>::Log(const param_type& p, std::string* l) {
-  l->append(base::Int64ToString(static_cast<int64>(p)));
+  l->append(base::Int64ToString(static_cast<int64_t>(p)));
 }
 
 void ParamTraits<unsigned long long>::Log(const param_type& p, std::string* l) {
   l->append(base::Uint64ToString(p));
 }
 
 void ParamTraits<float>::Log(const param_type& p, std::string* l) {
   l->append(base::StringPrintf("%e", p));
 }
 
@@ skipping 354 matching lines @@
   l->append(",");
   LogParam(p.last_modified.ToDoubleT(), l);
   l->append(",");
   LogParam(p.last_accessed.ToDoubleT(), l);
   l->append(",");
   LogParam(p.creation_time.ToDoubleT(), l);
   l->append(")");
 }
 
 void ParamTraits<base::Time>::Write(Message* m, const param_type& p) {
-  ParamTraits<int64>::Write(m, p.ToInternalValue());
+  ParamTraits<int64_t>::Write(m, p.ToInternalValue());
 }
 
 bool ParamTraits<base::Time>::Read(const Message* m,
                                    base::PickleIterator* iter,
                                    param_type* r) {
-  int64 value;
-  if (!ParamTraits<int64>::Read(m, iter, &value))
+  int64_t value;
+  if (!ParamTraits<int64_t>::Read(m, iter, &value))
     return false;
   *r = base::Time::FromInternalValue(value);
   return true;
 }
 
 void ParamTraits<base::Time>::Log(const param_type& p, std::string* l) {
-  ParamTraits<int64>::Log(p.ToInternalValue(), l);
+  ParamTraits<int64_t>::Log(p.ToInternalValue(), l);
 }
 
 void ParamTraits<base::TimeDelta>::Write(Message* m, const param_type& p) {
-  ParamTraits<int64>::Write(m, p.ToInternalValue());
+  ParamTraits<int64_t>::Write(m, p.ToInternalValue());
 }
 
 bool ParamTraits<base::TimeDelta>::Read(const Message* m,
                                         base::PickleIterator* iter,
                                         param_type* r) {
-  int64 value;
-  bool ret = ParamTraits<int64>::Read(m, iter, &value);
+  int64_t value;
+  bool ret = ParamTraits<int64_t>::Read(m, iter, &value);
   if (ret)
     *r = base::TimeDelta::FromInternalValue(value);
 
   return ret;
 }
 
 void ParamTraits<base::TimeDelta>::Log(const param_type& p, std::string* l) {
-  ParamTraits<int64>::Log(p.ToInternalValue(), l);
+  ParamTraits<int64_t>::Log(p.ToInternalValue(), l);
 }
 
 void ParamTraits<base::TimeTicks>::Write(Message* m, const param_type& p) {
-  ParamTraits<int64>::Write(m, p.ToInternalValue());
+  ParamTraits<int64_t>::Write(m, p.ToInternalValue());
 }
 
 bool ParamTraits<base::TimeTicks>::Read(const Message* m,
                                         base::PickleIterator* iter,
                                         param_type* r) {
-  int64 value;
-  bool ret = ParamTraits<int64>::Read(m, iter, &value);
+  int64_t value;
+  bool ret = ParamTraits<int64_t>::Read(m, iter, &value);
   if (ret)
     *r = base::TimeTicks::FromInternalValue(value);
 
   return ret;
 }
 
 void ParamTraits<base::TimeTicks>::Log(const param_type& p, std::string* l) {
-  ParamTraits<int64>::Log(p.ToInternalValue(), l);
+  ParamTraits<int64_t>::Log(p.ToInternalValue(), l);
 }
 
 void ParamTraits<base::TraceTicks>::Write(Message* m, const param_type& p) {
-  ParamTraits<int64>::Write(m, p.ToInternalValue());
+  ParamTraits<int64_t>::Write(m, p.ToInternalValue());
 }
 
 bool ParamTraits<base::TraceTicks>::Read(const Message* m,
                                          base::PickleIterator* iter,
                                          param_type* r) {
-  int64 value;
-  bool ret = ParamTraits<int64>::Read(m, iter, &value);
+  int64_t value;
+  bool ret = ParamTraits<int64_t>::Read(m, iter, &value);
   if (ret)
     *r = base::TraceTicks::FromInternalValue(value);
 
   return ret;
 }
 
 void ParamTraits<base::TraceTicks>::Log(const param_type& p, std::string* l) {
-  ParamTraits<int64>::Log(p.ToInternalValue(), l);
+  ParamTraits<int64_t>::Log(p.ToInternalValue(), l);
 }
 
 void ParamTraits<IPC::ChannelHandle>::Write(Message* m, const param_type& p) {
 #if defined(OS_WIN)
   // On Windows marshalling pipe handle is not supported.
   DCHECK(p.pipe.handle == NULL);
 #endif  // defined (OS_WIN)
   WriteParam(m, p.name);
 #if defined(OS_POSIX)
   WriteParam(m, p.socket);
@@ skipping 61 matching lines @@
   // Don't just write out the message. This is used to send messages between
   // NaCl (Posix environment) and the browser (could be on Windows). The message
   // header formats differ between these systems (so does handle sharing, but
   // we already asserted we don't have any handles). So just write out the
   // parts of the header we use.
   //
   // Be careful also to use only explicitly-sized types. The NaCl environment
   // could be 64-bit and the host browser could be 32-bits. The nested message
   // may or may not be safe to send between 32-bit and 64-bit systems, but we
   // leave that up to the code sending the message to ensure.
-  m->WriteUInt32(static_cast<uint32>(p.routing_id()));
+  m->WriteUInt32(static_cast<uint32_t>(p.routing_id()));
   m->WriteUInt32(p.type());
   m->WriteUInt32(p.flags());
-  m->WriteData(p.payload(), static_cast<uint32>(p.payload_size()));
+  m->WriteData(p.payload(), static_cast<uint32_t>(p.payload_size()));
 }
 
 bool ParamTraits<Message>::Read(const Message* m,
                                 base::PickleIterator* iter,
                                 Message* r) {
-  uint32 routing_id, type, flags;
+  uint32_t routing_id, type, flags;
   if (!iter->ReadUInt32(&routing_id) ||
       !iter->ReadUInt32(&type) ||
       !iter->ReadUInt32(&flags))
     return false;
 
   int payload_size;
   const char* payload;
   if (!iter->ReadData(&payload, &payload_size))
     return false;
 
-  r->SetHeaderValues(static_cast<int32>(routing_id), type, flags);
+  r->SetHeaderValues(static_cast<int32_t>(routing_id), type, flags);
   return r->WriteBytes(payload, payload_size);
 }
 
 void ParamTraits<Message>::Log(const Message& p, std::string* l) {
   l->append("<IPC::Message>");
 }
 
 #if defined(OS_WIN)
 // Note that HWNDs/HANDLE/HCURSOR/HACCEL etc are always 32 bits, even on 64
 // bit systems. That's why we use the Windows macros to convert to 32 bits.
 void ParamTraits<HANDLE>::Write(Message* m, const param_type& p) {
   m->WriteInt(HandleToLong(p));
 }
 
 bool ParamTraits<HANDLE>::Read(const Message* m,
                                base::PickleIterator* iter,
                                param_type* r) {
-  int32 temp;
+  int32_t temp;
   if (!iter->ReadInt(&temp))
     return false;
   *r = LongToHandle(temp);
   return true;
 }
 
 void ParamTraits<HANDLE>::Log(const param_type& p, std::string* l) {
   l->append(base::StringPrintf("0x%X", p));
 }
 
@@ skipping 42 matching lines @@
   return result;
 }
 
 void ParamTraits<MSG>::Log(const param_type& p, std::string* l) {
   l->append("<MSG>");
 }
 
 #endif  // OS_WIN
 
 }  // namespace IPC