Try to deflake VideoSendStream tests with FlexFEC.

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 528 matching lines @@
 // TODO(brandtr): Move these FlexFEC tests when we have created
 // FlexfecSendStream.
 class FlexfecObserver : public test::EndToEndTest {
  public:
   FlexfecObserver(bool header_extensions_enabled,
                   bool use_nack,
                   const std::string& codec)
       : EndToEndTest(VideoSendStreamTest::kDefaultTimeoutMs),
         payload_name_(codec),
         use_nack_(use_nack),
-        send_count_(0),
         sent_media_(false),
         sent_flexfec_(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();
     }
   }
 
   size_t GetNumFlexfecStreams() const override { return 1; }
 
  private:
   Action OnSendRtp(const uint8_t* packet, size_t length) override {
     RTPHeader header;
     EXPECT_TRUE(parser_->Parse(packet, length, &header));
 
-    ++send_count_;
     if (header.payloadType == VideoSendStreamTest::kFlexfecPayloadType) {
       EXPECT_EQ(VideoSendStreamTest::kFlexfecSendSsrc, header.ssrc);
       sent_flexfec_ = true;
     } else {
       EXPECT_EQ(VideoSendStreamTest::kFakeVideoSendPayloadType,
                 header.payloadType);
       EXPECT_EQ(VideoSendStreamTest::kVideoSendSsrcs[0], header.ssrc);
       sent_media_ = true;
     }
 
     if (header_extensions_enabled_) {
       EXPECT_TRUE(header.extension.hasAbsoluteSendTime);
       EXPECT_TRUE(header.extension.hasTransmissionTimeOffset);
       EXPECT_TRUE(header.extension.hasTransportSequenceNumber);
     }
 
-    if (send_count_ > 100 && sent_media_ && sent_flexfec_) {
+    if (sent_media_ && sent_flexfec_) {
       observation_complete_.Set();
     }
 
     return SEND_PACKET;
   }
 
   test::PacketTransport* CreateSendTransport(Call* sender_call) override {
     // At low RTT (< kLowRttNackMs) -> NACK only, no FEC.
     // Therefore we need some network delay.
     const int kNetworkDelayMs = 100;
@@ skipping 31 matching lines @@
 
   void PerformTest() override {
     EXPECT_TRUE(Wait())
         << "Timed out waiting for FlexFEC 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_;
-  int send_count_;
   bool sent_media_;
   bool sent_flexfec_;
   bool header_extensions_enabled_;
 };
 
 TEST_F(VideoSendStreamTest, SupportsFlexfecWithRtpExtensionsVp8) {
   FlexfecObserver test(true, false, "VP8");
   RunBaseTest(&test);
 }
 
@@ skipping 2517 matching lines @@
        RequestSourceRotateIfVideoOrientationExtensionNotSupported) {
   TestRequestSourceRotateVideo(false);
 }
 
 TEST_F(VideoSendStreamTest,
        DoNotRequestsRotationIfVideoOrientationExtensionSupported) {
   TestRequestSourceRotateVideo(true);
 }
 
 }  // namespace webrtc