Switch to standard integer types in media/.

media/cast/net/pacing/paced_sender_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 "base/big_endian.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "media/cast/net/pacing/paced_sender.h"
 #include "media/cast/test/fake_single_thread_task_runner.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using testing::_;
 
 namespace media {
 namespace cast {
 namespace {
 
-static const uint8 kValue = 123;
+static const uint8_t kValue = 123;
 static const size_t kSize1 = 101;
 static const size_t kSize2 = 102;
 static const size_t kSize3 = 103;
 static const size_t kSize4 = 104;
 static const size_t kNackSize = 105;
-static const int64 kStartMillisecond = INT64_C(12345678900000);
-static const uint32 kVideoSsrc = 0x1234;
-static const uint32 kAudioSsrc = 0x5678;
-static const uint32 kFrameRtpTimestamp = 12345;
+static const int64_t kStartMillisecond = INT64_C(12345678900000);
+static const uint32_t kVideoSsrc = 0x1234;
+static const uint32_t kAudioSsrc = 0x5678;
+static const uint32_t kFrameRtpTimestamp = 12345;
 
 class TestPacketSender : public PacketSender {
  public:
   TestPacketSender() : bytes_sent_(0) {}
 
   bool SendPacket(PacketRef packet, const base::Closure& cb) final {
     EXPECT_FALSE(expected_packet_size_.empty());
     size_t expected_packet_size = expected_packet_size_.front();
     expected_packet_size_.pop_front();
     EXPECT_EQ(expected_packet_size, packet->data.size());
     bytes_sent_ += packet->data.size();
     return true;
   }
 
-  int64 GetBytesSent() final { return bytes_sent_; }
+  int64_t GetBytesSent() final { return bytes_sent_; }
 
   void AddExpectedSize(int expected_packet_size, int repeat_count) {
     for (int i = 0; i < repeat_count; ++i) {
       expected_packet_size_.push_back(expected_packet_size);
     }
   }
 
  public:
   std::list<int> expected_packet_size_;
-  int64 bytes_sent_;
+  int64_t bytes_sent_;
 
   DISALLOW_COPY_AND_ASSIGN(TestPacketSender);
 };
 
 class PacedSenderTest : public ::testing::Test {
  protected:
   PacedSenderTest() : frame_id_(0) {
     testing_clock_.Advance(
         base::TimeDelta::FromMilliseconds(kStartMillisecond));
     task_runner_ = new test::FakeSingleThreadTaskRunner(&testing_clock_);
@@ skipping 52 matching lines @@
     }
 
     return mock_transport_.expected_packet_size_.empty();
   }
 
   std::vector<PacketEvent> packet_events_;
   base::SimpleTestTickClock testing_clock_;
   TestPacketSender mock_transport_;
   scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner_;
   scoped_ptr<PacedSender> paced_sender_;
-  uint32 frame_id_;
+  uint32_t frame_id_;
 
   DISALLOW_COPY_AND_ASSIGN(PacedSenderTest);
 };
 
 }  // namespace
 
 TEST_F(PacedSenderTest, PassThroughRtcp) {
   mock_transport_.AddExpectedSize(kSize1, 2);
   SendPacketVector packets = CreateSendPacketVector(kSize1, 1, true);
 
@@ skipping 33 matching lines @@
   mock_transport_.AddExpectedSize(kSize1, 7);
   testing_clock_.Advance(timeout);
   task_runner_->RunTasks();
 
   // Check that we don't get any more packets.
   EXPECT_TRUE(RunUntilEmpty(3));
   const base::TimeTicks latest_event_timestamp = testing_clock_.NowTicks();
 
   // Check that packet logging events match expected values.
   EXPECT_EQ(num_of_packets, static_cast<int>(packet_events_.size()));
-  uint16 expected_packet_id = 0;
+  uint16_t expected_packet_id = 0;
   for (const PacketEvent& e : packet_events_) {
     ASSERT_LE(earliest_event_timestamp, e.timestamp);
     ASSERT_GE(latest_event_timestamp, e.timestamp);
     ASSERT_EQ(PACKET_SENT_TO_NETWORK, e.type);
     ASSERT_EQ(VIDEO_EVENT, e.media_type);
     ASSERT_EQ(kFrameRtpTimestamp, e.rtp_timestamp);
     ASSERT_EQ(num_of_packets - 1, e.max_packet_id);
     ASSERT_EQ(expected_packet_id++, e.packet_id);
     ASSERT_EQ(kSize1, e.size);
   }
@@ skipping 209 matching lines @@
   EXPECT_TRUE(RunUntilEmpty(4));
 }
 
 TEST_F(PacedSenderTest, GetLastByteSent) {
   mock_transport_.AddExpectedSize(kSize1, 4);
 
   SendPacketVector packets1 = CreateSendPacketVector(kSize1, 1, true);
   SendPacketVector packets2 = CreateSendPacketVector(kSize1, 1, false);
 
   EXPECT_TRUE(paced_sender_->SendPackets(packets1));
-  EXPECT_EQ(static_cast<int64>(kSize1),
+  EXPECT_EQ(static_cast<int64_t>(kSize1),
             paced_sender_->GetLastByteSentForPacket(packets1[0].first));
-  EXPECT_EQ(static_cast<int64>(kSize1),
+  EXPECT_EQ(static_cast<int64_t>(kSize1),
             paced_sender_->GetLastByteSentForSsrc(kAudioSsrc));
   EXPECT_EQ(0, paced_sender_->GetLastByteSentForSsrc(kVideoSsrc));
 
   EXPECT_TRUE(paced_sender_->SendPackets(packets2));
-  EXPECT_EQ(static_cast<int64>(2 * kSize1),
+  EXPECT_EQ(static_cast<int64_t>(2 * kSize1),
             paced_sender_->GetLastByteSentForPacket(packets2[0].first));
-  EXPECT_EQ(static_cast<int64>(kSize1),
+  EXPECT_EQ(static_cast<int64_t>(kSize1),
             paced_sender_->GetLastByteSentForSsrc(kAudioSsrc));
-  EXPECT_EQ(static_cast<int64>(2 * kSize1),
+  EXPECT_EQ(static_cast<int64_t>(2 * kSize1),
             paced_sender_->GetLastByteSentForSsrc(kVideoSsrc));
 
   EXPECT_TRUE(paced_sender_->ResendPackets(packets1, DedupInfo()));
-  EXPECT_EQ(static_cast<int64>(3 * kSize1),
+  EXPECT_EQ(static_cast<int64_t>(3 * kSize1),
             paced_sender_->GetLastByteSentForPacket(packets1[0].first));
-  EXPECT_EQ(static_cast<int64>(3 * kSize1),
+  EXPECT_EQ(static_cast<int64_t>(3 * kSize1),
             paced_sender_->GetLastByteSentForSsrc(kAudioSsrc));
-  EXPECT_EQ(static_cast<int64>(2 * kSize1),
+  EXPECT_EQ(static_cast<int64_t>(2 * kSize1),
             paced_sender_->GetLastByteSentForSsrc(kVideoSsrc));
 
   EXPECT_TRUE(paced_sender_->ResendPackets(packets2, DedupInfo()));
-  EXPECT_EQ(static_cast<int64>(4 * kSize1),
+  EXPECT_EQ(static_cast<int64_t>(4 * kSize1),
             paced_sender_->GetLastByteSentForPacket(packets2[0].first));
-  EXPECT_EQ(static_cast<int64>(3 * kSize1),
+  EXPECT_EQ(static_cast<int64_t>(3 * kSize1),
             paced_sender_->GetLastByteSentForSsrc(kAudioSsrc));
-  EXPECT_EQ(static_cast<int64>(4 * kSize1),
+  EXPECT_EQ(static_cast<int64_t>(4 * kSize1),
             paced_sender_->GetLastByteSentForSsrc(kVideoSsrc));
 }
 
 TEST_F(PacedSenderTest, DedupWithResendInterval) {
   mock_transport_.AddExpectedSize(kSize1, 2);
 
   SendPacketVector packets = CreateSendPacketVector(kSize1, 1, true);
   EXPECT_TRUE(paced_sender_->SendPackets(packets));
   testing_clock_.Advance(base::TimeDelta::FromMilliseconds(10));
 
   DedupInfo dedup_info;
   dedup_info.resend_interval = base::TimeDelta::FromMilliseconds(20);
 
   // This packet will not be sent.
   EXPECT_TRUE(paced_sender_->ResendPackets(packets, dedup_info));
-  EXPECT_EQ(static_cast<int64>(kSize1), mock_transport_.GetBytesSent());
+  EXPECT_EQ(static_cast<int64_t>(kSize1), mock_transport_.GetBytesSent());
 
   dedup_info.resend_interval = base::TimeDelta::FromMilliseconds(5);
   EXPECT_TRUE(paced_sender_->ResendPackets(packets, dedup_info));
-  EXPECT_EQ(static_cast<int64>(2 * kSize1), mock_transport_.GetBytesSent());
+  EXPECT_EQ(static_cast<int64_t>(2 * kSize1), mock_transport_.GetBytesSent());
 }
 
 }  // namespace cast
 }  // namespace media