Fix issues with RestartingSendStreamPreservesRtpStatesWithRtx

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 3044 matching lines @@
 }
 
 void EndToEndTest::TestRtpStatePreservation(bool use_rtx,
                                             bool provoke_rtcpsr_before_rtp) {
   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;
+        ssrc_is_rtx_[kVideoSendSsrcs[i]] = false;
         if (use_rtx)
-          configured_ssrcs_[kSendRtxSsrcs[i]] = true;
+          ssrc_is_rtx_[kSendRtxSsrcs[i]] = true;
       }
     }
 
     void ResetExpectedSsrcs(size_t num_expected_ssrcs) {
       rtc::CritScope lock(&crit_);
       ssrc_observed_.clear();
       ssrcs_to_observe_ = num_expected_ssrcs;
     }
 
    private:
@@ skipping 22 matching lines @@
     Action OnSendRtp(const uint8_t* packet, size_t length) override {
       RTPHeader header;
       EXPECT_TRUE(parser_->Parse(packet, length, &header));
       const uint32_t ssrc = header.ssrc;
       const int64_t sequence_number =
           seq_numbers_unwrapper_.Unwrap(header.sequenceNumber);
       const uint32_t timestamp = header.timestamp;
       const bool only_padding =
           header.headerLength + header.paddingLength == length;
 
-      EXPECT_TRUE(configured_ssrcs_[ssrc])
+      EXPECT_TRUE(ssrc_is_rtx_.find(ssrc) != ssrc_is_rtx_.end())
           << "Received SSRC that wasn't configured: " << ssrc;
 
       static const int64_t kMaxSequenceNumberGap = 100;
       std::list<int64_t>* seq_numbers = &last_observed_seq_numbers_[ssrc];
       if (seq_numbers->empty()) {
         seq_numbers->push_back(sequence_number);
       } else {
         // We shouldn't get replays of previous sequence numbers.
         for (int64_t observed : *seq_numbers) {
           EXPECT_NE(observed, sequence_number)
               << "Received sequence number " << sequence_number
               << " for SSRC " << ssrc << " 2nd time.";
         }
         // Verify sequence numbers are reasonably close.
         int64_t latest_observed = seq_numbers->back();
         int64_t sequence_number_gap = sequence_number - latest_observed;
         EXPECT_LE(std::abs(sequence_number_gap), kMaxSequenceNumberGap)
             << "Gap in sequence numbers (" << latest_observed << " -> "
             << sequence_number << ") too large for SSRC: " << ssrc << ".";
         seq_numbers->push_back(sequence_number);
         if (seq_numbers->size() >= kMaxSequenceNumberGap) {
           seq_numbers->pop_front();
         }
       }
 
-      rtc::CritScope lock(&crit_);
-      ValidateTimestampGap(ssrc, timestamp, only_padding);
+      if (!ssrc_is_rtx_[ssrc]) {
+        rtc::CritScope lock(&crit_);
+        ValidateTimestampGap(ssrc, timestamp, only_padding);
 
-      // Wait for media packets on all ssrcs.
-      if (!ssrc_observed_[ssrc] && !only_padding) {
-        ssrc_observed_[ssrc] = true;
-        if (--ssrcs_to_observe_ == 0)
-          observation_complete_.Set();
+        // Wait for media packets on all ssrcs.
+        if (!ssrc_observed_[ssrc] && !only_padding) {
+          ssrc_observed_[ssrc] = true;
+          if (--ssrcs_to_observe_ == 0)
+            observation_complete_.Set();
+        }
       }
 
       return SEND_PACKET;
     }
 
     Action OnSendRtcp(const uint8_t* packet, size_t length) override {
       test::RtcpPacketParser rtcp_parser;
       rtcp_parser.Parse(packet, length);
       if (rtcp_parser.sender_report()->num_packets() > 0) {
         uint32_t ssrc = rtcp_parser.sender_report()->Ssrc();
         uint32_t rtcp_timestamp = rtcp_parser.sender_report()->RtpTimestamp();
 
         rtc::CritScope lock(&crit_);
         ValidateTimestampGap(ssrc, rtcp_timestamp, false);
       }
       return SEND_PACKET;
     }
 
     SequenceNumberUnwrapper seq_numbers_unwrapper_;
     std::map<uint32_t, std::list<int64_t>> last_observed_seq_numbers_;
     std::map<uint32_t, uint32_t> last_observed_timestamp_;
-    std::map<uint32_t, bool> configured_ssrcs_;
+    std::map<uint32_t, bool> ssrc_is_rtx_;
 
     rtc::CriticalSection crit_;
     size_t ssrcs_to_observe_ GUARDED_BY(crit_);
     std::map<uint32_t, bool> ssrc_observed_ GUARDED_BY(crit_);
   } observer(use_rtx);
 
   CreateCalls(Call::Config(), Call::Config());
 
   test::PacketTransport send_transport(sender_call_.get(), &observer,
                                        test::PacketTransport::kSender,
@@ skipping 89 matching lines @@
   receive_transport.StopSending();
 
   Stop();
   DestroyStreams();
 }
 
 TEST_F(EndToEndTest, RestartingSendStreamPreservesRtpState) {
   TestRtpStatePreservation(false, false);
 }
 
-// These tests are flaky. See:
-// https://bugs.chromium.org/p/webrtc/issues/detail?id=4332
-TEST_F(EndToEndTest, DISABLED_RestartingSendStreamPreservesRtpStatesWithRtx) {
+TEST_F(EndToEndTest, RestartingSendStreamPreservesRtpStatesWithRtx) {
   TestRtpStatePreservation(true, false);
 }
 
-TEST_F(EndToEndTest,
-       DISABLED_RestartingSendStreamKeepsRtpAndRtcpTimestampsSynced) {
+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.
@@ skipping 439 matching lines @@
    private:
     bool video_observed_;
     bool audio_observed_;
     SequenceNumberUnwrapper unwrapper_;
     std::set<int64_t> received_packet_ids_;
   } test;
 
   RunBaseTest(&test);
 }
 }  // namespace webrtc