Switch to standard integer types in media/.

media/cast/net/rtcp/rtcp_unittest.cc

 // Copyright 2014 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 <stdint.h>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "media/cast/net/cast_transport_config.h"
 #include "media/cast/net/pacing/paced_sender.h"
 #include "media/cast/net/rtcp/rtcp.h"
 #include "media/cast/net/rtcp/rtcp_utility.h"
 #include "media/cast/test/skewed_tick_clock.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 namespace media {
 namespace cast {
 
 using testing::_;
 
-static const uint32 kSenderSsrc = 0x10203;
-static const uint32 kReceiverSsrc = 0x40506;
+static const uint32_t kSenderSsrc = 0x10203;
+static const uint32_t kReceiverSsrc = 0x40506;
 static const int kInitialReceiverClockOffsetSeconds = -5;
 
 class FakeRtcpTransport : public PacedPacketSender {
  public:
   explicit FakeRtcpTransport(base::SimpleTestTickClock* clock)
       : clock_(clock),
         packet_delay_(base::TimeDelta::FromMilliseconds(42)),
         paused_(false) {}
 
   void set_rtcp_destination(Rtcp* rtcp) { rtcp_ = rtcp; }
 
   base::TimeDelta packet_delay() const { return packet_delay_; }
   void set_packet_delay(base::TimeDelta delay) { packet_delay_ = delay; }
 
-  bool SendRtcpPacket(uint32 ssrc, PacketRef packet) final {
+  bool SendRtcpPacket(uint32_t ssrc, PacketRef packet) final {
     clock_->Advance(packet_delay_);
     if (paused_) {
       packet_queue_.push_back(packet);
     } else {
       rtcp_->IncomingRtcpPacket(&packet->data[0], packet->data.size());
     }
     return true;
   }
 
   bool SendPackets(const SendPacketVector& packets) final { return false; }
@@ skipping 87 matching lines @@
   Rtcp rtcp_for_sender_;
   Rtcp rtcp_for_receiver_;
 
   DISALLOW_COPY_AND_ASSIGN(RtcpTest);
 };
 
 TEST_F(RtcpTest, LipSyncGleanedFromSenderReport) {
   // Initially, expect no lip-sync info receiver-side without having first
   // received a RTCP packet.
   base::TimeTicks reference_time;
-  uint32 rtp_timestamp;
+  uint32_t rtp_timestamp;
   ASSERT_FALSE(rtcp_for_receiver_.GetLatestLipSyncTimes(&rtp_timestamp,
                                                         &reference_time));
 
   // Send a Sender Report to the receiver.
   const base::TimeTicks reference_time_sent = sender_clock_->NowTicks();
-  const uint32 rtp_timestamp_sent = 0xbee5;
+  const uint32_t rtp_timestamp_sent = 0xbee5;
   rtcp_for_sender_.SendRtcpFromRtpSender(
       reference_time_sent, rtp_timestamp_sent, 1, 1);
 
   // Now the receiver should have lip-sync info.  Confirm that the lip-sync
   // reference time is the same as that sent.
   EXPECT_TRUE(rtcp_for_receiver_.GetLatestLipSyncTimes(&rtp_timestamp,
                                                        &reference_time));
   const base::TimeTicks rolled_back_time =
       (reference_time -
        // Roll-back relative clock offset:
@@ skipping 23 matching lines @@
   base::TimeDelta expected_rtt_according_to_sender;
   base::TimeDelta expected_rtt_according_to_receiver;
   for (int i = 0; i < iterations; ++i) {
     const base::TimeDelta one_way_trip_time =
         base::TimeDelta::FromMilliseconds(1 << i);
     sender_to_receiver_.set_packet_delay(one_way_trip_time);
     receiver_to_sender_.set_packet_delay(one_way_trip_time);
 
     // Sender --> Receiver
     base::TimeTicks reference_time_sent = sender_clock_->NowTicks();
-    uint32 rtp_timestamp_sent = 0xbee5 + i;
+    uint32_t rtp_timestamp_sent = 0xbee5 + i;
     rtcp_for_sender_.SendRtcpFromRtpSender(
         reference_time_sent, rtp_timestamp_sent, 1, 1);
     EXPECT_EQ(expected_rtt_according_to_sender,
               rtcp_for_sender_.current_round_trip_time());
 #ifdef SENDER_PROVIDES_REPORT_BLOCK
     EXPECT_EQ(expected_rtt_according_to_receiver,
               rtcp_for_receiver_.current_round_trip_time());
 #endif
 
     // Receiver --> Sender
@@ skipping 53 matching lines @@
       &cast_message, base::TimeDelta(), NULL, NULL);
 
   cast_message.ack_frame_id = 1;
   rtcp_for_receiver_.SendRtcpFromRtpReceiver(
       rtcp_for_receiver_.ConvertToNTPAndSave(base::TimeTicks()),
       &cast_message, base::TimeDelta(), NULL, NULL);
 }
 
 // TODO(miu): Find a better home for this test.
 TEST(MisplacedCastTest, NtpAndTime) {
-  const int64 kSecondsbetweenYear1900and2010 = INT64_C(40176 * 24 * 60 * 60);
-  const int64 kSecondsbetweenYear1900and2030 = INT64_C(47481 * 24 * 60 * 60);
+  const int64_t kSecondsbetweenYear1900and2010 = INT64_C(40176 * 24 * 60 * 60);
+  const int64_t kSecondsbetweenYear1900and2030 = INT64_C(47481 * 24 * 60 * 60);
 
-  uint32 ntp_seconds_1 = 0;
-  uint32 ntp_fraction_1 = 0;
+  uint32_t ntp_seconds_1 = 0;
+  uint32_t ntp_fraction_1 = 0;
   base::TimeTicks input_time = base::TimeTicks::Now();
   ConvertTimeTicksToNtp(input_time, &ntp_seconds_1, &ntp_fraction_1);
 
   // Verify absolute value.
   EXPECT_GT(ntp_seconds_1, kSecondsbetweenYear1900and2010);
   EXPECT_LT(ntp_seconds_1, kSecondsbetweenYear1900and2030);
 
   base::TimeTicks out_1 = ConvertNtpToTimeTicks(ntp_seconds_1, ntp_fraction_1);
   EXPECT_EQ(input_time, out_1);  // Verify inverse.
 
   base::TimeDelta time_delta = base::TimeDelta::FromMilliseconds(1000);
   input_time += time_delta;
 
-  uint32 ntp_seconds_2 = 0;
-  uint32 ntp_fraction_2 = 0;
+  uint32_t ntp_seconds_2 = 0;
+  uint32_t ntp_fraction_2 = 0;
 
   ConvertTimeTicksToNtp(input_time, &ntp_seconds_2, &ntp_fraction_2);
   base::TimeTicks out_2 = ConvertNtpToTimeTicks(ntp_seconds_2, ntp_fraction_2);
   EXPECT_EQ(input_time, out_2);  // Verify inverse.
 
   // Verify delta.
   EXPECT_EQ((out_2 - out_1), time_delta);
   EXPECT_EQ((ntp_seconds_2 - ntp_seconds_1), UINT32_C(1));
   EXPECT_NEAR(ntp_fraction_2, ntp_fraction_1, 1);
 
   time_delta = base::TimeDelta::FromMilliseconds(500);
   input_time += time_delta;
 
-  uint32 ntp_seconds_3 = 0;
-  uint32 ntp_fraction_3 = 0;
+  uint32_t ntp_seconds_3 = 0;
+  uint32_t ntp_fraction_3 = 0;
 
   ConvertTimeTicksToNtp(input_time, &ntp_seconds_3, &ntp_fraction_3);
   base::TimeTicks out_3 = ConvertNtpToTimeTicks(ntp_seconds_3, ntp_fraction_3);
   EXPECT_EQ(input_time, out_3);  // Verify inverse.
 
   // Verify delta.
   EXPECT_EQ((out_3 - out_2), time_delta);
   EXPECT_NEAR((ntp_fraction_3 - ntp_fraction_2), 0xffffffff / 2, 1);
 }
 
 }  // namespace cast
 }  // namespace media