Switch to standard integer types in media/.

media/cast/net/rtcp/rtcp_builder_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 "base/memory/scoped_ptr.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "media/cast/cast_environment.h"
 #include "media/cast/net/cast_transport_config.h"
 #include "media/cast/net/cast_transport_defines.h"
 #include "media/cast/net/pacing/paced_sender.h"
 #include "media/cast/net/rtcp/receiver_rtcp_event_subscriber.h"
 #include "media/cast/net/rtcp/rtcp_builder.h"
 #include "media/cast/net/rtcp/rtcp_utility.h"
 #include "media/cast/net/rtcp/test_rtcp_packet_builder.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 namespace media {
 namespace cast {
 
 namespace {
-static const uint32 kSendingSsrc = 0x12345678;
-static const uint32 kMediaSsrc = 0x87654321;
+static const uint32_t kSendingSsrc = 0x12345678;
+static const uint32_t kMediaSsrc = 0x87654321;
 static const base::TimeDelta kDefaultDelay =
     base::TimeDelta::FromMilliseconds(100);
 
 RtcpReportBlock GetReportBlock() {
   RtcpReportBlock report_block;
   // Initialize remote_ssrc to a "clearly illegal" value.
   report_block.remote_ssrc = 0xDEAD;
   report_block.media_ssrc = kMediaSsrc;  // SSRC of the RTP packet sender.
   report_block.fraction_lost = kLoss >> 24;
   report_block.cumulative_lost = kLoss;  // 24 bits valid.
@@ skipping 127 matching lines @@
   ExpectPacketEQ(p.GetPacket().Pass(),
                  rtcp_builder_->BuildRtcpFromReceiver(
                      &report_block,
                      &rrtr,
                      &cast_message,
                      NULL,
                      kDefaultDelay));
 }
 
 TEST_F(RtcpBuilderTest, RtcpReceiverReportWithRrtrCastMessageAndLog) {
-  static const uint32 kTimeBaseMs = 12345678;
-  static const uint32 kTimeDelayMs = 10;
+  static const uint32_t kTimeBaseMs = 12345678;
+  static const uint32_t kTimeDelayMs = 10;
 
   TestRtcpPacketBuilder p;
   p.AddRr(kSendingSsrc, 1);
   p.AddRb(kMediaSsrc);
   p.AddXrHeader(kSendingSsrc);
   p.AddXrRrtrBlock();
   p.AddCast(kSendingSsrc, kMediaSsrc, kDefaultDelay);
 
   RtcpReportBlock report_block = GetReportBlock();
 
@@ skipping 53 matching lines @@
       p.GetPacket().Pass(),
       rtcp_builder_->BuildRtcpFromReceiver(
           &report_block,
           &rrtr,
           &cast_message,
           &rtcp_events,
           kDefaultDelay));
 }
 
 TEST_F(RtcpBuilderTest, RtcpReceiverReportWithOversizedFrameLog) {
-  static const uint32 kTimeBaseMs = 12345678;
-  static const uint32 kTimeDelayMs = 10;
+  static const uint32_t kTimeBaseMs = 12345678;
+  static const uint32_t kTimeDelayMs = 10;
 
   TestRtcpPacketBuilder p;
   p.AddRr(kSendingSsrc, 1);
   p.AddRb(kMediaSsrc);
 
   RtcpReportBlock report_block = GetReportBlock();
 
   base::SimpleTestTickClock testing_clock;
   testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs));
 
   p.AddReceiverLog(kSendingSsrc);
 
   int num_events = kMaxEventsPerRTCP;
 
   EXPECT_LE(num_events, static_cast<int>(kRtcpMaxReceiverLogMessages));
   p.AddReceiverFrameLog(
       kRtpTimestamp + 2345,
       num_events,
       kTimeBaseMs);
   for (int i = 0; i < num_events; i++) {
-    p.AddReceiverEventLog(
-        kLostPacketId1,
-        PACKET_RECEIVED,
-        static_cast<uint16>(kTimeDelayMs * i));
+    p.AddReceiverEventLog(kLostPacketId1, PACKET_RECEIVED,
+                          static_cast<uint16_t>(kTimeDelayMs * i));
   }
 
 
   ReceiverRtcpEventSubscriber event_subscriber(500, VIDEO_EVENT);
 
   for (size_t i = 0; i < kRtcpMaxReceiverLogMessages; ++i) {
     PacketEvent packet_event;
     packet_event.rtp_timestamp = kRtpTimestamp + 2345;
     packet_event.type = PACKET_RECEIVED;
     packet_event.media_type = VIDEO_EVENT;
     packet_event.timestamp = testing_clock.NowTicks();
     packet_event.packet_id = kLostPacketId1;
     event_subscriber.OnReceivePacketEvent(packet_event);
     testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs));
   }
 
   ReceiverRtcpEventSubscriber::RtcpEvents rtcp_events;
   event_subscriber.GetRtcpEventsWithRedundancy(&rtcp_events);
 
   ExpectPacketEQ(p.GetPacket().Pass(),
                  rtcp_builder_->BuildRtcpFromReceiver(
                      &report_block,
                      NULL,
                      NULL,
                      &rtcp_events,
                      kDefaultDelay));
 }
 
 TEST_F(RtcpBuilderTest, RtcpReceiverReportWithTooManyLogFrames) {
-  static const uint32 kTimeBaseMs = 12345678;
-  static const uint32 kTimeDelayMs = 10;
+  static const uint32_t kTimeBaseMs = 12345678;
+  static const uint32_t kTimeDelayMs = 10;
 
   TestRtcpPacketBuilder p;
   p.AddRr(kSendingSsrc, 1);
   p.AddRb(kMediaSsrc);
 
   RtcpReportBlock report_block = GetReportBlock();
 
   base::SimpleTestTickClock testing_clock;
   testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs));
 
