Use suffixed {uint,int}{8,16,32,64}_t types.

talk/media/base/rtpdump_unittest.cc

 /*
  * libjingle
  * Copyright 2004 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 18 matching lines @@
 
 #include "talk/media/base/rtpdump.h"
 #include "talk/media/base/rtputils.h"
 #include "talk/media/base/testutils.h"
 #include "webrtc/base/bytebuffer.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/thread.h"
 
 namespace cricket {
 
-static const uint32 kTestSsrc = 1;
+static const uint32_t kTestSsrc = 1;
 
 // Test that we read the correct header fields from the RTP/RTCP packet.
 TEST(RtpDumpTest, ReadRtpDumpPacket) {
   rtc::ByteBuffer rtp_buf;
   RtpTestUtility::kTestRawRtpPackets[0].WriteToByteBuffer(kTestSsrc, &rtp_buf);
   RtpDumpPacket rtp_packet(rtp_buf.Data(), rtp_buf.Length(), 0, false);
 
   int payload_type;
   int seq_num;
-  uint32 ts;
-  uint32 ssrc;
+  uint32_t ts;
+  uint32_t ssrc;
   int rtcp_type;
   EXPECT_FALSE(rtp_packet.is_rtcp());
   EXPECT_TRUE(rtp_packet.IsValidRtpPacket());
   EXPECT_FALSE(rtp_packet.IsValidRtcpPacket());
   EXPECT_TRUE(rtp_packet.GetRtpPayloadType(&payload_type));
   EXPECT_EQ(0, payload_type);
   EXPECT_TRUE(rtp_packet.GetRtpSeqNum(&seq_num));
   EXPECT_EQ(0, seq_num);
   EXPECT_TRUE(rtp_packet.GetRtpTimestamp(&ts));
   EXPECT_EQ(0U, ts);
@@ skipping 61 matching lines @@
   ASSERT_TRUE(RtpTestUtility::WriteTestPackets(
       RtpTestUtility::GetTestPacketCount(), false, kTestSsrc, &writer));
   EXPECT_TRUE(RtpTestUtility::VerifyTestPacketsFromStream(
       RtpTestUtility::GetTestPacketCount(), &stream, kTestSsrc));
 
   // Check stream has only RtpTestUtility::GetTestPacketCount() packets.
   RtpDumpPacket packet;
   RtpDumpReader reader(&stream);
   for (size_t i = 0; i < RtpTestUtility::GetTestPacketCount(); ++i) {
     EXPECT_EQ(rtc::SR_SUCCESS, reader.ReadPacket(&packet));
-    uint32 ssrc;
+    uint32_t ssrc;
     EXPECT_TRUE(GetRtpSsrc(&packet.data[0], packet.data.size(), &ssrc));
     EXPECT_EQ(kTestSsrc, ssrc);
   }
   // No more packets to read.
   EXPECT_EQ(rtc::SR_EOS, reader.ReadPacket(&packet));
 
   // Rewind the stream and read again with a specified ssrc.
   stream.Rewind();
   RtpDumpReader reader_w_ssrc(&stream);
-  const uint32 send_ssrc = kTestSsrc + 1;
+  const uint32_t send_ssrc = kTestSsrc + 1;
   reader_w_ssrc.SetSsrc(send_ssrc);
   for (size_t i = 0; i < RtpTestUtility::GetTestPacketCount(); ++i) {
     EXPECT_EQ(rtc::SR_SUCCESS, reader_w_ssrc.ReadPacket(&packet));
     EXPECT_FALSE(packet.is_rtcp());
     EXPECT_EQ(packet.original_data_len, packet.data.size());
-    uint32 ssrc;
+    uint32_t ssrc;
     EXPECT_TRUE(GetRtpSsrc(&packet.data[0], packet.data.size(), &ssrc));
     EXPECT_EQ(send_ssrc, ssrc);
   }
   // No more packets to read.
   EXPECT_EQ(rtc::SR_EOS, reader_w_ssrc.ReadPacket(&packet));
 }
 
 // Test that we read the same RTCP packets that rtp dump writes.
 TEST(RtpDumpTest, WriteReadSameRtcp) {
   rtc::MemoryStream stream;
@@ skipping 130 matching lines @@
 
   // The loop reader reads three packets from the input stream.
   stream.Rewind();
   RtpDumpLoopReader loop_reader(&stream);
   EXPECT_EQ(rtc::SR_SUCCESS, loop_reader.ReadPacket(&packet));
   EXPECT_EQ(rtc::SR_SUCCESS, loop_reader.ReadPacket(&packet));
   EXPECT_EQ(rtc::SR_SUCCESS, loop_reader.ReadPacket(&packet));
 }
 
 }  // namespace cricket