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

talk/media/webrtc/webrtcvoiceengine_unittest.cc

 /*
  * libjingle
  * Copyright 2008 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 39 matching lines @@
 static const cricket::AudioCodec kG722CodecSdp(9, "G722", 8000, 64000, 1, 0);
 static const cricket::AudioCodec kRedCodec(117, "red", 8000, 0, 1, 0);
 static const cricket::AudioCodec kCn8000Codec(13, "CN", 8000, 0, 1, 0);
 static const cricket::AudioCodec kCn16000Codec(105, "CN", 16000, 0, 1, 0);
 static const cricket::AudioCodec
     kTelephoneEventCodec(106, "telephone-event", 8000, 0, 1, 0);
 static const cricket::AudioCodec* const kAudioCodecs[] = {
     &kPcmuCodec, &kIsacCodec, &kOpusCodec, &kG722CodecVoE, &kRedCodec,
     &kCn8000Codec, &kCn16000Codec, &kTelephoneEventCodec,
 };
-static uint32 kSsrc1 = 0x99;
-static uint32 kSsrc2 = 0x98;
+static uint32_t kSsrc1 = 0x99;
+static uint32_t kSsrc2 = 0x98;
 
 class FakeVoEWrapper : public cricket::VoEWrapper {
  public:
   explicit FakeVoEWrapper(cricket::FakeWebRtcVoiceEngine* engine)
       : cricket::VoEWrapper(engine,  // processing
                             engine,  // base
                             engine,  // codec
                             engine,  // dtmf
                             engine,  // hw
                             engine,  // neteq
@@ skipping 39 matching lines @@
     if (!SetupEngineWithoutStream()) {
       return false;
     }
     return channel_->AddSendStream(
         cricket::StreamParams::CreateLegacy(kSsrc1));
   }
   void SetupForMultiSendStream() {
     EXPECT_TRUE(SetupEngine());
     // Remove stream added in Setup, which is corresponding to default channel.
     int default_channel_num = voe_.GetLastChannel();
-    uint32 default_send_ssrc = 0u;
+    uint32_t default_send_ssrc = 0u;
     EXPECT_EQ(0, voe_.GetLocalSSRC(default_channel_num, default_send_ssrc));
     EXPECT_EQ(kSsrc1, default_send_ssrc);
     EXPECT_TRUE(channel_->RemoveSendStream(default_send_ssrc));
 
     // Verify the default channel still exists.
     EXPECT_EQ(0, voe_.GetLocalSSRC(default_channel_num, default_send_ssrc));
   }
   void DeliverPacket(const void* data, int len) {
     rtc::Buffer packet(reinterpret_cast<const uint8_t*>(data), len);
     channel_->OnPacketReceived(&packet, rtc::PacketTime());
   }
   void TearDown() override {
     delete channel_;
     engine_.Terminate();
   }
 
-  void TestInsertDtmf(uint32 ssrc, bool caller) {
+  void TestInsertDtmf(uint32_t ssrc, bool caller) {
     EXPECT_TRUE(engine_.Init(rtc::Thread::Current()));
     channel_ = engine_.CreateChannel(&call_, cricket::AudioOptions());
     EXPECT_TRUE(channel_ != nullptr);
     if (caller) {
       // if this is a caller, local description will be applied and add the
       // send stream.
       EXPECT_TRUE(channel_->AddSendStream(
           cricket::StreamParams::CreateLegacy(kSsrc1)));
     }
     int channel_id = voe_.GetLastChannel();
@@ skipping 1707 matching lines @@
   EXPECT_TRUE(channel_->SetSend(cricket::SEND_NOTHING));
   EXPECT_FALSE(voe_.GetSend(channel_num));
   EXPECT_TRUE(channel_->SetPlayout(false));
   EXPECT_FALSE(voe_.GetPlayout(channel_num));
 }
 
 // Test that we can add and remove send streams.
 TEST_F(WebRtcVoiceEngineTestFake, CreateAndDeleteMultipleSendStreams) {
   SetupForMultiSendStream();
 
-  static const uint32 kSsrcs4[] = {1, 2, 3, 4};
+  static const uint32_t kSsrcs4[] = {1, 2, 3, 4};
 
   // Set the global state for sending.
   EXPECT_TRUE(channel_->SetSend(cricket::SEND_MICROPHONE));
 
   for (unsigned int i = 0; i < ARRAY_SIZE(kSsrcs4); ++i) {
     EXPECT_TRUE(channel_->AddSendStream(
         cricket::StreamParams::CreateLegacy(kSsrcs4[i])));
 
     // Verify that we are in a sending state for all the created streams.
     int channel_num = voe_.GetChannelFromLocalSsrc(kSsrcs4[i]);
@@ skipping 14 matching lines @@
     // Stream should already be deleted.
     EXPECT_FALSE(channel_->RemoveSendStream(kSsrcs4[i]));
     EXPECT_EQ(-1, voe_.GetChannelFromLocalSsrc(kSsrcs4[i]));
   }
 }
 
 // Test SetSendCodecs correctly configure the codecs in all send streams.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsWithMultipleSendStreams) {
   SetupForMultiSendStream();
 
-  static const uint32 kSsrcs4[] = {1, 2, 3, 4};
+  static const uint32_t kSsrcs4[] = {1, 2, 3, 4};
   // Create send streams.
   for (unsigned int i = 0; i < ARRAY_SIZE(kSsrcs4); ++i) {
     EXPECT_TRUE(channel_->AddSendStream(
         cricket::StreamParams::CreateLegacy(kSsrcs4[i])));
   }
 
   cricket::AudioSendParameters parameters;
   // Set ISAC(16K) and CN(16K). VAD should be activated.
   parameters.codecs.push_back(kIsacCodec);
   parameters.codecs.push_back(kCn16000Codec);
@@ skipping 18 matching lines @@
     EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
     EXPECT_STREQ("PCMU", gcodec.plname);
     EXPECT_FALSE(voe_.GetVAD(channel_num));
   }
 }
 
 // Test we can SetSend on all send streams correctly.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendWithMultipleSendStreams) {
   SetupForMultiSendStream();
 
-  static const uint32 kSsrcs4[] = {1, 2, 3, 4};
+  static const uint32_t kSsrcs4[] = {1, 2, 3, 4};
   // Create the send channels and they should be a SEND_NOTHING date.
   for (unsigned int i = 0; i < ARRAY_SIZE(kSsrcs4); ++i) {
     EXPECT_TRUE(channel_->AddSendStream(
         cricket::StreamParams::CreateLegacy(kSsrcs4[i])));
     int channel_num = voe_.GetLastChannel();
     EXPECT_FALSE(voe_.GetSend(channel_num));
   }
 
   // Set the global state for starting sending.
   EXPECT_TRUE(channel_->SetSend(cricket::SEND_MICROPHONE));
   for (unsigned int i = 0; i < ARRAY_SIZE(kSsrcs4); ++i) {
     // Verify that we are in a sending state for all the send streams.
     int channel_num = voe_.GetChannelFromLocalSsrc(kSsrcs4[i]);
     EXPECT_TRUE(voe_.GetSend(channel_num));
   }
 
   // Set the global state for stopping sending.
   EXPECT_TRUE(channel_->SetSend(cricket::SEND_NOTHING));
   for (unsigned int i = 1; i < ARRAY_SIZE(kSsrcs4); ++i) {
     // Verify that we are in a stop state for all the send streams.
     int channel_num = voe_.GetChannelFromLocalSsrc(kSsrcs4[i]);
     EXPECT_FALSE(voe_.GetSend(channel_num));
   }
 }
 
 // Test we can set the correct statistics on all send streams.
 TEST_F(WebRtcVoiceEngineTestFake, GetStatsWithMultipleSendStreams) {
   SetupForMultiSendStream();
 
-  static const uint32 kSsrcs4[] = {1, 2, 3, 4};
+  static const uint32_t kSsrcs4[] = {1, 2, 3, 4};
   // Create send streams.
   for (unsigned int i = 0; i < ARRAY_SIZE(kSsrcs4); ++i) {
     EXPECT_TRUE(channel_->AddSendStream(
         cricket::StreamParams::CreateLegacy(kSsrcs4[i])));
   }
   // Create a receive stream to check that none of the send streams end up in
   // the receive stream stats.
   EXPECT_TRUE(channel_->AddRecvStream(
       cricket::StreamParams::CreateLegacy(kSsrc2)));
   // We need send codec to be set to get all stats.
@@ skipping 403 matching lines @@
   EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
   int channel_num1 = voe_.GetLastChannel();
   EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2)));
   int channel_num2 = voe_.GetLastChannel();
   EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(3)));
   int channel_num3 = voe_.GetLastChannel();
   // Create packets with the right SSRCs.
   char packets[4][sizeof(kPcmuFrame)];
   for (size_t i = 0; i < ARRAY_SIZE(packets); ++i) {
     memcpy(packets[i], kPcmuFrame, sizeof(kPcmuFrame));
-    rtc::SetBE32(packets[i] + 8, static_cast<uint32>(i));
+    rtc::SetBE32(packets[i] + 8, static_cast<uint32_t>(i));
   }
   EXPECT_TRUE(voe_.CheckNoPacket(channel_num1));
   EXPECT_TRUE(voe_.CheckNoPacket(channel_num2));
   EXPECT_TRUE(voe_.CheckNoPacket(channel_num3));
   DeliverPacket(packets[0], sizeof(packets[0]));
   EXPECT_TRUE(voe_.CheckNoPacket(channel_num1));
   EXPECT_TRUE(voe_.CheckNoPacket(channel_num2));
   EXPECT_TRUE(voe_.CheckNoPacket(channel_num3));
   DeliverPacket(packets[1], sizeof(packets[1]));
   EXPECT_TRUE(voe_.CheckPacket(channel_num1, packets[1],
@@ skipping 509 matching lines @@
 
   EXPECT_TRUE(channel_->SetOutputScaling(kSsrc2, 2, 1));
   channel_id = voe_.GetLastChannel();
   EXPECT_EQ(0, voe_.GetChannelOutputVolumeScaling(channel_id, scale));
   EXPECT_EQ(0, voe_.GetOutputVolumePan(channel_id, left, right));
   EXPECT_DOUBLE_EQ(2, left * scale);
   EXPECT_DOUBLE_EQ(1, right * scale);
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, SetsSyncGroupFromSyncLabel) {
-  const uint32 kAudioSsrc = 123;
+  const uint32_t kAudioSsrc = 123;
   const std::string kSyncLabel = "AvSyncLabel";
 
   EXPECT_TRUE(SetupEngine());
   cricket::StreamParams sp = cricket::StreamParams::CreateLegacy(kAudioSsrc);
   sp.sync_label = kSyncLabel;
   // Creating two channels to make sure that sync label is set properly for both
   // the default voice channel and following ones.
   EXPECT_TRUE(channel_->AddRecvStream(sp));
   sp.ssrcs[0] += 1;
   EXPECT_TRUE(channel_->AddRecvStream(sp));
 
   ASSERT_EQ(2, call_.GetAudioReceiveStreams().size());
   EXPECT_EQ(kSyncLabel,
             call_.GetAudioReceiveStream(kAudioSsrc)->GetConfig().sync_group)
       << "SyncGroup should be set based on sync_label";
   EXPECT_EQ(kSyncLabel,
             call_.GetAudioReceiveStream(kAudioSsrc + 1)->GetConfig().sync_group)
       << "SyncGroup should be set based on sync_label";
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, CanChangeCombinedBweOption) {
   // Test that changing the combined_audio_video_bwe option results in the
   // expected state changes on an associated Call.
-  std::vector<uint32> ssrcs;
+  std::vector<uint32_t> ssrcs;
   ssrcs.push_back(223);
   ssrcs.push_back(224);
 
   EXPECT_TRUE(SetupEngine());
   cricket::WebRtcVoiceMediaChannel* media_channel =
       static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_);
-  for (uint32 ssrc : ssrcs) {
+  for (uint32_t ssrc : ssrcs) {
     EXPECT_TRUE(media_channel->AddRecvStream(
         cricket::StreamParams::CreateLegacy(ssrc)));
   }
   EXPECT_EQ(2, call_.GetAudioReceiveStreams().size());
 
   // Combined BWE should be disabled.
-  for (uint32 ssrc : ssrcs) {
+  for (uint32_t ssrc : ssrcs) {
     const auto* s = call_.GetAudioReceiveStream(ssrc);
     EXPECT_NE(nullptr, s);
     EXPECT_EQ(false, s->GetConfig().combined_audio_video_bwe);
   }
 
   // Enable combined BWE option - now it should be set up.
   send_parameters_.options.combined_audio_video_bwe.Set(true);
   EXPECT_TRUE(media_channel->SetSendParameters(send_parameters_));
-  for (uint32 ssrc : ssrcs) {
+  for (uint32_t ssrc : ssrcs) {
     const auto* s = call_.GetAudioReceiveStream(ssrc);
     EXPECT_NE(nullptr, s);
     EXPECT_EQ(true, s->GetConfig().combined_audio_video_bwe);
   }
 
   // Disable combined BWE option - should be disabled again.
   send_parameters_.options.combined_audio_video_bwe.Set(false);
   EXPECT_TRUE(media_channel->SetSendParameters(send_parameters_));
-  for (uint32 ssrc : ssrcs) {
+  for (uint32_t ssrc : ssrcs) {
     const auto* s = call_.GetAudioReceiveStream(ssrc);
     EXPECT_NE(nullptr, s);
     EXPECT_EQ(false, s->GetConfig().combined_audio_video_bwe);
   }
 
   EXPECT_EQ(2, call_.GetAudioReceiveStreams().size());
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, ConfigureCombinedBweForNewRecvStreams) {
   // Test that adding receive streams after enabling combined bandwidth
   // estimation will correctly configure each channel.
   EXPECT_TRUE(SetupEngine());
   cricket::WebRtcVoiceMediaChannel* media_channel =
       static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_);
   send_parameters_.options.combined_audio_video_bwe.Set(true);
   EXPECT_TRUE(media_channel->SetSendParameters(send_parameters_));
 
-  static const uint32 kSsrcs[] = {1, 2, 3, 4};
+  static const uint32_t kSsrcs[] = {1, 2, 3, 4};
   for (unsigned int i = 0; i < ARRAY_SIZE(kSsrcs); ++i) {
     EXPECT_TRUE(media_channel->AddRecvStream(
         cricket::StreamParams::CreateLegacy(kSsrcs[i])));
     EXPECT_NE(nullptr, call_.GetAudioReceiveStream(kSsrcs[i]));
   }
   EXPECT_EQ(ARRAY_SIZE(kSsrcs), call_.GetAudioReceiveStreams().size());
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, ConfiguresAudioReceiveStreamRtpExtensions) {
   // Test that setting the header extensions results in the expected state
   // changes on an associated Call.
-  std::vector<uint32> ssrcs;
+  std::vector<uint32_t> ssrcs;
   ssrcs.push_back(223);
   ssrcs.push_back(224);
 
   EXPECT_TRUE(SetupEngine());
   cricket::WebRtcVoiceMediaChannel* media_channel =
       static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_);
   send_parameters_.options.combined_audio_video_bwe.Set(true);
   EXPECT_TRUE(media_channel->SetSendParameters(send_parameters_));
-  for (uint32 ssrc : ssrcs) {
+  for (uint32_t ssrc : ssrcs) {
     EXPECT_TRUE(media_channel->AddRecvStream(
         cricket::StreamParams::CreateLegacy(ssrc)));
   }
 
   // Combined BWE should be set up, but with no configured extensions.
   EXPECT_EQ(2, call_.GetAudioReceiveStreams().size());
-  for (uint32 ssrc : ssrcs) {
+  for (uint32_t ssrc : ssrcs) {
     const auto* s = call_.GetAudioReceiveStream(ssrc);
     EXPECT_NE(nullptr, s);
     EXPECT_EQ(0, s->GetConfig().rtp.extensions.size());
   }
 
   // Set up receive extensions.
   const auto& e_exts = engine_.rtp_header_extensions();
   cricket::AudioRecvParameters recv_parameters;
   recv_parameters.extensions = e_exts;
   channel_->SetRecvParameters(recv_parameters);
   EXPECT_EQ(2, call_.GetAudioReceiveStreams().size());
-  for (uint32 ssrc : ssrcs) {
+  for (uint32_t ssrc : ssrcs) {
     const auto* s = call_.GetAudioReceiveStream(ssrc);
     EXPECT_NE(nullptr, s);
     const auto& s_exts = s->GetConfig().rtp.extensions;
     EXPECT_EQ(e_exts.size(), s_exts.size());
     for (const auto& e_ext : e_exts) {
       for (const auto& s_ext : s_exts) {
         if (e_ext.id == s_ext.id) {
           EXPECT_EQ(e_ext.uri, s_ext.name);
         }
       }
     }
   }
 
   // Disable receive extensions.
   channel_->SetRecvParameters(cricket::AudioRecvParameters());
-  for (uint32 ssrc : ssrcs) {
+  for (uint32_t ssrc : ssrcs) {
     const auto* s = call_.GetAudioReceiveStream(ssrc);
     EXPECT_NE(nullptr, s);
     EXPECT_EQ(0, s->GetConfig().rtp.extensions.size());
   }
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, DeliverAudioPacket_Call) {
   // Test that packets are forwarded to the Call when configured accordingly.
-  const uint32 kAudioSsrc = 1;
+  const uint32_t kAudioSsrc = 1;
   rtc::Buffer kPcmuPacket(kPcmuFrame, sizeof(kPcmuFrame));
   static const unsigned char kRtcp[] = {
     0x80, 0xc9, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
     0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
   };
   rtc::Buffer kRtcpPacket(kRtcp, sizeof(kRtcp));
 
   EXPECT_TRUE(SetupEngine());
@@ skipping 225 matching lines @@
   cricket::WebRtcVoiceEngine engine;
   EXPECT_TRUE(engine.Init(rtc::Thread::Current()));
   rtc::scoped_ptr<webrtc::Call> call(
       webrtc::Call::Create(webrtc::Call::Config()));
   cricket::WebRtcVoiceMediaChannel channel(&engine, cricket::AudioOptions(),
                                            call.get());
   cricket::AudioRecvParameters parameters;
   parameters.codecs = engine.codecs();
   EXPECT_TRUE(channel.SetRecvParameters(parameters));
 }