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

talk/session/media/channel_unittest.cc

 /*
  * libjingle
  * Copyright 2009 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 49 matching lines @@
 using cricket::StreamParams;
 using cricket::TransportChannel;
 using rtc::WindowId;
 
 static const cricket::AudioCodec kPcmuCodec(0, "PCMU", 64000, 8000, 1, 0);
 static const cricket::AudioCodec kPcmaCodec(8, "PCMA", 64000, 8000, 1, 0);
 static const cricket::AudioCodec kIsacCodec(103, "ISAC", 40000, 16000, 1, 0);
 static const cricket::VideoCodec kH264Codec(97, "H264", 640, 400, 30, 0);
 static const cricket::VideoCodec kH264SvcCodec(99, "H264-SVC", 320, 200, 15, 0);
 static const cricket::DataCodec kGoogleDataCodec(101, "google-data", 0);
-static const uint32 kSsrc1 = 0x1111;
-static const uint32 kSsrc2 = 0x2222;
-static const uint32 kSsrc3 = 0x3333;
+static const uint32_t kSsrc1 = 0x1111;
+static const uint32_t kSsrc2 = 0x2222;
+static const uint32_t kSsrc3 = 0x3333;
 static const int kAudioPts[] = {0, 8};
 static const int kVideoPts[] = {97, 99};
 
 template<class ChannelT,
          class MediaChannelT,
          class ContentT,
          class CodecT,
          class MediaInfoT,
          class OptionsT>
 class Traits {
@@ skipping 40 matching lines @@
       rtc::Pathname(path), "wb");
 }
 
 // Base class for Voice/VideoChannel tests
 template<class T>
 class ChannelTest : public testing::Test, public sigslot::has_slots<> {
  public:
   enum Flags { RTCP = 0x1, RTCP_MUX = 0x2, SECURE = 0x4, SSRC_MUX = 0x8,
                DTLS = 0x10 };
 
-  ChannelTest(const uint8* rtp_data, int rtp_len,
-              const uint8* rtcp_data, int rtcp_len)
+  ChannelTest(const uint8_t* rtp_data,
+              int rtp_len,
+              const uint8_t* rtcp_data,
+              int rtcp_len)
       : session1_(true),
         session2_(false),
         media_channel1_(NULL),
         media_channel2_(NULL),
         rtp_packet_(reinterpret_cast<const char*>(rtp_data), rtp_len),
         rtcp_packet_(reinterpret_cast<const char*>(rtcp_data), rtcp_len),
         media_info_callbacks1_(),
         media_info_callbacks2_(),
         ssrc_(0),
-        error_(T::MediaChannel::ERROR_NONE) {
-  }
+        error_(T::MediaChannel::ERROR_NONE) {}
 
   void CreateChannels(int flags1, int flags2) {
     CreateChannels(new typename T::MediaChannel(NULL, typename T::Options()),
                    new typename T::MediaChannel(NULL, typename T::Options()),
                    flags1, flags2, rtc::Thread::Current());
   }
   void CreateChannels(
       typename T::MediaChannel* ch1, typename T::MediaChannel* ch2,
       int flags1, int flags2, rtc::Thread* thread) {
     media_channel1_ = ch1;
@@ skipping 147 matching lines @@
   }
   bool SendRtcp1() {
     return media_channel1_->SendRtcp(rtcp_packet_.c_str(),
                                      static_cast<int>(rtcp_packet_.size()));
   }
   bool SendRtcp2() {
     return media_channel2_->SendRtcp(rtcp_packet_.c_str(),
                                      static_cast<int>(rtcp_packet_.size()));
   }
   // Methods to send custom data.
-  bool SendCustomRtp1(uint32 ssrc, int sequence_number, int pl_type = -1) {
+  bool SendCustomRtp1(uint32_t ssrc, int sequence_number, int pl_type = -1) {
     std::string data(CreateRtpData(ssrc, sequence_number, pl_type));
     return media_channel1_->SendRtp(data.c_str(),
                                     static_cast<int>(data.size()));
   }
-  bool SendCustomRtp2(uint32 ssrc, int sequence_number, int pl_type = -1) {
+  bool SendCustomRtp2(uint32_t ssrc, int sequence_number, int pl_type = -1) {
     std::string data(CreateRtpData(ssrc, sequence_number, pl_type));
     return media_channel2_->SendRtp(data.c_str(),
                                     static_cast<int>(data.size()));
   }
-  bool SendCustomRtcp1(uint32 ssrc) {
+  bool SendCustomRtcp1(uint32_t ssrc) {
     std::string data(CreateRtcpData(ssrc));
     return media_channel1_->SendRtcp(data.c_str(),
                                      static_cast<int>(data.size()));
   }
-  bool SendCustomRtcp2(uint32 ssrc) {
+  bool SendCustomRtcp2(uint32_t ssrc) {
     std::string data(CreateRtcpData(ssrc));
     return media_channel2_->SendRtcp(data.c_str(),
                                      static_cast<int>(data.size()));
   }
   bool CheckRtp1() {
     return media_channel1_->CheckRtp(rtp_packet_.c_str(),
                                      static_cast<int>(rtp_packet_.size()));
   }
   bool CheckRtp2() {
     return media_channel2_->CheckRtp(rtp_packet_.c_str(),
                                      static_cast<int>(rtp_packet_.size()));
   }
   bool CheckRtcp1() {
     return media_channel1_->CheckRtcp(rtcp_packet_.c_str(),
                                       static_cast<int>(rtcp_packet_.size()));
   }
   bool CheckRtcp2() {
     return media_channel2_->CheckRtcp(rtcp_packet_.c_str(),
                                       static_cast<int>(rtcp_packet_.size()));
   }
   // Methods to check custom data.
-  bool CheckCustomRtp1(uint32 ssrc, int sequence_number, int pl_type = -1 ) {
+  bool CheckCustomRtp1(uint32_t ssrc, int sequence_number, int pl_type = -1) {
     std::string data(CreateRtpData(ssrc, sequence_number, pl_type));
     return media_channel1_->CheckRtp(data.c_str(),
                                      static_cast<int>(data.size()));
   }
-  bool CheckCustomRtp2(uint32 ssrc, int sequence_number, int pl_type = -1) {
+  bool CheckCustomRtp2(uint32_t ssrc, int sequence_number, int pl_type = -1) {
     std::string data(CreateRtpData(ssrc, sequence_number, pl_type));
     return media_channel2_->CheckRtp(data.c_str(),
                                      static_cast<int>(data.size()));
   }
-  bool CheckCustomRtcp1(uint32 ssrc) {
+  bool CheckCustomRtcp1(uint32_t ssrc) {
     std::string data(CreateRtcpData(ssrc));
     return media_channel1_->CheckRtcp(data.c_str(),
                                       static_cast<int>(data.size()));
   }
-  bool CheckCustomRtcp2(uint32 ssrc) {
+  bool CheckCustomRtcp2(uint32_t ssrc) {
     std::string data(CreateRtcpData(ssrc));
     return media_channel2_->CheckRtcp(data.c_str(),
                                       static_cast<int>(data.size()));
   }
-  std::string CreateRtpData(uint32 ssrc, int sequence_number, int pl_type) {
+  std::string CreateRtpData(uint32_t ssrc, int sequence_number, int pl_type) {
     std::string data(rtp_packet_);
     // Set SSRC in the rtp packet copy.
     rtc::SetBE32(const_cast<char*>(data.c_str()) + 8, ssrc);
     rtc::SetBE16(const_cast<char*>(data.c_str()) + 2, sequence_number);
     if (pl_type >= 0) {
       rtc::Set8(const_cast<char*>(data.c_str()), 1,
                 static_cast<uint8_t>(pl_type));
     }
     return data;
   }
-  std::string CreateRtcpData(uint32 ssrc) {
+  std::string CreateRtcpData(uint32_t ssrc) {
     std::string data(rtcp_packet_);
     // Set SSRC in the rtcp packet copy.
     rtc::SetBE32(const_cast<char*>(data.c_str()) + 4, ssrc);
     return data;
   }
 
   bool CheckNoRtp1() {
     return media_channel1_->CheckNoRtp();
   }
   bool CheckNoRtp2() {
@@ skipping 12 matching lines @@
                      typename T::Content* content) {
     // overridden in specialized classes
   }
   void CopyContent(const typename T::Content& source,
                    typename T::Content* content) {
     // overridden in specialized classes
   }
 
   // Creates a cricket::SessionDescription with one MediaContent and one stream.
   // kPcmuCodec is used as audio codec and kH264Codec is used as video codec.
-  cricket::SessionDescription* CreateSessionDescriptionWithStream(uint32 ssrc) {
+  cricket::SessionDescription* CreateSessionDescriptionWithStream(
+      uint32_t ssrc) {
      typename T::Content content;
      cricket::SessionDescription* sdesc = new cricket::SessionDescription();
      CreateContent(SECURE, kPcmuCodec, kH264Codec, &content);
      AddLegacyStreamInContent(ssrc, 0, &content);
      sdesc->AddContent("DUMMY_CONTENT_NAME",
                        cricket::NS_JINGLE_RTP, content.Copy());
      return sdesc;
   }
 
   class CallThread : public rtc::SignalThread {
@@ skipping 36 matching lines @@
   void OnMediaMonitor(typename T::Channel* channel,
                       const typename T::MediaInfo& info) {
     if (channel == channel1_.get()) {
       media_info_callbacks1_++;
     } else if (channel == channel2_.get()) {
       media_info_callbacks2_++;
     }
   }
 
   void OnMediaChannelError(typename T::Channel* channel,
-                           uint32 ssrc,
+                           uint32_t ssrc,
                            typename T::MediaChannel::Error error) {
     ssrc_ = ssrc;
     error_ = error;
   }
 
-  void AddLegacyStreamInContent(uint32 ssrc, int flags,
-                        typename T::Content* content) {
+  void AddLegacyStreamInContent(uint32_t ssrc,
+                                int flags,
+                                typename T::Content* content) {
     // Base implementation.
   }
 
   // Tests that can be used by derived classes.
 
   // Basic sanity check.
   void TestInit() {
     CreateChannels(0, 0);
     EXPECT_FALSE(channel1_->secure());
     EXPECT_FALSE(media_channel1_->sending());
@@ skipping 890 matching lines @@
   void SendBundleToBundle(
       const int* pl_types, int len, bool rtcp_mux, bool secure) {
     ASSERT_EQ(2, len);
     int sequence_number1_1 = 0, sequence_number2_2 = 0;
     // Only pl_type1 was added to the bundle filter for both |channel1_|
     // and |channel2_|.
     int pl_type1 = pl_types[0];
     int pl_type2 = pl_types[1];
     int flags = SSRC_MUX | RTCP;
     if (secure) flags |= SECURE;
-    uint32 expected_channels = 2U;
+    uint32_t expected_channels = 2U;
     if (rtcp_mux) {
       flags |= RTCP_MUX;
       expected_channels = 1U;
     }
     CreateChannels(flags, flags);
     EXPECT_TRUE(SendInitiate());
     EXPECT_EQ(2U, GetTransport1()->channels().size());
     EXPECT_EQ(expected_channels, GetTransport2()->channels().size());
     EXPECT_TRUE(SendAccept());
     EXPECT_EQ(expected_channels, GetTransport1()->channels().size());
@@ skipping 312 matching lines @@
   typename T::Content local_media_content1_;
   typename T::Content local_media_content2_;
   typename T::Content remote_media_content1_;
   typename T::Content remote_media_content2_;
   // The RTP and RTCP packets to send in the tests.
   std::string rtp_packet_;
   std::string rtcp_packet_;
   int media_info_callbacks1_;
   int media_info_callbacks2_;
 
-  uint32 ssrc_;
+  uint32_t ssrc_;
   typename T::MediaChannel::Error error_;
 };
 
 
 template<>
 void ChannelTest<VoiceTraits>::CreateContent(
     int flags,
     const cricket::AudioCodec& audio_codec,
     const cricket::VideoCodec& video_codec,
     cricket::AudioContentDescription* audio) {
@@ skipping 13 matching lines @@
   *audio = source;
 }
 
 template<>
 bool ChannelTest<VoiceTraits>::CodecMatches(const cricket::AudioCodec& c1,
                                             const cricket::AudioCodec& c2) {
   return c1.name == c2.name && c1.clockrate == c2.clockrate &&
       c1.bitrate == c2.bitrate && c1.channels == c2.channels;
 }
 
-template<>
+template <>
 void ChannelTest<VoiceTraits>::AddLegacyStreamInContent(
-    uint32 ssrc, int flags, cricket::AudioContentDescription* audio) {
+    uint32_t ssrc,
+    int flags,
+    cricket::AudioContentDescription* audio) {
   audio->AddLegacyStream(ssrc);
 }
 
 class VoiceChannelTest
     : public ChannelTest<VoiceTraits> {
  public:
   typedef ChannelTest<VoiceTraits> Base;
   VoiceChannelTest() : Base(kPcmuFrame, sizeof(kPcmuFrame),
                             kRtcpReport, sizeof(kRtcpReport)) {}
 };
@@ skipping 41 matching lines @@
   *video = source;
 }
 
 template<>
 bool ChannelTest<VideoTraits>::CodecMatches(const cricket::VideoCodec& c1,
                                             const cricket::VideoCodec& c2) {
   return c1.name == c2.name && c1.width == c2.width && c1.height == c2.height &&
       c1.framerate == c2.framerate;
 }
 
-template<>
+template <>
 void ChannelTest<VideoTraits>::AddLegacyStreamInContent(
-    uint32 ssrc, int flags, cricket::VideoContentDescription* video) {
+    uint32_t ssrc,
+    int flags,
+    cricket::VideoContentDescription* video) {
   video->AddLegacyStream(ssrc);
 }
 
 class VideoChannelTest
     : public ChannelTest<VideoTraits> {
  public:
   typedef ChannelTest<VideoTraits> Base;
   VideoChannelTest() : Base(kH264Packet, sizeof(kH264Packet),
                             kRtcpReport, sizeof(kRtcpReport)) {}
 };
@@ skipping 748 matching lines @@
     cricket::DataContentDescription* data) {
   *data = source;
 }
 
 template<>
 bool ChannelTest<DataTraits>::CodecMatches(const cricket::DataCodec& c1,
                                            const cricket::DataCodec& c2) {
   return c1.name == c2.name;
 }
 
-template<>
+template <>
 void ChannelTest<DataTraits>::AddLegacyStreamInContent(
-    uint32 ssrc, int flags, cricket::DataContentDescription* data) {
+    uint32_t ssrc,
+    int flags,
+    cricket::DataContentDescription* data) {
   data->AddLegacyStream(ssrc);
 }
 
 TEST_F(DataChannelTest, TestInit) {
   Base::TestInit();
   EXPECT_FALSE(media_channel1_->IsStreamMuted(0));
 }
 
 TEST_F(DataChannelTest, TestSetContents) {
   Base::TestSetContents();
@@ skipping 127 matching lines @@
   };
   rtc::Buffer payload(data, 3);
   cricket::SendDataResult result;
   ASSERT_TRUE(media_channel1_->SendData(params, payload, &result));
   EXPECT_EQ(params.ssrc,
             media_channel1_->last_sent_data_params().ssrc);
   EXPECT_EQ("foo", media_channel1_->last_sent_data());
 }
 
 // TODO(pthatcher): TestSetReceiver?