Make VideoSendStreamTest.DoesNotUtilizeUlpfecForH264WithNackEnabled useful again.

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 340 matching lines @@
 };
 
 class UlpfecObserver : public test::EndToEndTest {
  public:
   UlpfecObserver(bool header_extensions_enabled,
                  bool use_nack,
                  bool expect_red,
                  bool expect_ulpfec,
                  const std::string& codec,
                  VideoEncoder* encoder)
-      : EndToEndTest(VideoSendStreamTest::kDefaultTimeoutMs),
+      : EndToEndTest(kTimeoutMs),
         encoder_(encoder),
         payload_name_(codec),
         use_nack_(use_nack),
         expect_red_(expect_red),
         expect_ulpfec_(expect_ulpfec),
         sent_media_(false),
         sent_ulpfec_(false),
         header_extensions_enabled_(header_extensions_enabled) {}
 
+  // Some of the test cases are expected to time out and thus we are using
+  // a shorter timeout window than the default here.
+  static constexpr size_t kTimeoutMs = 10000;
+
  private:
   Action OnSendRtp(const uint8_t* packet, size_t length) override {
     RTPHeader header;
     EXPECT_TRUE(parser_->Parse(packet, length, &header));
 
     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 !=
@@ skipping 33 matching lines @@
     if (encapsulated_payload_type != -1) {
       if (encapsulated_payload_type ==
           VideoSendStreamTest::kUlpfecPayloadType) {
         EXPECT_TRUE(expect_ulpfec_);
         sent_ulpfec_ = true;
       } else {
         sent_media_ = true;
       }
     }
 
-    if (sent_media_) {
-      if (sent_ulpfec_ || !expect_ulpfec_)
-        observation_complete_.Set();
+    if (sent_media_ && sent_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.
@@ skipping 30 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 ULPFEC and/or media packets.";
+    EXPECT_EQ(expect_ulpfec_, Wait())
+        << "Timed out waiting for ULPFEC and/or media packets.";
   }
 
   std::unique_ptr<internal::TransportAdapter> transport_adapter_;
   VideoEncoder* const encoder_;
   std::string payload_name_;
   const bool use_nack_;
   const bool expect_red_;
   const bool expect_ulpfec_;
   bool sent_media_;
   bool sent_ulpfec_;
@@ skipping 2738 matching lines @@
    private:
     Call* call_;
     rtc::CriticalSection crit_;
     uint32_t max_bitrate_kbps_ GUARDED_BY(&crit_);
   } test;
 
   RunBaseTest(&test);
 }
 
 }  // namespace webrtc