Validates sending RTCP before RTP.

webrtc/modules/rtp_rtcp/source/rtcp_sender_unittest.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 203 matching lines @@
                             const size_t payload_size,
                             const WebRtcRTPHeader* rtp_header) override {
     return 0;
   }
   test::RtcpPacketParser parser_;
 };
 
 namespace {
 static const uint32_t kSenderSsrc = 0x11111111;
 static const uint32_t kRemoteSsrc = 0x22222222;
+static const uint32_t kStartRtpTimestamp = 0x34567;
+static const uint32_t kRtpTimestamp = 0x45678;
 }
 
 class RtcpSenderTest : public ::testing::Test {
  protected:
   RtcpSenderTest()
       : clock_(1335900000),
         receive_statistics_(ReceiveStatistics::Create(&clock_)) {
     RtpRtcp::Configuration configuration;
     configuration.audio = false;
     configuration.clock = &clock_;
     configuration.outgoing_transport = &test_transport_;
 
     rtp_rtcp_impl_.reset(new ModuleRtpRtcpImpl(configuration));
     rtcp_sender_.reset(new RTCPSender(false, &clock_, receive_statistics_.get(),
                                       nullptr, nullptr, &test_transport_));
     rtcp_sender_->SetSSRC(kSenderSsrc);
     rtcp_sender_->SetRemoteSSRC(kRemoteSsrc);
+    rtcp_sender_->SetStartTimestamp(kStartRtpTimestamp);
+    rtcp_sender_->SetLastRtpTime(kRtpTimestamp, clock_.TimeInMilliseconds());
   }
 
   void InsertIncomingPacket(uint32_t remote_ssrc, uint16_t seq_num) {
     RTPHeader header;
     header.ssrc = remote_ssrc;
     header.sequenceNumber = seq_num;
     header.timestamp = 12345;
     header.headerLength = 12;
     size_t kPacketLength = 100;
     receive_statistics_->IncomingPacket(header, kPacketLength, false);
@@ skipping 27 matching lines @@
 TEST_F(RtcpSenderTest, NoPacketSentIfOff) {
   rtcp_sender_->SetRTCPStatus(RtcpMode::kOff);
   EXPECT_EQ(-1, rtcp_sender_->SendRTCP(feedback_state(), kRtcpSr));
 }
 
 TEST_F(RtcpSenderTest, SendSr) {
   const uint32_t kPacketCount = 0x12345;
   const uint32_t kOctetCount = 0x23456;
   rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
   RTCPSender::FeedbackState feedback_state = rtp_rtcp_impl_->GetFeedbackState();
+  rtcp_sender_->SetSendingStatus(feedback_state, true);
   feedback_state.packets_sent = kPacketCount;
   feedback_state.media_bytes_sent = kOctetCount;
   uint32_t ntp_secs;
   uint32_t ntp_frac;
   clock_.CurrentNtp(ntp_secs, ntp_frac);
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpSr));
   EXPECT_EQ(1, parser()->sender_report()->num_packets());
   EXPECT_EQ(kSenderSsrc, parser()->sender_report()->Ssrc());
   EXPECT_EQ(ntp_secs, parser()->sender_report()->NtpSec());
   EXPECT_EQ(ntp_frac, parser()->sender_report()->NtpFrac());
   EXPECT_EQ(kPacketCount, parser()->sender_report()->PacketCount());
   EXPECT_EQ(kOctetCount, parser()->sender_report()->OctetCount());
+  EXPECT_EQ(kStartRtpTimestamp + kRtpTimestamp,
+            parser()->sender_report()->RtpTimestamp());
   EXPECT_EQ(0, parser()->report_block()->num_packets());
 }
 
