Try to deflake VideoSendStream tests with ULPFEC.

webrtc/video/video_send_stream_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>  // max
@@ skipping 335 matching lines @@
     RtcpStatistics stats_;
   };
 
   std::unique_ptr<LossyStatistician> lossy_stats_;
   StatisticianMap stats_map_;
 };
 
 class UlpfecObserver : public test::EndToEndTest {
  public:
   UlpfecObserver(bool header_extensions_enabled,
-              bool use_nack,
-              bool expect_red,
-              bool expect_ulpfec,
-              const std::string& codec)
+                 bool use_nack,
+                 bool expect_red,
+                 bool expect_ulpfec,
+                 const std::string& codec)
       : EndToEndTest(VideoSendStreamTest::kDefaultTimeoutMs),
         payload_name_(codec),
         use_nack_(use_nack),
         expect_red_(expect_red),
         expect_ulpfec_(expect_ulpfec),
-        send_count_(0),
-        received_media_(false),
-        received_fec_(false),
+        sent_media_(false),
+        sent_ulpfec_(false),
         header_extensions_enabled_(header_extensions_enabled) {
     if (codec == "H264") {
       encoder_.reset(new test::FakeH264Encoder(Clock::GetRealTimeClock()));
     } else if (codec == "VP8") {
       encoder_.reset(VP8Encoder::Create());
     } else if (codec == "VP9") {
       encoder_.reset(VP9Encoder::Create());
     } else {
       RTC_NOTREACHED();
     }
   }
 
  private:
   Action OnSendRtp(const uint8_t* packet, size_t length) override {
     RTPHeader header;
     EXPECT_TRUE(parser_->Parse(packet, length, &header));
 
-    ++send_count_;
     int encapsulated_payload_type = -1;
     if (header.payloadType == VideoSendStreamTest::kRedPayloadType) {
       EXPECT_TRUE(expect_red_);
       encapsulated_payload_type = static_cast<int>(packet[header.headerLength]);
       if (encapsulated_payload_type !=
           VideoSendStreamTest::kFakeVideoSendPayloadType) {
         EXPECT_EQ(VideoSendStreamTest::kUlpfecPayloadType,
                   encapsulated_payload_type);
       }
     } else {
       EXPECT_EQ(VideoSendStreamTest::kFakeVideoSendPayloadType,
                 header.payloadType);
       if (static_cast<size_t>(header.headerLength + header.paddingLength) <
           length) {
         // Not padding-only, media received outside of RED.
         EXPECT_FALSE(expect_red_);
-        received_media_ = true;
+        sent_media_ = true;
       }
     }
 
     if (header_extensions_enabled_) {
       EXPECT_TRUE(header.extension.hasAbsoluteSendTime);
       uint32_t kHalf24BitsSpace = 0xFFFFFF / 2;
       if (header.extension.absoluteSendTime <= kHalf24BitsSpace &&
           prev_header_.extension.absoluteSendTime > kHalf24BitsSpace) {
         // 24 bits wrap.
         EXPECT_GT(prev_header_.extension.absoluteSendTime,
                   header.extension.absoluteSendTime);
       } else {
         EXPECT_GE(header.extension.absoluteSendTime,
                   prev_header_.extension.absoluteSendTime);
       }
       EXPECT_TRUE(header.extension.hasTransportSequenceNumber);
       uint16_t seq_num_diff = header.extension.transportSequenceNumber -
                               prev_header_.extension.transportSequenceNumber;
       EXPECT_EQ(1, seq_num_diff);
     }
 
     if (encapsulated_payload_type != -1) {
       if (encapsulated_payload_type ==
           VideoSendStreamTest::kUlpfecPayloadType) {
         EXPECT_TRUE(expect_ulpfec_);
-        received_fec_ = true;
+        sent_ulpfec_ = true;
       } else {
-        received_media_ = true;
+        sent_media_ = true;
       }
     }
 
-    if (send_count_ > 100 && received_media_) {
-      if (received_fec_ || !expect_ulpfec_)
+    if (sent_media_) {
+      if (sent_ulpfec_ || !expect_ulpfec_)
         observation_complete_.Set();
     }
 
     prev_header_ = header;
 
     return SEND_PACKET;
   }
 
   test::PacketTransport* CreateSendTransport(Call* sender_call) override {
     // At low RTT (< kLowRttNackMs) -> NACK only, no FEC.
     // Configure some network delay.
     const int kNetworkDelayMs = 100;
     FakeNetworkPipe::Config config;
-    config.loss_percent = 50;
+    config.loss_percent = 5;
     config.queue_delay_ms = kNetworkDelayMs;
     return new test::PacketTransport(sender_call, this,
                                      test::PacketTransport::kSender, config);
   }
 
   void ModifyVideoConfigs(
       VideoSendStream::Config* send_config,
       std::vector<VideoReceiveStream::Config>* receive_configs,
       VideoEncoderConfig* encoder_config) override {
     transport_adapter_.reset(
@@ skipping 17 matching lines @@
           RtpExtension(RtpExtension::kTransportSequenceNumberUri,
                        test::kTransportSequenceNumberExtensionId));
     }
     (*receive_configs)[0].rtp.ulpfec.red_payload_type =
         send_config->rtp.ulpfec.red_payload_type;
     (*receive_configs)[0].rtp.ulpfec.ulpfec_payload_type =
         send_config->rtp.ulpfec.ulpfec_payload_type;
   }
 
   void PerformTest() override {
-    EXPECT_TRUE(Wait()) << "Timed out waiting for FEC and media packets.";
+    EXPECT_TRUE(Wait()) << "Timed out waiting for ULPFEC and/or media packets.";
   }
 
   std::unique_ptr<internal::TransportAdapter> transport_adapter_;
   std::unique_ptr<VideoEncoder> encoder_;
   const std::string payload_name_;
   const bool use_nack_;
   const bool expect_red_;
   const bool expect_ulpfec_;
-  int send_count_;
-  bool received_media_;
-  bool received_fec_;
+  bool sent_media_;
+  bool sent_ulpfec_;
   bool header_extensions_enabled_;
   RTPHeader prev_header_;
 };
 
 TEST_F(VideoSendStreamTest, SupportsUlpfecWithExtensions) {
   UlpfecObserver test(true, false, true, true, "VP8");
   RunBaseTest(&test);
 }
 
 TEST_F(VideoSendStreamTest, SupportsUlpfecWithoutExtensions) {
@@ skipping 2705 matching lines @@
    private:
     Call* call_;
     rtc::CriticalSection crit_;
     uint32_t max_bitrate_kbps_ GUARDED_BY(&crit_);
   } test;
 
   RunBaseTest(&test);
 }
 
 }  // namespace webrtc