Validates sending RTCP before RTP.

webrtc/video/end_to_end_tests.cc

 /*
  *  Copyright (c) 2013 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.
  */
 #include <algorithm>
@@ skipping 62 matching lines @@
       ADD_FAILURE() << "Unexpected RTCP sent.";
       return false;
     }
   };
 
   void DecodesRetransmittedFrame(bool use_rtx, bool use_red);
   void ReceivesPliAndRecovers(int rtp_history_ms);
   void RespectsRtcpMode(RtcpMode rtcp_mode);
   void TestXrReceiverReferenceTimeReport(bool enable_rrtr);
   void TestSendsSetSsrcs(size_t num_ssrcs, bool send_single_ssrc_first);
-  void TestRtpStatePreservation(bool use_rtx);
+  void TestRtpStatePreservation(bool use_rtx, bool wait_rtcp);
   void VerifyHistogramStats(bool use_rtx, bool use_red, bool screenshare);
 };
 
 TEST_F(EndToEndTest, ReceiverCanBeStartedTwice) {
   CreateCalls(Call::Config(), Call::Config());
 
   test::NullTransport transport;
   CreateSendConfig(1, 0, &transport);
   CreateMatchingReceiveConfigs(&transport);
 
@@ skipping 2835 matching lines @@
 
    private:
     size_t ssrcs_to_observe_;
     std::map<uint32_t, bool> observed_redundant_retransmission_;
     std::map<uint32_t, bool> registered_rtx_ssrc_;
   } test;
 
   RunBaseTest(&test);
 }
 
-void EndToEndTest::TestRtpStatePreservation(bool use_rtx) {
+void EndToEndTest::TestRtpStatePreservation(bool use_rtx, bool wait_rtcp) {
   static const uint32_t kMaxSequenceNumberGap = 100;
   class RtpSequenceObserver : public test::RtpRtcpObserver {
    public:
     explicit RtpSequenceObserver(bool use_rtx)
         : test::RtpRtcpObserver(kDefaultTimeoutMs),
           ssrcs_to_observe_(kNumSsrcs) {
       for (size_t i = 0; i < kNumSsrcs; ++i) {
         configured_ssrcs_[kVideoSendSsrcs[i]] = true;
         if (use_rtx)
           configured_ssrcs_[kSendRtxSsrcs[i]] = true;
@@ skipping 148 matching lines @@
   // Test stream resetting more than once to make sure that the state doesn't
   // get set once (this could be due to using std::map::insert for instance).
   for (size_t i = 0; i < 3; ++i) {
     frame_generator_capturer_->Stop();
     sender_call_->DestroyVideoSendStream(video_send_stream_);
 
     // Re-create VideoSendStream with only one stream.
     video_send_stream_ =
         sender_call_->CreateVideoSendStream(video_send_config_, one_stream);
     video_send_stream_->Start();
+    if (wait_rtcp) {
+      // Wait for SR rtcp packet before generating rtp packets.

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

I'm not sure I understand this test change. How can we even expect RTCP SR to be
sent before we send RTP? 

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

RTP packets will not be send until FrameGeneratorCapturer will start to work.
I know 2 ways to wait for RTCP before starting FrameGeneratorCapturer:
One, longer way - just wait ~5 sec. Process thread will try to generate an SR
report. 
Another, faster way, the one used in this test - send rapid synchronization
request (transport feedback message with feedback_message_type=5). In response
to this message RtpRtcp module tries to send back SenderReport as fast as it
can. Current implementation doesn't validate Sender/Receiver SSRCs, so I put
zeroes in both these field to make code shorter.

Pathset#1 demonstrates test fails before the change.

+      // There should be no rtcp packet or its time should be in sync with rtp.
+
+      // Rapid Resync Request forces sending RTCP Sender Report back.
+      // Alternative approach is to wait several seconds for SR to be generated.
+      // TODO(danilchap): Create rtcp packet with dedicated class when it lands.
+      const uint8_t kPacket[] = {0x85, 205, 0x00, 0x02, 0, 0, 0, 0, 0, 0, 0, 0};
+      video_send_stream_->DeliverRtcp(kPacket, sizeof(kPacket));
+    }
     CreateFrameGeneratorCapturer();
     frame_generator_capturer_->Start();
 
     observer.ResetExpectedSsrcs(1);
     EXPECT_TRUE(observer.Wait()) << "Timed out waiting for single RTP packet.";
 
     // Reconfigure back to use all streams.
     video_send_stream_->ReconfigureVideoEncoder(video_encoder_config_);
     observer.ResetExpectedSsrcs(kNumSsrcs);
     EXPECT_TRUE(observer.Wait())
@@ skipping 12 matching lines @@
   }
 
   send_transport.StopSending();
   receive_transport.StopSending();
 
   Stop();
   DestroyStreams();
 }
 
 TEST_F(EndToEndTest, DISABLED_RestartingSendStreamPreservesRtpState) {
-  TestRtpStatePreservation(false);
+  TestRtpStatePreservation(false, false);
 }
 
 TEST_F(EndToEndTest, RestartingSendStreamPreservesRtpStatesWithRtx) {
-  TestRtpStatePreservation(true);
+  TestRtpStatePreservation(true, false);
+}
+
+TEST_F(EndToEndTest, RestartingSendStreamKeepsRtpAndRtcpTimestampsSynced) {
+  TestRtpStatePreservation(true, true);
 }
 
 TEST_F(EndToEndTest, RespectsNetworkState) {
   // TODO(pbos): Remove accepted downtime packets etc. when signaling network
   // down blocks until no more packets will be sent.
 
   // Pacer will send from its packet list and then send required padding before
   // checking paused_ again. This should be enough for one round of pacing,
   // otherwise increase.
   static const int kNumAcceptedDowntimeRtp = 5;
@@ skipping 365 matching lines @@
    private:
     bool video_observed_;
     bool audio_observed_;
     SequenceNumberUnwrapper unwrapper_;
     std::set<int64_t> received_packet_ids_;
   } test;
 
   RunBaseTest(&test);
 }
 }  // namespace webrtc