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 201 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 39 matching lines @@
   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());
 }

[stefan-webrtc, 2016/02/01 17:32:07]

Should we add a test which verifies we don't send an SR before sending RTP? Or
at least in some way verify what actually was fixed in this CL.

[danilchap, 2016/02/01 18:24:18]

test in video/end_to_end is one way to see this CL changes something.
DCHECK in RtcpSender::BuildSR  is another way to ensure bogus RTP timestamps are
not generated.

Not sure tests in RtcpSenderTest are helpful, specially that this change will
not be needed if we switch calculating rtp timestamps base on ntp time instead
of last frame timestamp. Sender Report before first RTP packet could be possible
and will make sense then (receiver will sooner get 2nd Sender Report and will be
able to convert rtp timestamp into ntp time)

 
 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) {
@@ skipping 445 matching lines @@
   rtcp_sender_->SetREMBData(kBitrate, ssrcs);
   std::set<RTCPPacketType> packet_types;
   packet_types.insert(kRtcpRemb);
   packet_types.insert(kRtcpPli);
   EXPECT_EQ(0, rtcp_sender_->SendCompoundRTCP(feedback_state(), packet_types));
   EXPECT_EQ(1, parser()->remb_item()->num_packets());
   EXPECT_EQ(1, parser()->pli()->num_packets());
 }
 
 }  // namespace webrtc