@@ skipping 24 matching lines @@
   ExpectPacketEQ(p.GetPacket().Pass(),
                  rtcp_builder_->BuildRtcpFromReceiver(
                      &report_block,
                      NULL,
                      NULL,
                      &rtcp_events,
                      kDefaultDelay));
 }
 
 TEST_F(RtcpBuilderTest, RtcpReceiverReportWithOldLogFrames) {
-  static const uint32 kTimeBaseMs = 12345678;
+  static const uint32_t kTimeBaseMs = 12345678;
 
   TestRtcpPacketBuilder p;
   p.AddRr(kSendingSsrc, 1);
   p.AddRb(kMediaSsrc);
 
   RtcpReportBlock report_block = GetReportBlock();
 
   base::SimpleTestTickClock testing_clock;
   testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs));
 
@@ skipping 26 matching lines @@
   ExpectPacketEQ(p.GetPacket().Pass(),
                  rtcp_builder_->BuildRtcpFromReceiver(
                      &report_block,
                      NULL,
                      NULL,
                      &rtcp_events,
                      kDefaultDelay));
 }
 
 TEST_F(RtcpBuilderTest, RtcpReceiverReportRedundancy) {
-  uint32 time_base_ms = 12345678;
+  uint32_t time_base_ms = 12345678;
   int kTimeBetweenEventsMs = 10;
 
   RtcpReportBlock report_block = GetReportBlock();
 
   base::SimpleTestTickClock testing_clock;
   testing_clock.Advance(base::TimeDelta::FromMilliseconds(time_base_ms));
 
   ReceiverRtcpEventSubscriber event_subscriber(500, VIDEO_EVENT);
   size_t packet_count = kNumResends * kResendDelay + 10;
   for (size_t i = 0; i < packet_count; i++) {
     TestRtcpPacketBuilder p;
     p.AddRr(kSendingSsrc, 1);
     p.AddRb(kMediaSsrc);
 
     p.AddReceiverLog(kSendingSsrc);
 
     int num_events = (i + kResendDelay) / kResendDelay;
     num_events = std::min<int>(num_events, kNumResends);
     p.AddReceiverFrameLog(kRtpTimestamp, num_events,
         time_base_ms - (num_events - 1) * kResendDelay *
         kTimeBetweenEventsMs);
     for (int i = 0; i < num_events; i++) {
-      p.AddReceiverEventLog(
-          0, FRAME_ACK_SENT,
-          base::checked_cast<uint16>(i * kResendDelay * kTimeBetweenEventsMs));
+      p.AddReceiverEventLog(0, FRAME_ACK_SENT,
+                            base::checked_cast<uint16_t>(i * kResendDelay *
+                                                         kTimeBetweenEventsMs));
     }
 
     FrameEvent frame_event;
     frame_event.rtp_timestamp = kRtpTimestamp;
     frame_event.type = FRAME_ACK_SENT;
     frame_event.media_type = VIDEO_EVENT;
     frame_event.timestamp = testing_clock.NowTicks();
     event_subscriber.OnReceiveFrameEvent(frame_event);
 
     ReceiverRtcpEventSubscriber::RtcpEvents rtcp_events;
@@ skipping 24 matching lines @@
   // Sender report.
   TestRtcpPacketBuilder p;
   p.AddSr(kSendingSsrc, 0);
 
   ExpectPacketEQ(p.GetPacket().Pass(),
                  rtcp_builder_->BuildRtcpFromSender(sender_info));
 }
 
 }  // namespace cast
 }  // namespace media