Upstream version 9.38.198.0

[platform/framework/web/crosswalk.git] / src / third_party / webrtc / modules / rtp_rtcp / source / rtp_sender_unittest.cc

diff --git a/src/third_party/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc b/src/third_party/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc
index 1848289..e9b01de 100644 (file)
--- a/src/third_party/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc
+++ b/src/third_party/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc
@@ -39,6 +39,7 @@ const uint8_t kAudioLevel = 0x5a;
 const uint8_t kAudioLevelExtensionId = 9;
 const int kAudioPayload = 103;
 const uint64_t kStartTime = 123456789;
+const size_t kMaxPaddingSize = 224u;
 }  // namespace
 
 using testing::_;
@@ -62,13 +63,12 @@ uint64_t ConvertMsToAbsSendTime(int64_t time_ms) {
 class LoopbackTransportTest : public webrtc::Transport {
  public:
   LoopbackTransportTest()
-    : packets_sent_(0),
-      last_sent_packet_len_(0) {
-  }
+      : packets_sent_(0), last_sent_packet_len_(0), total_bytes_sent_(0) {}
   virtual int SendPacket(int channel, const void *data, int len) {
     packets_sent_++;
     memcpy(last_sent_packet_, data, len);
     last_sent_packet_len_ = len;
+    total_bytes_sent_ += static_cast<size_t>(len);
     return len;
   }
   virtual int SendRTCPPacket(int channel, const void *data, int len) {
@@ -76,6 +76,7 @@ class LoopbackTransportTest : public webrtc::Transport {
   }
   int packets_sent_;
   int last_sent_packet_len_;
+  size_t total_bytes_sent_;
   uint8_t last_sent_packet_[kMaxPacketLength];
 };
 
@@ -94,7 +95,7 @@ class RtpSenderTest : public ::testing::Test {
 
   virtual void SetUp() {
     rtp_sender_.reset(new RTPSender(0, false, &fake_clock_, &transport_, NULL,
-                                    &mock_paced_sender_));
+                                    &mock_paced_sender_, NULL, NULL, NULL));
     rtp_sender_->SetSequenceNumber(kSeqNum);
   }
 
@@ -204,7 +205,7 @@ TEST_F(RtpSenderTest, BuildRTPPacket) {
   EXPECT_EQ(kRtpHeaderSize, length);
 
   // Verify
-  webrtc::ModuleRTPUtility::RTPHeaderParser rtp_parser(packet_, length);
+  webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length);
   webrtc::RTPHeader rtp_header;
 
   const bool valid_rtp_header = rtp_parser.Parse(rtp_header, NULL);
@@ -235,7 +236,7 @@ TEST_F(RtpSenderTest, BuildRTPPacketWithTransmissionOffsetExtension) {
       length);
 
   // Verify
-  webrtc::ModuleRTPUtility::RTPHeaderParser rtp_parser(packet_, length);
+  webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length);
   webrtc::RTPHeader rtp_header;
 
   RtpHeaderExtensionMap map;
@@ -276,7 +277,7 @@ TEST_F(RtpSenderTest, BuildRTPPacketWithNegativeTransmissionOffsetExtension) {
       length);
 
   // Verify
-  webrtc::ModuleRTPUtility::RTPHeaderParser rtp_parser(packet_, length);
+  webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length);
   webrtc::RTPHeader rtp_header;
 
   RtpHeaderExtensionMap map;
@@ -306,7 +307,7 @@ TEST_F(RtpSenderTest, BuildRTPPacketWithAbsoluteSendTimeExtension) {
       length);
 
   // Verify
-  webrtc::ModuleRTPUtility::RTPHeaderParser rtp_parser(packet_, length);
+  webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length);
   webrtc::RTPHeader rtp_header;
 
   RtpHeaderExtensionMap map;
@@ -344,7 +345,7 @@ TEST_F(RtpSenderTest, BuildRTPPacketWithAudioLevelExtension) {
       length);
 
   // Verify