+TEST_F(RtcpSenderTest, DoNotSendSrBeforeRtp) {
+  rtcp_sender_.reset(new RTCPSender(false, &clock_, receive_statistics_.get(),
+                                    nullptr, nullptr, &test_transport_));
+  rtcp_sender_->SetSSRC(kSenderSsrc);
+  rtcp_sender_->SetRemoteSSRC(kRemoteSsrc);
+  rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
+  rtcp_sender_->SetSendingStatus(feedback_state(), true);
+
+  // Sender Report shouldn't be send not as Sr, nor as Report.

[stefan-webrtc, 2016/07/20 09:13:31]

Sender Report shouldn't be sent as an SR nor as a Report

[danilchap, 2016/07/20 10:09:49]

Done.

+  rtcp_sender_->SendRTCP(feedback_state(), kRtcpSr);
+  EXPECT_EQ(0, parser()->sender_report()->num_packets());
+  rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport);
+  EXPECT_EQ(0, parser()->sender_report()->num_packets());
+  // Other packets (e.g. Pli) are allowed, even if useless.
+  EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpPli));
+  EXPECT_EQ(1, parser()->pli()->num_packets());
+}
+
+TEST_F(RtcpSenderTest, DoNotSendCompundBeforeRtp) {
+  rtcp_sender_.reset(new RTCPSender(false, &clock_, receive_statistics_.get(),
+                                    nullptr, nullptr, &test_transport_));
+  rtcp_sender_->SetSSRC(kSenderSsrc);
+  rtcp_sender_->SetRemoteSSRC(kRemoteSsrc);
+  rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
+  rtcp_sender_->SetSendingStatus(feedback_state(), true);
+
+  // In compound mode no packets are allowed (e.g. Pli) because compound mode
+  // should start with Sender Report.
+  EXPECT_EQ(-1, rtcp_sender_->SendRTCP(feedback_state(), kRtcpPli));
+  EXPECT_EQ(0, parser()->pli()->num_packets());
+}
+
 TEST_F(RtcpSenderTest, SendRr) {
   rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpRr));
   EXPECT_EQ(1, parser()->receiver_report()->num_packets());
   EXPECT_EQ(kSenderSsrc, parser()->receiver_report()->Ssrc());
   EXPECT_EQ(0, parser()->report_block()->num_packets());
 }
 
 TEST_F(RtcpSenderTest, SendRrWithOneReportBlock) {
   const uint16_t kSeqNum = 11111;
@@ skipping 368 matching lines @@
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
   EXPECT_EQ(2, parser()->tmmbr()->num_packets());
   EXPECT_EQ(2, parser()->tmmbr_item()->num_packets());
 
   rtcp_sender_->SetTMMBRStatus(false);
   EXPECT_FALSE(rtcp_sender_->TMMBR());
 }
 
 TEST_F(RtcpSenderTest, SendTmmbn) {
   rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
+  rtcp_sender_->SetSendingStatus(feedback_state(), true);
   std::vector<rtcp::TmmbItem> bounding_set;
   const uint32_t kBitrateKbps = 32768;
   const uint32_t kPacketOh = 40;
   const uint32_t kSourceSsrc = 12345;
   const rtcp::TmmbItem tmmbn(kSourceSsrc, kBitrateKbps * 1000, kPacketOh);
   bounding_set.push_back(tmmbn);
   rtcp_sender_->SetTMMBN(&bounding_set);
 
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpSr));
   EXPECT_EQ(1, parser()->sender_report()->num_packets());
   EXPECT_EQ(1, parser()->tmmbn()->num_packets());
   EXPECT_EQ(kSenderSsrc, parser()->tmmbn()->Ssrc());
   EXPECT_EQ(1, parser()->tmmbn_items()->num_packets());
   EXPECT_EQ(kBitrateKbps, parser()->tmmbn_items()->BitrateKbps(0));
   EXPECT_EQ(kPacketOh, parser()->tmmbn_items()->Overhead(0));
   EXPECT_EQ(kSourceSsrc, parser()->tmmbn_items()->Ssrc(0));
 }
 
 // This test is written to verify actual behaviour. It does not seem
 // to make much sense to send an empty TMMBN, since there is no place
 // to put an actual limit here. It's just information that no limit
 // is set, which is kind of the starting assumption.
 // See http://code.google.com/p/webrtc/issues/detail?id=468 for one
 // situation where this caused confusion.
 TEST_F(RtcpSenderTest, SendsTmmbnIfSetAndEmpty) {
   rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
+  rtcp_sender_->SetSendingStatus(feedback_state(), true);
   std::vector<rtcp::TmmbItem> bounding_set;
   rtcp_sender_->SetTMMBN(&bounding_set);
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpSr));
   EXPECT_EQ(1, parser()->sender_report()->num_packets());
   EXPECT_EQ(1, parser()->tmmbn()->num_packets());
   EXPECT_EQ(kSenderSsrc, parser()->tmmbn()->Ssrc());
   EXPECT_EQ(0, parser()->tmmbn_items()->num_packets());
 }
 
 TEST_F(RtcpSenderTest, SendCompoundPliRemb) {
@@ skipping 34 matching lines @@
     }
 
     return true;
   }));
 
   // Re-configure rtcp_sender_ with mock_transport_
   rtcp_sender_.reset(new RTCPSender(false, &clock_, receive_statistics_.get(),
                                     nullptr, nullptr, &mock_transport));
   rtcp_sender_->SetSSRC(kSenderSsrc);
   rtcp_sender_->SetRemoteSSRC(kRemoteSsrc);
+  rtcp_sender_->SetStartTimestamp(kStartRtpTimestamp);
+  rtcp_sender_->SetLastRtpTime(kRtpTimestamp, clock_.TimeInMilliseconds());
 
   // Set up XR VoIP metric to be included with BYE
   rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
   RTCPVoIPMetric metric;
   EXPECT_EQ(0, rtcp_sender_->SetRTCPVoIPMetrics(&metric));
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpBye));
 }
 
 }  // namespace webrtc