-  webrtc::ModuleRTPUtility::RTPHeaderParser rtp_parser(packet_, length);
+  webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length);
   webrtc::RTPHeader rtp_header;
 
   // Updating audio level is done in RTPSenderAudio, so simulate it here.
@@ -394,7 +395,7 @@ TEST_F(RtpSenderTest, BuildRTPPacketWithHeaderExtensions) {
       length);
 
   // Verify
-  webrtc::ModuleRTPUtility::RTPHeaderParser rtp_parser(packet_, length);
+  webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length);
   webrtc::RTPHeader rtp_header;
 
   // Updating audio level is done in RTPSenderAudio, so simulate it here.
@@ -471,8 +472,8 @@ TEST_F(RtpSenderTest, TrafficSmoothingWithExtensions) {
   EXPECT_EQ(1, transport_.packets_sent_);
   EXPECT_EQ(rtp_length, transport_.last_sent_packet_len_);
   // Parse sent packet.
-  webrtc::ModuleRTPUtility::RTPHeaderParser rtp_parser(
-      transport_.last_sent_packet_, rtp_length);
+  webrtc::RtpUtility::RtpHeaderParser rtp_parser(transport_.last_sent_packet_,
+                                                 rtp_length);
   webrtc::RTPHeader rtp_header;
   RtpHeaderExtensionMap map;
   map.Register(kRtpExtensionTransmissionTimeOffset,
@@ -533,8 +534,8 @@ TEST_F(RtpSenderTest, TrafficSmoothingRetransmits) {
   EXPECT_EQ(rtp_length, transport_.last_sent_packet_len_);
 
   // Parse sent packet.
-  webrtc::ModuleRTPUtility::RTPHeaderParser rtp_parser(
-      transport_.last_sent_packet_, rtp_length);
+  webrtc::RtpUtility::RtpHeaderParser rtp_parser(transport_.last_sent_packet_,
+                                                 rtp_length);
   webrtc::RTPHeader rtp_header;
   RtpHeaderExtensionMap map;
   map.Register(kRtpExtensionTransmissionTimeOffset,
@@ -672,7 +673,7 @@ TEST_F(RtpSenderTest, SendPadding) {
 TEST_F(RtpSenderTest, SendRedundantPayloads) {
   MockTransport transport;
   rtp_sender_.reset(new RTPSender(0, false, &fake_clock_, &transport, NULL,
-                                  &mock_paced_sender_));
+                                  &mock_paced_sender_, NULL, NULL, NULL));
   rtp_sender_->SetSequenceNumber(kSeqNum);
   // Make all packets go through the pacer.
   EXPECT_CALL(mock_paced_sender_,
@@ -700,7 +701,7 @@ TEST_F(RtpSenderTest, SendRedundantPayloads) {
                                          kAbsoluteSendTimeExtensionId);
   rtp_sender_->SetTargetBitrate(300000);
   const size_t kNumPayloadSizes = 10;
-  const int kPayloadSizes[kNumPayloadSizes] = {500, 550, 600, 650, 700, 750,
+  const size_t kPayloadSizes[kNumPayloadSizes] = {500, 550, 600, 650, 700, 750,
       800, 850, 900, 950};
   // Send 10 packets of increasing size.
   for (size_t i = 0; i < kNumPayloadSizes; ++i) {
@@ -711,25 +712,27 @@ TEST_F(RtpSenderTest, SendRedundantPayloads) {
     rtp_sender_->TimeToSendPacket(seq_num++, capture_time_ms, false);
     fake_clock_.AdvanceTimeMilliseconds(33);
   }
-  const int kPaddingPayloadSize = 224;
   // The amount of padding to send it too small to send a payload packet.
-  EXPECT_CALL(transport, SendPacket(_, _, kPaddingPayloadSize + rtp_header_len))
+  EXPECT_CALL(transport,
+              SendPacket(_, _, kMaxPaddingSize + rtp_header_len))
       .WillOnce(testing::ReturnArg<2>());
-  EXPECT_EQ(kPaddingPayloadSize, rtp_sender_->TimeToSendPadding(49));
+  EXPECT_EQ(kMaxPaddingSize,
+            static_cast<size_t>(rtp_sender_->TimeToSendPadding(49)));
 
   const int kRtxHeaderSize = 2;
   EXPECT_CALL(transport, SendPacket(_, _, kPayloadSizes[0] +
                                     rtp_header_len + kRtxHeaderSize))
       .WillOnce(testing::ReturnArg<2>());
-  EXPECT_EQ(kPayloadSizes[0], rtp_sender_->TimeToSendPadding(500));
+  EXPECT_EQ(kPayloadSizes[0],
+            static_cast<size_t>(rtp_sender_->TimeToSendPadding(500)));
 
   EXPECT_CALL(transport, SendPacket(_, _, kPayloadSizes[kNumPayloadSizes - 1] +
                                     rtp_header_len + kRtxHeaderSize))
       .WillOnce(testing::ReturnArg<2>());
-  EXPECT_CALL(transport, SendPacket(_, _, kPaddingPayloadSize + rtp_header_len))
+  EXPECT_CALL(transport, SendPacket(_, _, kMaxPaddingSize + rtp_header_len))
       .WillOnce(testing::ReturnArg<2>());
-  EXPECT_EQ(kPayloadSizes[kNumPayloadSizes - 1] + kPaddingPayloadSize,
-            rtp_sender_->TimeToSendPadding(999));
+  EXPECT_EQ(kPayloadSizes[kNumPayloadSizes - 1] + kMaxPaddingSize,
+            static_cast<size_t>(rtp_sender_->TimeToSendPadding(999)));
 }
 
 TEST_F(RtpSenderTest, SendGenericVideo) {
@@ -744,8 +747,8 @@ TEST_F(RtpSenderTest, SendGenericVideo) {
                                              4321, payload, sizeof(payload),
                                              NULL));
 
-  ModuleRTPUtility::RTPHeaderParser rtp_parser(transport_.last_sent_packet_,
-      transport_.last_sent_packet_len_);
+  RtpUtility::RtpHeaderParser rtp_parser(transport_.last_sent_packet_,
+                                         transport_.last_sent_packet_len_);
   webrtc::RTPHeader rtp_header;
   ASSERT_TRUE(rtp_parser.Parse(rtp_header));
 
@@ -770,8 +773,8 @@ TEST_F(RtpSenderTest, SendGenericVideo) {
                                              1234, 4321, payload,
                                              sizeof(payload), NULL));
 
-  ModuleRTPUtility::RTPHeaderParser rtp_parser2(transport_.last_sent_packet_,
-      transport_.last_sent_packet_len_);
+  RtpUtility::RtpHeaderParser rtp_parser2(transport_.last_sent_packet_,
+                                          transport_.last_sent_packet_len_);
   ASSERT_TRUE(rtp_parser.Parse(rtp_header));
 
   payload_data = GetPayloadData(rtp_header, transport_.last_sent_packet_);
@@ -817,6 +820,9 @@ TEST_F(RtpSenderTest, FrameCountCallbacks) {
     uint32_t delta_frames_;
   } callback;
 
+  rtp_sender_.reset(new RTPSender(0, false, &fake_clock_, &transport_, NULL,
+                                  &mock_paced_sender_, NULL, &callback, NULL));
+
   char payload_name[RTP_PAYLOAD_NAME_SIZE] = "GENERIC";
   const uint8_t payload_type = 127;
   ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 90000,
@@ -825,8 +831,6 @@ TEST_F(RtpSenderTest, FrameCountCallbacks) {
   rtp_sender_->SetStorePacketsStatus(true, 1);
   uint32_t ssrc = rtp_sender_->SSRC();
 
-  rtp_sender_->RegisterFrameCountObserver(&callback);
-
   ASSERT_EQ(0, rtp_sender_->SendOutgoingData(kVideoFrameKey, payload_type, 1234,
                                              4321, payload, sizeof(payload),
                                              NULL));
@@ -845,7 +849,7 @@ TEST_F(RtpSenderTest, FrameCountCallbacks) {
   EXPECT_EQ(1U, callback.key_frames_);
   EXPECT_EQ(1U, callback.delta_frames_);
 
-  rtp_sender_->RegisterFrameCountObserver(NULL);
+  rtp_sender_.reset();
 }
 
 TEST_F(RtpSenderTest, BitrateCallbacks) {
@@ -865,6 +869,8 @@ TEST_F(RtpSenderTest, BitrateCallbacks) {
     uint32_t ssrc_;
     BitrateStatistics bitrate_;
   } callback;
+  rtp_sender_.reset(new RTPSender(0, false, &fake_clock_, &transport_, NULL,
+                                  &mock_paced_sender_, &callback, NULL, NULL));
 
   // Simulate kNumPackets sent with kPacketInterval ms intervals.
   const uint32_t kNumPackets = 15;
@@ -881,8 +887,6 @@ TEST_F(RtpSenderTest, BitrateCallbacks) {
   rtp_sender_->SetStorePacketsStatus(true, 1);
   uint32_t ssrc = rtp_sender_->SSRC();
 
-  rtp_sender_->RegisterBitrateObserver(&callback);
-
   // Initial process call so we get a new time window.
   rtp_sender_->ProcessBitrate();
   uint64_t start_time = fake_clock_.CurrentNtpInMilliseconds();
@@ -912,7 +916,7 @@ TEST_F(RtpSenderTest, BitrateCallbacks) {
   EXPECT_EQ((kPacketOverhead + sizeof(payload)) * 8 * expected_packet_rate,
             callback.bitrate_.bitrate_bps);
 
-  rtp_sender_->RegisterBitrateObserver(NULL);
+  rtp_sender_.reset();
 }
 
 class RtpSenderAudioTest : public RtpSenderTest {
@@ -922,7 +926,7 @@ class RtpSenderAudioTest : public RtpSenderTest {
   virtual void SetUp() {
     payload_ = kAudioPayload;
     rtp_sender_.reset(new RTPSender(0, true, &fake_clock_, &transport_, NULL,
-                                    &mock_paced_sender_));
+                                    &mock_paced_sender_, NULL, NULL, NULL));
     rtp_sender_->SetSequenceNumber(kSeqNum);
   }
 };
@@ -958,7 +962,6 @@ TEST_F(RtpSenderTest, StreamDataCountersCallbacks) {
 
   const uint8_t kRedPayloadType = 96;
   const uint8_t kUlpfecPayloadType = 97;
-  const uint32_t kMaxPaddingSize = 224;
   char payload_name[RTP_PAYLOAD_NAME_SIZE] = "GENERIC";
   const uint8_t payload_type = 127;
   ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 90000,
@@ -987,7 +990,7 @@ TEST_F(RtpSenderTest, StreamDataCountersCallbacks) {
   // Send padding.
   rtp_sender_->TimeToSendPadding(kMaxPaddingSize);
   // {bytes = 6, header = 24, padding = 224, packets = 3, retrans = 1, fec = 0}
-  EXPECT_TRUE(callback.Matches(ssrc, 6, 24, 224, 3, 1, 0));
+  EXPECT_TRUE(callback.Matches(ssrc, 6, 24, kMaxPaddingSize, 3, 1, 0));
 
   // Send FEC.
   rtp_sender_->SetGenericFECStatus(true, kRedPayloadType, kUlpfecPayloadType);
@@ -1002,7 +1005,7 @@ TEST_F(RtpSenderTest, StreamDataCountersCallbacks) {
                                              sizeof(payload), NULL));
 
   // {bytes = 34, header = 48, padding = 224, packets = 5, retrans = 1, fec = 1}
-  EXPECT_TRUE(callback.Matches(ssrc, 34, 48, 224, 5, 1, 1));
+  EXPECT_TRUE(callback.Matches(ssrc, 34, 48, kMaxPaddingSize, 5, 1, 1));
 
   rtp_sender_->RegisterRtpStatisticsCallback(NULL);
 }
@@ -1018,8 +1021,8 @@ TEST_F(RtpSenderAudioTest, SendAudio) {
                                              4321, payload, sizeof(payload),
                                              NULL));
 
-  ModuleRTPUtility::RTPHeaderParser rtp_parser(transport_.last_sent_packet_,
-      transport_.last_sent_packet_len_);
+  RtpUtility::RtpHeaderParser rtp_parser(transport_.last_sent_packet_,
+                                         transport_.last_sent_packet_len_);
   webrtc::RTPHeader rtp_header;
   ASSERT_TRUE(rtp_parser.Parse(rtp_header));
 
@@ -1047,8 +1050,8 @@ TEST_F(RtpSenderAudioTest, SendAudioWithAudioLevelExtension) {
                                              4321, payload, sizeof(payload),
                                              NULL));
 
-  ModuleRTPUtility::RTPHeaderParser rtp_parser(transport_.last_sent_packet_,
-      transport_.last_sent_packet_len_);
+  RtpUtility::RtpHeaderParser rtp_parser(transport_.last_sent_packet_,
+                                         transport_.last_sent_packet_len_);
   webrtc::RTPHeader rtp_header;
   ASSERT_TRUE(rtp_parser.Parse(rtp_header));
 
@@ -1070,4 +1073,47 @@ TEST_F(RtpSenderAudioTest, SendAudioWithAudioLevelExtension) {
                       sizeof(extension)));
 }
 
+TEST_F(RtpSenderTest, BytesReportedCorrectly) {
+  const char* kPayloadName = "GENERIC";
+  const uint8_t kPayloadType = 127;
+  rtp_sender_->SetSSRC(1234);
+  rtp_sender_->SetRtxSsrc(4321);
+  rtp_sender_->SetRtxPayloadType(kPayloadType - 1);
+  rtp_sender_->SetRTXStatus(kRtxRetransmitted | kRtxRedundantPayloads);
+
+  ASSERT_EQ(
+      0,
+      rtp_sender_->RegisterPayload(kPayloadName, kPayloadType, 90000, 0, 1500));
+  uint8_t payload[] = {47, 11, 32, 93, 89};
+
+  ASSERT_EQ(0,
+            rtp_sender_->SendOutgoingData(kVideoFrameKey,
+                                          kPayloadType,
+                                          1234,
+                                          4321,
+                                          payload,
+                                          sizeof(payload),
+                                          0));
+
+  // Will send 2 full-size padding packets.
+  rtp_sender_->TimeToSendPadding(1);
+  rtp_sender_->TimeToSendPadding(1);
+
+  StreamDataCounters rtp_stats;
+  StreamDataCounters rtx_stats;
+  rtp_sender_->GetDataCounters(&rtp_stats, &rtx_stats);
+
+  // Payload + 1-byte generic header.
+  EXPECT_EQ(rtp_stats.bytes, sizeof(payload) + 1);
+  EXPECT_EQ(rtp_stats.header_bytes, 12u);
+  EXPECT_EQ(rtp_stats.padding_bytes, 0u);
+  EXPECT_EQ(rtx_stats.bytes, 0u);
+  EXPECT_EQ(rtx_stats.header_bytes, 24u);
+  EXPECT_EQ(rtx_stats.padding_bytes, 2 * kMaxPaddingSize);
+
+  EXPECT_EQ(transport_.total_bytes_sent_,
+            rtp_stats.bytes + rtp_stats.header_bytes + rtp_stats.padding_bytes +
+                rtx_stats.bytes + rtx_stats.header_bytes +
+                rtx_stats.padding_bytes);
+}
 }  // namespace webrtc