admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

CallTest: migrate timeouts to TimeDelta.

Browse Source 
Bug: webrtc:13756
Change-Id: I1b6675dfd1f0b9f3868c0db81d24e9a80d90657d
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/271483
Auto-Submit: Markus Handell <handellm@webrtc.org>
Commit-Queue: Markus Handell <handellm@webrtc.org>
Reviewed-by: Erik Språng <sprang@webrtc.org>
Reviewed-by: Gustaf Ullberg <gustaf@webrtc.org>
Commit-Queue: Gustaf Ullberg <gustaf@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#37794}
This commit is contained in:
Markus Handell 2022-08-16 11:02:45 +00:00 committed by WebRTC LUCI CQ
parent 476f18d2a4
commit f4f22872d0
29 changed files with 124 additions and 121 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
audio/audio_send_stream_tests.cc
View File

@ -31,7 +31,7 @@ enum : int { // The first valid value is 1.
class AudioSendTest : public SendTest { class AudioSendTest : public SendTest {
public: public:
AudioSendTest() : SendTest(CallTest::kDefaultTimeoutMs) {} AudioSendTest() : SendTest(CallTest::kDefaultTimeout) {}
size_t GetNumVideoStreams() const override { return 0; } size_t GetNumVideoStreams() const override { return 0; }
size_t GetNumAudioStreams() const override { return 1; } size_t GetNumAudioStreams() const override { return 1; }

2
audio/test/audio_bwe_integration_test.cc
View File

@ -35,7 +35,7 @@ enum : int { // The first valid value is 1.
constexpr int kExtraProcessTimeMs = 1000; constexpr int kExtraProcessTimeMs = 1000;
} // namespace } // namespace
AudioBweTest::AudioBweTest() : EndToEndTest(CallTest::kDefaultTimeoutMs) {} AudioBweTest::AudioBweTest() : EndToEndTest(CallTest::kDefaultTimeout) {}
size_t AudioBweTest::GetNumVideoStreams() const { size_t AudioBweTest::GetNumVideoStreams() const {
return 0; return 0;

2
audio/test/audio_end_to_end_test.cc
View File

@ -29,7 +29,7 @@ constexpr int kSampleRate = 48000;
} // namespace } // namespace
AudioEndToEndTest::AudioEndToEndTest() AudioEndToEndTest::AudioEndToEndTest()
: EndToEndTest(CallTest::kDefaultTimeoutMs) {} : EndToEndTest(CallTest::kDefaultTimeout) {}
BuiltInNetworkBehaviorConfig AudioEndToEndTest::GetNetworkPipeConfig() const { BuiltInNetworkBehaviorConfig AudioEndToEndTest::GetNetworkPipeConfig() const {
return BuiltInNetworkBehaviorConfig(); return BuiltInNetworkBehaviorConfig();

2
call/bitrate_estimator_tests.cc
View File

@ -81,7 +81,7 @@ class LogObserver {
} }
} }
bool Wait() { return done_.Wait(test::CallTest::kDefaultTimeoutMs); } bool Wait() { return done_.Wait(test::CallTest::kDefaultTimeout.ms()); }
void PushExpectedLogLine(absl::string_view expected_log_line) { void PushExpectedLogLine(absl::string_view expected_log_line) {
MutexLock lock(&mutex_); MutexLock lock(&mutex_);

14
call/call_perf_tests.cc
View File

@ -106,7 +106,7 @@ class VideoRtcpAndSyncObserver : public test::RtpRtcpObserver,
explicit VideoRtcpAndSyncObserver(TaskQueueBase* task_queue, explicit VideoRtcpAndSyncObserver(TaskQueueBase* task_queue,
Clock* clock, Clock* clock,
absl::string_view test_label) absl::string_view test_label)
: test::RtpRtcpObserver(CallPerfTest::kLongTimeoutMs), : test::RtpRtcpObserver(CallPerfTest::kLongTimeout),
clock_(clock), clock_(clock),
test_label_(test_label), test_label_(test_label),
creation_time_ms_(clock_->TimeInMilliseconds()), creation_time_ms_(clock_->TimeInMilliseconds()),
@ -387,7 +387,7 @@ void CallPerfTest::TestCaptureNtpTime(
int threshold_ms, int threshold_ms,
int start_time_ms, int start_time_ms,
int run_time_ms) int run_time_ms)
: EndToEndTest(kLongTimeoutMs), : EndToEndTest(kLongTimeout),
net_config_(net_config), net_config_(net_config),
clock_(Clock::GetRealTimeClock()), clock_(Clock::GetRealTimeClock()),
threshold_ms_(threshold_ms), threshold_ms_(threshold_ms),
@ -552,7 +552,7 @@ TEST_F(CallPerfTest, ReceivesCpuOveruseAndUnderuse) {
class LoadObserver : public test::SendTest, class LoadObserver : public test::SendTest,
public test::FrameGeneratorCapturer::SinkWantsObserver { public test::FrameGeneratorCapturer::SinkWantsObserver {
public: public:
LoadObserver() : SendTest(kLongTimeoutMs), test_phase_(TestPhase::kInit) {} LoadObserver() : SendTest(kLongTimeout), test_phase_(TestPhase::kInit) {}
void OnFrameGeneratorCapturerCreated( void OnFrameGeneratorCapturerCreated(
test::FrameGeneratorCapturer* frame_generator_capturer) override { test::FrameGeneratorCapturer* frame_generator_capturer) override {
@ -661,7 +661,7 @@ void CallPerfTest::TestMinTransmitBitrate(bool pad_to_min_bitrate) {
public: public:
explicit BitrateObserver(bool using_min_transmit_bitrate, explicit BitrateObserver(bool using_min_transmit_bitrate,
TaskQueueBase* task_queue) TaskQueueBase* task_queue)
: EndToEndTest(kLongTimeoutMs), : EndToEndTest(kLongTimeout),
send_stream_(nullptr), send_stream_(nullptr),
converged_(false), converged_(false),
pad_to_min_bitrate_(using_min_transmit_bitrate), pad_to_min_bitrate_(using_min_transmit_bitrate),
@ -791,7 +791,7 @@ TEST_F(CallPerfTest, MAYBE_KeepsHighBitrateWhenReconfiguringSender) {
class BitrateObserver : public test::EndToEndTest, public test::FakeEncoder { class BitrateObserver : public test::EndToEndTest, public test::FakeEncoder {
public: public:
explicit BitrateObserver(TaskQueueBase* task_queue) explicit BitrateObserver(TaskQueueBase* task_queue)
: EndToEndTest(kDefaultTimeoutMs), : EndToEndTest(kDefaultTimeout),
FakeEncoder(Clock::GetRealTimeClock()), FakeEncoder(Clock::GetRealTimeClock()),
encoder_inits_(0), encoder_inits_(0),
last_set_bitrate_kbps_(0), last_set_bitrate_kbps_(0),
@ -867,7 +867,7 @@ TEST_F(CallPerfTest, MAYBE_KeepsHighBitrateWhenReconfiguringSender) {
} }
void PerformTest() override { void PerformTest() override {
ASSERT_TRUE(time_to_reconfigure_.Wait(kDefaultTimeoutMs)) ASSERT_TRUE(time_to_reconfigure_.Wait(kDefaultTimeout.ms()))
<< "Timed out before receiving an initial high bitrate."; << "Timed out before receiving an initial high bitrate.";
frame_generator_->ChangeResolution(kDefaultWidth * 2, kDefaultHeight * 2); frame_generator_->ChangeResolution(kDefaultWidth * 2, kDefaultHeight * 2);
SendTask(task_queue_, [&]() { SendTask(task_queue_, [&]() {
@ -1071,7 +1071,7 @@ void CallPerfTest::TestEncodeFramerate(VideoEncoderFactory* encoder_factory,
absl::string_view payload_name, absl::string_view payload_name,
const std::vector<int>& max_framerates, const std::vector<int>& max_framerates,
TaskQueueBase* task_queue) TaskQueueBase* task_queue)
: EndToEndTest(kDefaultTimeoutMs), : EndToEndTest(kDefaultTimeout),
clock_(Clock::GetRealTimeClock()), clock_(Clock::GetRealTimeClock()),
encoder_factory_(encoder_factory), encoder_factory_(encoder_factory),
payload_name_(payload_name), payload_name_(payload_name),

2
call/rampup_tests.cc
View File

@ -64,7 +64,7 @@ RampUpTester::RampUpTester(size_t num_video_streams,
bool red, bool red,
bool report_perf_stats, bool report_perf_stats,
TaskQueueBase* task_queue) TaskQueueBase* task_queue)
: EndToEndTest(test::CallTest::kLongTimeoutMs), : EndToEndTest(test::CallTest::kLongTimeout),
clock_(Clock::GetRealTimeClock()), clock_(Clock::GetRealTimeClock()),
num_video_streams_(num_video_streams), num_video_streams_(num_video_streams),
num_audio_streams_(num_audio_streams), num_audio_streams_(num_audio_streams),

1
test/BUILD.gn
View File

@ -978,6 +978,7 @@ rtc_library("test_common") {
"../api/task_queue:default_task_queue_factory", "../api/task_queue:default_task_queue_factory",
"../api/test/video:function_video_factory", "../api/test/video:function_video_factory",
"../api/transport:field_trial_based_config", "../api/transport:field_trial_based_config",
"../api/units:time_delta",
"../api/video:builtin_video_bitrate_allocator_factory", "../api/video:builtin_video_bitrate_allocator_factory",
"../api/video:video_bitrate_allocator_factory", "../api/video:video_bitrate_allocator_factory",
"../api/video:video_frame", "../api/video:video_frame",

8
test/call_test.cc
View File

@ -700,8 +700,6 @@ constexpr size_t CallTest::kNumSsrcs;
const int CallTest::kDefaultWidth; const int CallTest::kDefaultWidth;
const int CallTest::kDefaultHeight; const int CallTest::kDefaultHeight;
const int CallTest::kDefaultFramerate; const int CallTest::kDefaultFramerate;
const int CallTest::kDefaultTimeoutMs = 30 * 1000;
const int CallTest::kLongTimeoutMs = 120 * 1000;
const uint32_t CallTest::kSendRtxSsrcs[kNumSsrcs] = { const uint32_t CallTest::kSendRtxSsrcs[kNumSsrcs] = {
0xBADCAFD, 0xBADCAFE, 0xBADCAFF, 0xBADCB00, 0xBADCB01, 0xBADCB02}; 0xBADCAFD, 0xBADCAFE, 0xBADCAFF, 0xBADCB00, 0xBADCB01, 0xBADCB02};
const uint32_t CallTest::kVideoSendSsrcs[kNumSsrcs] = { const uint32_t CallTest::kVideoSendSsrcs[kNumSsrcs] = {
@ -724,7 +722,7 @@ const std::map<uint8_t, MediaType> CallTest::payload_type_map_ = {
BaseTest::BaseTest() {} BaseTest::BaseTest() {}
BaseTest::BaseTest(int timeout_ms) : RtpRtcpObserver(timeout_ms) {} BaseTest::BaseTest(TimeDelta timeout) : RtpRtcpObserver(timeout) {}
BaseTest::~BaseTest() {} BaseTest::~BaseTest() {}
@ -815,7 +813,7 @@ void BaseTest::OnFrameGeneratorCapturerCreated(
void BaseTest::OnStreamsStopped() {} void BaseTest::OnStreamsStopped() {}
SendTest::SendTest(int timeout_ms) : BaseTest(timeout_ms) {} SendTest::SendTest(TimeDelta timeout) : BaseTest(timeout) {}
bool SendTest::ShouldCreateReceivers() const { bool SendTest::ShouldCreateReceivers() const {
return false; return false;
@ -823,7 +821,7 @@ bool SendTest::ShouldCreateReceivers() const {
EndToEndTest::EndToEndTest() {} EndToEndTest::EndToEndTest() {}
EndToEndTest::EndToEndTest(int timeout_ms) : BaseTest(timeout_ms) {} EndToEndTest::EndToEndTest(TimeDelta timeout) : BaseTest(timeout) {}
bool EndToEndTest::ShouldCreateReceivers() const { bool EndToEndTest::ShouldCreateReceivers() const {
return true; return true;

11
test/call_test.h
View File

@ -21,6 +21,7 @@
#include "api/task_queue/task_queue_factory.h" #include "api/task_queue/task_queue_factory.h"
#include "api/test/video/function_video_decoder_factory.h" #include "api/test/video/function_video_decoder_factory.h"
#include "api/test/video/function_video_encoder_factory.h" #include "api/test/video/function_video_encoder_factory.h"
#include "api/units/time_delta.h"
#include "api/video/video_bitrate_allocator_factory.h" #include "api/video/video_bitrate_allocator_factory.h"
#include "call/call.h" #include "call/call.h"
#include "modules/audio_device/include/test_audio_device.h" #include "modules/audio_device/include/test_audio_device.h"
@ -48,8 +49,8 @@ class CallTest : public ::testing::Test, public RtpPacketSinkInterface {
static const int kDefaultWidth = 320; static const int kDefaultWidth = 320;
static const int kDefaultHeight = 180; static const int kDefaultHeight = 180;
static const int kDefaultFramerate = 30; static const int kDefaultFramerate = 30;
static const int kDefaultTimeoutMs; static constexpr TimeDelta kDefaultTimeout = TimeDelta::Seconds(30);
static const int kLongTimeoutMs; static constexpr TimeDelta kLongTimeout = TimeDelta::Seconds(120);
enum classPayloadTypes : uint8_t { enum classPayloadTypes : uint8_t {
kSendRtxPayloadType = 98, kSendRtxPayloadType = 98,
kRtxRedPayloadType = 99, kRtxRedPayloadType = 99,
@ -246,7 +247,7 @@ class CallTest : public ::testing::Test, public RtpPacketSinkInterface {
class BaseTest : public RtpRtcpObserver { class BaseTest : public RtpRtcpObserver {
public: public:
BaseTest(); BaseTest();
explicit BaseTest(int timeout_ms); explicit BaseTest(TimeDelta timeout);
virtual ~BaseTest(); virtual ~BaseTest();
virtual void PerformTest() = 0; virtual void PerformTest() = 0;
@ -307,7 +308,7 @@ class BaseTest : public RtpRtcpObserver {
class SendTest : public BaseTest { class SendTest : public BaseTest {
public: public:
explicit SendTest(int timeout_ms); explicit SendTest(TimeDelta timeout);
bool ShouldCreateReceivers() const override; bool ShouldCreateReceivers() const override;
}; };
@ -315,7 +316,7 @@ class SendTest : public BaseTest {
class EndToEndTest : public BaseTest { class EndToEndTest : public BaseTest {
public: public:
EndToEndTest(); EndToEndTest();
explicit EndToEndTest(int timeout_ms); explicit EndToEndTest(TimeDelta timeout);
bool ShouldCreateReceivers() const override; bool ShouldCreateReceivers() const override;
}; };

6
test/rtp_rtcp_observer.h
View File

@ -68,9 +68,9 @@ class RtpRtcpObserver {
} }
protected: protected:
RtpRtcpObserver() : RtpRtcpObserver(0) {} RtpRtcpObserver() : RtpRtcpObserver(TimeDelta::Zero()) {}
explicit RtpRtcpObserver(int event_timeout_ms) explicit RtpRtcpObserver(TimeDelta event_timeout)
: timeout_ms_(event_timeout_ms) {} : timeout_ms_(event_timeout.ms()) {}
rtc::Event observation_complete_; rtc::Event observation_complete_;

2
video/cpu_scaling_tests.cc
View File

@ -55,7 +55,7 @@ void CpuOveruseTest::RunTestAndCheckForAdaptation(
public: public:
OveruseObserver(const DegradationPreference& degradation_preference, OveruseObserver(const DegradationPreference& degradation_preference,
bool expect_adaptation) bool expect_adaptation)
: SendTest(expect_adaptation ? kLongTimeoutMs : kDefaultTimeoutMs), : SendTest(expect_adaptation ? kLongTimeout : kDefaultTimeout),
degradation_preference_(degradation_preference), degradation_preference_(degradation_preference),
expect_adaptation_(expect_adaptation) {} expect_adaptation_(expect_adaptation) {}

12
video/end_to_end_tests/bandwidth_tests.cc
View File

@ -46,7 +46,7 @@ class BandwidthEndToEndTest : public test::CallTest {
TEST_F(BandwidthEndToEndTest, ReceiveStreamSendsRemb) { TEST_F(BandwidthEndToEndTest, ReceiveStreamSendsRemb) {
class RembObserver : public test::EndToEndTest { class RembObserver : public test::EndToEndTest {
public: public:
RembObserver() : EndToEndTest(kDefaultTimeoutMs) {} RembObserver() : EndToEndTest(kDefaultTimeout) {}
void ModifyVideoConfigs( void ModifyVideoConfigs(
VideoSendStream::Config* send_config, VideoSendStream::Config* send_config,
@ -85,7 +85,7 @@ TEST_F(BandwidthEndToEndTest, ReceiveStreamSendsRemb) {
class BandwidthStatsTest : public test::EndToEndTest { class BandwidthStatsTest : public test::EndToEndTest {
public: public:
BandwidthStatsTest(bool send_side_bwe, TaskQueueBase* task_queue) BandwidthStatsTest(bool send_side_bwe, TaskQueueBase* task_queue)
: EndToEndTest(test::CallTest::kDefaultTimeoutMs), : EndToEndTest(test::CallTest::kDefaultTimeout),
sender_call_(nullptr), sender_call_(nullptr),
receiver_call_(nullptr), receiver_call_(nullptr),
has_seen_pacer_delay_(false), has_seen_pacer_delay_(false),
@ -194,7 +194,7 @@ TEST_F(BandwidthEndToEndTest, RembWithSendSideBwe) {
class BweObserver : public test::EndToEndTest { class BweObserver : public test::EndToEndTest {
public: public:
explicit BweObserver(TaskQueueBase* task_queue) explicit BweObserver(TaskQueueBase* task_queue)
: EndToEndTest(kDefaultTimeoutMs), : EndToEndTest(kDefaultTimeout),
sender_call_(nullptr), sender_call_(nullptr),
clock_(Clock::GetRealTimeClock()), clock_(Clock::GetRealTimeClock()),
sender_ssrc_(0), sender_ssrc_(0),
@ -320,7 +320,7 @@ TEST_F(BandwidthEndToEndTest, ReportsSetEncoderRates) {
public test::FakeEncoder { public test::FakeEncoder {
public: public:
explicit EncoderRateStatsTest(TaskQueueBase* task_queue) explicit EncoderRateStatsTest(TaskQueueBase* task_queue)
: EndToEndTest(kDefaultTimeoutMs), : EndToEndTest(kDefaultTimeout),
FakeEncoder(Clock::GetRealTimeClock()), FakeEncoder(Clock::GetRealTimeClock()),
task_queue_(task_queue), task_queue_(task_queue),
send_stream_(nullptr), send_stream_(nullptr),
@ -368,7 +368,7 @@ TEST_F(BandwidthEndToEndTest, ReportsSetEncoderRates) {
} }
void WaitForEncoderTargetBitrateMatchStats() { void WaitForEncoderTargetBitrateMatchStats() {
for (int i = 0; i < kDefaultTimeoutMs; ++i) { for (int i = 0; i < kDefaultTimeout.ms(); ++i) {
VideoSendStream::Stats stats = send_stream_->GetStats(); VideoSendStream::Stats stats = send_stream_->GetStats();
{ {
MutexLock lock(&mutex_); MutexLock lock(&mutex_);
@ -384,7 +384,7 @@ TEST_F(BandwidthEndToEndTest, ReportsSetEncoderRates) {
} }
void WaitForStatsReportZeroTargetBitrate() { void WaitForStatsReportZeroTargetBitrate() {
for (int i = 0; i < kDefaultTimeoutMs; ++i) { for (int i = 0; i < kDefaultTimeout.ms(); ++i) {
if (send_stream_->GetStats().target_media_bitrate_bps == 0) { if (send_stream_->GetStats().target_media_bitrate_bps == 0) {
return; return;
} }

4
video/end_to_end_tests/call_operation_tests.cc
View File

@ -88,7 +88,7 @@ TEST_F(CallOperationEndToEndTest, RendersSingleDelayedFrame) {
event_.Set(); event_.Set();
} }
bool Wait() { return event_.Wait(kDefaultTimeoutMs); } bool Wait() { return event_.Wait(kDefaultTimeout.ms()); }
rtc::Event event_; rtc::Event event_;
} renderer; } renderer;
@ -159,7 +159,7 @@ TEST_F(CallOperationEndToEndTest, TransmitsFirstFrame) {
public: public:
void OnFrame(const VideoFrame& video_frame) override { event_.Set(); } void OnFrame(const VideoFrame& video_frame) override { event_.Set(); }
bool Wait() { return event_.Wait(kDefaultTimeoutMs); } bool Wait() { return event_.Wait(kDefaultTimeout.ms()); }
rtc::Event event_; rtc::Event event_;
} renderer; } renderer;

2
video/end_to_end_tests/codec_tests.cc
View File

@ -53,7 +53,7 @@ class CodecObserver : public test::EndToEndTest,
const std::string& payload_name, const std::string& payload_name,
VideoEncoderFactory* encoder_factory, VideoEncoderFactory* encoder_factory,
VideoDecoderFactory* decoder_factory) VideoDecoderFactory* decoder_factory)
: EndToEndTest(4 * CodecEndToEndTest::kDefaultTimeoutMs), : EndToEndTest(4 * CodecEndToEndTest::kDefaultTimeout),
// TODO(hta): This timeout (120 seconds) is excessive. // TODO(hta): This timeout (120 seconds) is excessive.
// https://bugs.webrtc.org/6830 // https://bugs.webrtc.org/6830
no_frames_to_wait_for_(no_frames_to_wait_for), no_frames_to_wait_for_(no_frames_to_wait_for),

2
video/end_to_end_tests/extended_reports_tests.cc
View File

@ -63,7 +63,7 @@ class RtcpXrObserver : public test::EndToEndTest {
bool expect_target_bitrate, bool expect_target_bitrate,
bool enable_zero_target_bitrate, bool enable_zero_target_bitrate,
VideoEncoderConfig::ContentType content_type) VideoEncoderConfig::ContentType content_type)
: EndToEndTest(test::CallTest::kDefaultTimeoutMs), : EndToEndTest(test::CallTest::kDefaultTimeout),
enable_rrtr_(enable_rrtr), enable_rrtr_(enable_rrtr),
expect_target_bitrate_(expect_target_bitrate), expect_target_bitrate_(expect_target_bitrate),
enable_zero_target_bitrate_(enable_zero_target_bitrate), enable_zero_target_bitrate_(enable_zero_target_bitrate),

6
video/end_to_end_tests/fec_tests.cc
View File

@ -53,7 +53,7 @@ TEST_F(FecEndToEndTest, ReceivesUlpfec) {
public rtc::VideoSinkInterface<VideoFrame> { public rtc::VideoSinkInterface<VideoFrame> {
public: public:
UlpfecRenderObserver() UlpfecRenderObserver()
: EndToEndTest(kDefaultTimeoutMs), : EndToEndTest(kDefaultTimeout),
encoder_factory_([]() { return VP8Encoder::Create(); }), encoder_factory_([]() { return VP8Encoder::Create(); }),
random_(0xcafef00d1), random_(0xcafef00d1),
num_packets_sent_(0) {} num_packets_sent_(0) {}
@ -159,7 +159,7 @@ class FlexfecRenderObserver : public test::EndToEndTest,
static constexpr uint32_t kFlexfecLocalSsrc = 456; static constexpr uint32_t kFlexfecLocalSsrc = 456;
explicit FlexfecRenderObserver(bool enable_nack, bool expect_flexfec_rtcp) explicit FlexfecRenderObserver(bool enable_nack, bool expect_flexfec_rtcp)
: test::EndToEndTest(test::CallTest::kDefaultTimeoutMs), : test::EndToEndTest(test::CallTest::kDefaultTimeout),
enable_nack_(enable_nack), enable_nack_(enable_nack),
expect_flexfec_rtcp_(expect_flexfec_rtcp), expect_flexfec_rtcp_(expect_flexfec_rtcp),
received_flexfec_rtcp_(false), received_flexfec_rtcp_(false),
@ -352,7 +352,7 @@ TEST_F(FecEndToEndTest, ReceivedUlpfecPacketsNotNacked) {
class UlpfecNackObserver : public test::EndToEndTest { class UlpfecNackObserver : public test::EndToEndTest {
public: public:
UlpfecNackObserver() UlpfecNackObserver()
: EndToEndTest(kDefaultTimeoutMs), : EndToEndTest(kDefaultTimeout),
state_(kFirstPacket), state_(kFirstPacket),
ulpfec_sequence_number_(0), ulpfec_sequence_number_(0),
has_last_sequence_number_(false), has_last_sequence_number_(false),

2
video/end_to_end_tests/frame_encryption_tests.cc
View File

@ -29,7 +29,7 @@ class DecryptedFrameObserver : public test::EndToEndTest,
public rtc::VideoSinkInterface<VideoFrame> { public rtc::VideoSinkInterface<VideoFrame> {
public: public:
DecryptedFrameObserver() DecryptedFrameObserver()
: EndToEndTest(test::CallTest::kDefaultTimeoutMs), : EndToEndTest(test::CallTest::kDefaultTimeout),
encoder_factory_([] { return VP8Encoder::Create(); }) {} encoder_factory_([] { return VP8Encoder::Create(); }) {}
private: private:

2
video/end_to_end_tests/histogram_tests.cc
View File

@ -44,7 +44,7 @@ void HistogramTest::VerifyHistogramStats(bool use_rtx,
public rtc::VideoSinkInterface<VideoFrame> { public rtc::VideoSinkInterface<VideoFrame> {
public: public:
FrameObserver(bool use_rtx, bool use_fec, bool screenshare) FrameObserver(bool use_rtx, bool use_fec, bool screenshare)
: EndToEndTest(kLongTimeoutMs), : EndToEndTest(kLongTimeout),
use_rtx_(use_rtx), use_rtx_(use_rtx),
use_fec_(use_fec), use_fec_(use_fec),
screenshare_(screenshare), screenshare_(screenshare),

2
video/end_to_end_tests/multi_codec_receive_tests.cc
View File

@ -63,7 +63,7 @@ int RemoveOlderOrEqual(uint32_t timestamp, std::vector<uint32_t>* timestamps) {
class FrameObserver : public test::RtpRtcpObserver, class FrameObserver : public test::RtpRtcpObserver,
public rtc::VideoSinkInterface<VideoFrame> { public rtc::VideoSinkInterface<VideoFrame> {
public: public:
FrameObserver() : test::RtpRtcpObserver(test::CallTest::kDefaultTimeoutMs) {} FrameObserver() : test::RtpRtcpObserver(test::CallTest::kDefaultTimeout) {}
void Reset(uint8_t expected_payload_type) { void Reset(uint8_t expected_payload_type) {
MutexLock lock(&mutex_); MutexLock lock(&mutex_);

4
video/end_to_end_tests/network_state_tests.cc
View File

@ -168,7 +168,7 @@ TEST_F(NetworkStateEndToEndTest, RespectsNetworkState) {
class NetworkStateTest : public test::EndToEndTest, public test::FakeEncoder { class NetworkStateTest : public test::EndToEndTest, public test::FakeEncoder {
public: public:
explicit NetworkStateTest(TaskQueueBase* task_queue) explicit NetworkStateTest(TaskQueueBase* task_queue)
: EndToEndTest(kDefaultTimeoutMs), : EndToEndTest(kDefaultTimeout),
FakeEncoder(Clock::GetRealTimeClock()), FakeEncoder(Clock::GetRealTimeClock()),
e2e_test_task_queue_(task_queue), e2e_test_task_queue_(task_queue),
task_queue_(CreateDefaultTaskQueueFactory()->CreateTaskQueue( task_queue_(CreateDefaultTaskQueueFactory()->CreateTaskQueue(
@ -235,7 +235,7 @@ TEST_F(NetworkStateEndToEndTest, RespectsNetworkState) {
} }
void PerformTest() override { void PerformTest() override {
EXPECT_TRUE(encoded_frames_.Wait(kDefaultTimeoutMs)) EXPECT_TRUE(encoded_frames_.Wait(kDefaultTimeout.ms()))
<< "No frames received by the encoder."; << "No frames received by the encoder.";
SendTask(task_queue_.get(), [this]() { SendTask(task_queue_.get(), [this]() {

2
video/end_to_end_tests/resolution_bitrate_limits_tests.cc
View File

@ -103,7 +103,7 @@ class InitEncodeTest : public test::EndToEndTest,
InitEncodeTest(const std::string& payload_name, InitEncodeTest(const std::string& payload_name,
const std::vector<TestConfig>& configs, const std::vector<TestConfig>& configs,
const std::vector<Expectation>& expectations) const std::vector<Expectation>& expectations)
: EndToEndTest(test::CallTest::kDefaultTimeoutMs), : EndToEndTest(test::CallTest::kDefaultTimeout),
FakeEncoder(Clock::GetRealTimeClock()), FakeEncoder(Clock::GetRealTimeClock()),
encoder_factory_(this), encoder_factory_(this),
payload_name_(payload_name), payload_name_(payload_name),

8
video/end_to_end_tests/retransmission_tests.cc
View File

@ -53,7 +53,7 @@ TEST_F(RetransmissionEndToEndTest, ReceivesAndRetransmitsNack) {
class NackObserver : public test::EndToEndTest { class NackObserver : public test::EndToEndTest {
public: public:
NackObserver() NackObserver()
: EndToEndTest(kLongTimeoutMs), : EndToEndTest(kLongTimeout),
sent_rtp_packets_(0), sent_rtp_packets_(0),
packets_left_to_drop_(0), packets_left_to_drop_(0),
nacks_left_(kNumberOfNacksToObserve) {} nacks_left_(kNumberOfNacksToObserve) {}
@ -133,7 +133,7 @@ TEST_F(RetransmissionEndToEndTest, ReceivesNackAndRetransmitsAudio) {
class NackObserver : public test::EndToEndTest { class NackObserver : public test::EndToEndTest {
public: public:
NackObserver() NackObserver()
: EndToEndTest(kLongTimeoutMs), : EndToEndTest(kLongTimeout),
local_ssrc_(0), local_ssrc_(0),
remote_ssrc_(0), remote_ssrc_(0),
receive_transport_(nullptr) {} receive_transport_(nullptr) {}
@ -282,7 +282,7 @@ void RetransmissionEndToEndTest::ReceivesPliAndRecovers(int rtp_history_ms) {
public rtc::VideoSinkInterface<VideoFrame> { public rtc::VideoSinkInterface<VideoFrame> {
public: public:
explicit PliObserver(int rtp_history_ms) explicit PliObserver(int rtp_history_ms)
: EndToEndTest(kLongTimeoutMs), : EndToEndTest(kLongTimeout),
rtp_history_ms_(rtp_history_ms), rtp_history_ms_(rtp_history_ms),
nack_enabled_(rtp_history_ms > 0), nack_enabled_(rtp_history_ms > 0),
highest_dropped_timestamp_(0), highest_dropped_timestamp_(0),
@ -372,7 +372,7 @@ void RetransmissionEndToEndTest::DecodesRetransmittedFrame(bool enable_rtx,
public rtc::VideoSinkInterface<VideoFrame> { public rtc::VideoSinkInterface<VideoFrame> {
public: public:
RetransmissionObserver(bool enable_rtx, bool enable_red) RetransmissionObserver(bool enable_rtx, bool enable_red)
: EndToEndTest(kDefaultTimeoutMs), : EndToEndTest(kDefaultTimeout),
payload_type_(GetPayloadType(false, enable_red)), payload_type_(GetPayloadType(false, enable_red)),
retransmission_ssrc_(enable_rtx ? kSendRtxSsrcs[0] retransmission_ssrc_(enable_rtx ? kSendRtxSsrcs[0]
: kVideoSendSsrcs[0]), : kVideoSendSsrcs[0]),

8
video/end_to_end_tests/rtp_rtcp_tests.cc
View File

@ -40,7 +40,7 @@ void RtpRtcpEndToEndTest::RespectsRtcpMode(RtcpMode rtcp_mode) {
class RtcpModeObserver : public test::EndToEndTest { class RtcpModeObserver : public test::EndToEndTest {
public: public:
explicit RtcpModeObserver(RtcpMode rtcp_mode) explicit RtcpModeObserver(RtcpMode rtcp_mode)
: EndToEndTest(kDefaultTimeoutMs), : EndToEndTest(kDefaultTimeout),
rtcp_mode_(rtcp_mode), rtcp_mode_(rtcp_mode),
sent_rtp_(0), sent_rtp_(0),
sent_rtcp_(0) {} sent_rtcp_(0) {}
@ -167,7 +167,7 @@ void RtpRtcpEndToEndTest::TestRtpStatePreservation(
class RtpSequenceObserver : public test::RtpRtcpObserver { class RtpSequenceObserver : public test::RtpRtcpObserver {
public: public:
explicit RtpSequenceObserver(bool use_rtx) explicit RtpSequenceObserver(bool use_rtx)
: test::RtpRtcpObserver(kDefaultTimeoutMs), : test::RtpRtcpObserver(kDefaultTimeout),
ssrcs_to_observe_(kNumSimulcastStreams) { ssrcs_to_observe_(kNumSimulcastStreams) {
for (size_t i = 0; i < kNumSimulcastStreams; ++i) { for (size_t i = 0; i < kNumSimulcastStreams; ++i) {
ssrc_is_rtx_[kVideoSendSsrcs[i]] = false; ssrc_is_rtx_[kVideoSendSsrcs[i]] = false;
@ -187,7 +187,7 @@ void RtpRtcpEndToEndTest::TestRtpStatePreservation(
uint32_t timestamp, uint32_t timestamp,
bool only_padding) bool only_padding)
RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_) { RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_) {
static const int32_t kMaxTimestampGap = kDefaultTimeoutMs * 90; static const int32_t kMaxTimestampGap = kDefaultTimeout.ms() * 90;
auto timestamp_it = last_observed_timestamp_.find(ssrc); auto timestamp_it = last_observed_timestamp_.find(ssrc);
if (timestamp_it == last_observed_timestamp_.end()) { if (timestamp_it == last_observed_timestamp_.end()) {
EXPECT_FALSE(only_padding); EXPECT_FALSE(only_padding);
@ -409,7 +409,7 @@ TEST_F(RtpRtcpEndToEndTest, DISABLED_TestFlexfecRtpStatePreservation) {
class RtpSequenceObserver : public test::RtpRtcpObserver { class RtpSequenceObserver : public test::RtpRtcpObserver {
public: public:
RtpSequenceObserver() RtpSequenceObserver()
: test::RtpRtcpObserver(kDefaultTimeoutMs), : test::RtpRtcpObserver(kDefaultTimeout),
num_flexfec_packets_sent_(0) {} num_flexfec_packets_sent_(0) {}
void ResetPacketCount() { void ResetPacketCount() {

8
video/end_to_end_tests/ssrc_tests.cc
View File

@ -29,7 +29,7 @@ class SsrcEndToEndTest : public test::CallTest {
TEST_F(SsrcEndToEndTest, ReceiverUsesLocalSsrc) { TEST_F(SsrcEndToEndTest, ReceiverUsesLocalSsrc) {
class SyncRtcpObserver : public test::EndToEndTest { class SyncRtcpObserver : public test::EndToEndTest {
public: public:
SyncRtcpObserver() : EndToEndTest(kDefaultTimeoutMs) {} SyncRtcpObserver() : EndToEndTest(kDefaultTimeout) {}
Action OnReceiveRtcp(const uint8_t* packet, size_t length) override { Action OnReceiveRtcp(const uint8_t* packet, size_t length) override {
test::RtcpPacketParser parser; test::RtcpPacketParser parser;
@ -55,7 +55,7 @@ TEST_F(SsrcEndToEndTest, UnknownRtpPacketGivesUnknownSsrcReturnCode) {
explicit PacketInputObserver(PacketReceiver* receiver) explicit PacketInputObserver(PacketReceiver* receiver)
: receiver_(receiver) {} : receiver_(receiver) {}
bool Wait() { return delivered_packet_.Wait(kDefaultTimeoutMs); } bool Wait() { return delivered_packet_.Wait(kDefaultTimeout.ms()); }
private: private:
DeliveryStatus DeliverPacket(MediaType media_type, DeliveryStatus DeliverPacket(MediaType media_type,
@ -134,7 +134,7 @@ void SsrcEndToEndTest::TestSendsSetSsrcs(size_t num_ssrcs,
size_t num_ssrcs, size_t num_ssrcs,
bool send_single_ssrc_first, bool send_single_ssrc_first,
TaskQueueBase* task_queue) TaskQueueBase* task_queue)
: EndToEndTest(kDefaultTimeoutMs), : EndToEndTest(kDefaultTimeout),
num_ssrcs_(num_ssrcs), num_ssrcs_(num_ssrcs),
send_single_ssrc_first_(send_single_ssrc_first), send_single_ssrc_first_(send_single_ssrc_first),
ssrcs_to_observe_(num_ssrcs), ssrcs_to_observe_(num_ssrcs),
@ -244,7 +244,7 @@ TEST_F(SsrcEndToEndTest, DISABLED_RedundantPayloadsTransmittedOnAllSsrcs) {
class ObserveRedundantPayloads : public test::EndToEndTest { class ObserveRedundantPayloads : public test::EndToEndTest {
public: public:
ObserveRedundantPayloads() ObserveRedundantPayloads()
: EndToEndTest(kDefaultTimeoutMs), : EndToEndTest(kDefaultTimeout),
ssrcs_to_observe_(kNumSimulcastStreams) { ssrcs_to_observe_(kNumSimulcastStreams) {
for (size_t i = 0; i < kNumSimulcastStreams; ++i) { for (size_t i = 0; i < kNumSimulcastStreams; ++i) {
registered_rtx_ssrc_[kSendRtxSsrcs[i]] = true; registered_rtx_ssrc_[kSendRtxSsrcs[i]] = true;

15
video/end_to_end_tests/stats_tests.cc
View File

@ -51,7 +51,7 @@ TEST_F(StatsEndToEndTest, GetStats) {
class StatsObserver : public test::EndToEndTest { class StatsObserver : public test::EndToEndTest {
public: public:
StatsObserver() StatsObserver()
: EndToEndTest(kLongTimeoutMs), encoder_factory_([]() { : EndToEndTest(kLongTimeout), encoder_factory_([]() {
return std::make_unique<test::DelayedEncoder>( return std::make_unique<test::DelayedEncoder>(
Clock::GetRealTimeClock(), 10); Clock::GetRealTimeClock(), 10);
}) {} }) {}
@ -292,7 +292,7 @@ TEST_F(StatsEndToEndTest, GetStats) {
void PerformTest() override { void PerformTest() override {
Clock* clock = Clock::GetRealTimeClock(); Clock* clock = Clock::GetRealTimeClock();
int64_t now_ms = clock->TimeInMilliseconds(); int64_t now_ms = clock->TimeInMilliseconds();
int64_t stop_time_ms = now_ms + test::CallTest::kLongTimeoutMs; int64_t stop_time_ms = now_ms + test::CallTest::kLongTimeout.ms();
bool receive_ok = false; bool receive_ok = false;
bool send_ok = false; bool send_ok = false;
@ -347,7 +347,7 @@ TEST_F(StatsEndToEndTest, TimingFramesAreReported) {
class StatsObserver : public test::EndToEndTest { class StatsObserver : public test::EndToEndTest {
public: public:
StatsObserver() : EndToEndTest(kLongTimeoutMs) {} StatsObserver() : EndToEndTest(kLongTimeout) {}
private: private:
void ModifyVideoConfigs( void ModifyVideoConfigs(
@ -400,7 +400,7 @@ TEST_F(StatsEndToEndTest, TestReceivedRtpPacketStats) {
class ReceivedRtpStatsObserver : public test::EndToEndTest { class ReceivedRtpStatsObserver : public test::EndToEndTest {
public: public:
explicit ReceivedRtpStatsObserver(TaskQueueBase* task_queue) explicit ReceivedRtpStatsObserver(TaskQueueBase* task_queue)
: EndToEndTest(kDefaultTimeoutMs), task_queue_(task_queue) {} : EndToEndTest(kDefaultTimeout), task_queue_(task_queue) {}
private: private:
void OnVideoStreamsCreated(VideoSendStream* send_stream, void OnVideoStreamsCreated(VideoSendStream* send_stream,
@ -452,7 +452,7 @@ TEST_F(StatsEndToEndTest, MAYBE_ContentTypeSwitches) {
class StatsObserver : public test::BaseTest, class StatsObserver : public test::BaseTest,
public rtc::VideoSinkInterface<VideoFrame> { public rtc::VideoSinkInterface<VideoFrame> {
public: public:
StatsObserver() : BaseTest(kLongTimeoutMs), num_frames_received_(0) {} StatsObserver() : BaseTest(kLongTimeout), num_frames_received_(0) {}
bool ShouldCreateReceivers() const override { return true; } bool ShouldCreateReceivers() const override { return true; }
@ -583,7 +583,7 @@ TEST_F(StatsEndToEndTest, VerifyNackStats) {
class NackObserver : public test::EndToEndTest { class NackObserver : public test::EndToEndTest {
public: public:
explicit NackObserver(TaskQueueBase* task_queue) explicit NackObserver(TaskQueueBase* task_queue)
: EndToEndTest(kLongTimeoutMs), task_queue_(task_queue) {} : EndToEndTest(kLongTimeout), task_queue_(task_queue) {}
private: private:
Action OnSendRtp(const uint8_t* packet, size_t length) override { Action OnSendRtp(const uint8_t* packet, size_t length) override {
@ -731,7 +731,8 @@ TEST_F(StatsEndToEndTest, CallReportsRttForSender) {
Call::Stats stats; Call::Stats stats;
SendTask(task_queue(), SendTask(task_queue(),
[this, &stats]() { stats = sender_call_->GetStats(); }); [this, &stats]() { stats = sender_call_->GetStats(); });
ASSERT_GE(start_time_ms + kDefaultTimeoutMs, clock_->TimeInMilliseconds()) ASSERT_GE(start_time_ms + kDefaultTimeout.ms(),
clock_->TimeInMilliseconds())
<< "No RTT stats before timeout!"; << "No RTT stats before timeout!";
if (stats.rtt_ms != -1) { if (stats.rtt_ms != -1) {
// To avoid failures caused by rounding or minor ntp clock adjustments, // To avoid failures caused by rounding or minor ntp clock adjustments,

17
video/end_to_end_tests/transport_feedback_tests.cc
View File

@ -11,6 +11,7 @@
#include <memory> #include <memory>
#include "api/task_queue/task_queue_base.h" #include "api/task_queue/task_queue_base.h"
#include "api/units/time_delta.h"
#include "call/call.h" #include "call/call.h"
#include "call/fake_network_pipe.h" #include "call/fake_network_pipe.h"
#include "call/simulated_network.h" #include "call/simulated_network.h"
@ -246,8 +247,7 @@ class TransportFeedbackTester : public test::EndToEndTest {
TransportFeedbackTester(bool feedback_enabled, TransportFeedbackTester(bool feedback_enabled,
size_t num_video_streams, size_t num_video_streams,
size_t num_audio_streams) size_t num_audio_streams)
: EndToEndTest( : EndToEndTest(::webrtc::TransportFeedbackEndToEndTest::kDefaultTimeout),
::webrtc::TransportFeedbackEndToEndTest::kDefaultTimeoutMs),
feedback_enabled_(feedback_enabled), feedback_enabled_(feedback_enabled),
num_video_streams_(num_video_streams), num_video_streams_(num_video_streams),
num_audio_streams_(num_audio_streams), num_audio_streams_(num_audio_streams),
@ -276,11 +276,12 @@ class TransportFeedbackTester : public test::EndToEndTest {
} }
void PerformTest() override { void PerformTest() override {
const int64_t kDisabledFeedbackTimeoutMs = 5000; constexpr TimeDelta kDisabledFeedbackTimeout = TimeDelta::Seconds(5);
EXPECT_EQ(feedback_enabled_, EXPECT_EQ(feedback_enabled_,
observation_complete_.Wait(feedback_enabled_ observation_complete_.Wait((feedback_enabled_
? test::CallTest::kDefaultTimeoutMs ? test::CallTest::kDefaultTimeout
: kDisabledFeedbackTimeoutMs)); : kDisabledFeedbackTimeout)
.ms()));
} }
void OnCallsCreated(Call* sender_call, Call* receiver_call) override { void OnCallsCreated(Call* sender_call, Call* receiver_call) override {
@ -350,7 +351,7 @@ TEST_F(TransportFeedbackEndToEndTest,
public: public:
TransportFeedbackTester(size_t num_video_streams, size_t num_audio_streams) TransportFeedbackTester(size_t num_video_streams, size_t num_audio_streams)
: EndToEndTest( : EndToEndTest(
::webrtc::TransportFeedbackEndToEndTest::kDefaultTimeoutMs), ::webrtc::TransportFeedbackEndToEndTest::kDefaultTimeout),
num_video_streams_(num_video_streams), num_video_streams_(num_video_streams),
num_audio_streams_(num_audio_streams), num_audio_streams_(num_audio_streams),
media_sent_(0), media_sent_(0),
@ -438,7 +439,7 @@ TEST_F(TransportFeedbackEndToEndTest, TransportSeqNumOnAudioAndVideo) {
class TransportSequenceNumberTest : public test::EndToEndTest { class TransportSequenceNumberTest : public test::EndToEndTest {
public: public:
TransportSequenceNumberTest() TransportSequenceNumberTest()
: EndToEndTest(kDefaultTimeoutMs), : EndToEndTest(kDefaultTimeout),
video_observed_(false), video_observed_(false),
audio_observed_(false) { audio_observed_(false) {
extensions_.Register<TransportSequenceNumber>( extensions_.Register<TransportSequenceNumber>(

2
video/picture_id_tests.cc
View File

@ -43,7 +43,7 @@ const size_t kNumTemporalLayers[] = {1, 2, 3};
class PictureIdObserver : public test::RtpRtcpObserver { class PictureIdObserver : public test::RtpRtcpObserver {
public: public:
explicit PictureIdObserver(VideoCodecType codec_type) explicit PictureIdObserver(VideoCodecType codec_type)
: test::RtpRtcpObserver(test::CallTest::kDefaultTimeoutMs), : test::RtpRtcpObserver(test::CallTest::kDefaultTimeout),
depacketizer_(CreateVideoRtpDepacketizer(codec_type)), depacketizer_(CreateVideoRtpDepacketizer(codec_type)),
max_expected_picture_id_gap_(0), max_expected_picture_id_gap_(0),
max_expected_tl0_idx_gap_(0), max_expected_tl0_idx_gap_(0),

5
video/quality_scaling_tests.cc
View File

@ -27,7 +27,8 @@ constexpr int kInitialHeight = 720;
constexpr int kLowStartBps = 100000; constexpr int kLowStartBps = 100000;
constexpr int kHighStartBps = 1000000; constexpr int kHighStartBps = 1000000;
constexpr int kDefaultVgaMinStartBps = 500000; // From video_stream_encoder.cc constexpr int kDefaultVgaMinStartBps = 500000; // From video_stream_encoder.cc
constexpr int kTimeoutMs = 10000; // Some tests are expected to time out. constexpr TimeDelta kTimeout =
TimeDelta::Seconds(10); // Some tests are expected to time out.
void SetEncoderSpecific(VideoEncoderConfig* encoder_config, void SetEncoderSpecific(VideoEncoderConfig* encoder_config,
VideoCodecType type, VideoCodecType type,
@ -82,7 +83,7 @@ class ScalingObserver : public test::SendTest {
int start_bps, int start_bps,
bool automatic_resize, bool automatic_resize,
bool expect_scaling) bool expect_scaling)
: SendTest(expect_scaling ? kTimeoutMs * 4 : kTimeoutMs), : SendTest(expect_scaling ? kTimeout * 4 : kTimeout),
encoder_factory_( encoder_factory_(
[](const SdpVideoFormat& format) -> std::unique_ptr<VideoEncoder> { [](const SdpVideoFormat& format) -> std::unique_ptr<VideoEncoder> {
if (format.name == "VP8") if (format.name == "VP8")

92
video/video_send_stream_tests.cc
View File

@ -182,7 +182,7 @@ TEST_F(VideoSendStreamTest, SupportsCName) {
static std::string kCName = "PjQatC14dGfbVwGPUOA9IH7RlsFDbWl4AhXEiDsBizo="; static std::string kCName = "PjQatC14dGfbVwGPUOA9IH7RlsFDbWl4AhXEiDsBizo=";
class CNameObserver : public test::SendTest { class CNameObserver : public test::SendTest {
public: public:
CNameObserver() : SendTest(kDefaultTimeoutMs) {} CNameObserver() : SendTest(kDefaultTimeout) {}
private: private:
Action OnSendRtcp(const uint8_t* packet, size_t length) override { Action OnSendRtcp(const uint8_t* packet, size_t length) override {
@ -216,7 +216,7 @@ TEST_F(VideoSendStreamTest, SupportsCName) {
TEST_F(VideoSendStreamTest, SupportsAbsoluteSendTime) { TEST_F(VideoSendStreamTest, SupportsAbsoluteSendTime) {
class AbsoluteSendTimeObserver : public test::SendTest { class AbsoluteSendTimeObserver : public test::SendTest {
public: public:
AbsoluteSendTimeObserver() : SendTest(kDefaultTimeoutMs) { AbsoluteSendTimeObserver() : SendTest(kDefaultTimeout) {
extensions_.Register<AbsoluteSendTime>(kAbsSendTimeExtensionId); extensions_.Register<AbsoluteSendTime>(kAbsSendTimeExtensionId);
} }
@ -267,7 +267,7 @@ TEST_F(VideoSendStreamTest, SupportsTransmissionTimeOffset) {
class TransmissionTimeOffsetObserver : public test::SendTest { class TransmissionTimeOffsetObserver : public test::SendTest {
public: public:
TransmissionTimeOffsetObserver() TransmissionTimeOffsetObserver()
: SendTest(kDefaultTimeoutMs), encoder_factory_([]() { : SendTest(kDefaultTimeout), encoder_factory_([]() {
return std::make_unique<test::DelayedEncoder>( return std::make_unique<test::DelayedEncoder>(
Clock::GetRealTimeClock(), kEncodeDelayMs); Clock::GetRealTimeClock(), kEncodeDelayMs);
}) { }) {
@ -314,7 +314,7 @@ TEST_F(VideoSendStreamTest, SupportsTransportWideSequenceNumbers) {
class TransportWideSequenceNumberObserver : public test::SendTest { class TransportWideSequenceNumberObserver : public test::SendTest {
public: public:
TransportWideSequenceNumberObserver() TransportWideSequenceNumberObserver()
: SendTest(kDefaultTimeoutMs), encoder_factory_([]() { : SendTest(kDefaultTimeout), encoder_factory_([]() {
return std::make_unique<test::FakeEncoder>( return std::make_unique<test::FakeEncoder>(
Clock::GetRealTimeClock()); Clock::GetRealTimeClock());
}) { }) {
@ -356,7 +356,7 @@ TEST_F(VideoSendStreamTest, SupportsTransportWideSequenceNumbers) {
TEST_F(VideoSendStreamTest, SupportsVideoRotation) { TEST_F(VideoSendStreamTest, SupportsVideoRotation) {
class VideoRotationObserver : public test::SendTest { class VideoRotationObserver : public test::SendTest {
public: public:
VideoRotationObserver() : SendTest(kDefaultTimeoutMs) { VideoRotationObserver() : SendTest(kDefaultTimeout) {
extensions_.Register<VideoOrientation>(kVideoRotationExtensionId); extensions_.Register<VideoOrientation>(kVideoRotationExtensionId);
} }
@ -400,7 +400,7 @@ TEST_F(VideoSendStreamTest, SupportsVideoContentType) {
class VideoContentTypeObserver : public test::SendTest { class VideoContentTypeObserver : public test::SendTest {
public: public:
VideoContentTypeObserver() VideoContentTypeObserver()
: SendTest(kDefaultTimeoutMs), first_frame_sent_(false) { : SendTest(kDefaultTimeout), first_frame_sent_(false) {
extensions_.Register<VideoContentTypeExtension>( extensions_.Register<VideoContentTypeExtension>(
kVideoContentTypeExtensionId); kVideoContentTypeExtensionId);
} }
@ -446,7 +446,7 @@ TEST_F(VideoSendStreamTest, SupportsVideoTimingFrames) {
class VideoTimingObserver : public test::SendTest { class VideoTimingObserver : public test::SendTest {
public: public:
VideoTimingObserver() VideoTimingObserver()
: SendTest(kDefaultTimeoutMs), first_frame_sent_(false) { : SendTest(kDefaultTimeout), first_frame_sent_(false) {
extensions_.Register<VideoTimingExtension>(kVideoTimingExtensionId); extensions_.Register<VideoTimingExtension>(kVideoTimingExtensionId);
} }
@ -510,7 +510,7 @@ class UlpfecObserver : public test::EndToEndTest {
public: public:
// Some of the test cases are expected to time out. // Some of the test cases are expected to time out.
// Use a shorter timeout window than the default one for those. // Use a shorter timeout window than the default one for those.
static constexpr int kReducedTimeoutMs = 10000; static constexpr TimeDelta kReducedTimeout = TimeDelta::Seconds(10);
UlpfecObserver(bool header_extensions_enabled, UlpfecObserver(bool header_extensions_enabled,
bool use_nack, bool use_nack,
@ -518,8 +518,8 @@ class UlpfecObserver : public test::EndToEndTest {
bool expect_ulpfec, bool expect_ulpfec,
const std::string& codec, const std::string& codec,
VideoEncoderFactory* encoder_factory) VideoEncoderFactory* encoder_factory)
: EndToEndTest(expect_ulpfec ? VideoSendStreamTest::kDefaultTimeoutMs : EndToEndTest(expect_ulpfec ? VideoSendStreamTest::kDefaultTimeout
: kReducedTimeoutMs), : kReducedTimeout),
encoder_factory_(encoder_factory), encoder_factory_(encoder_factory),
payload_name_(codec), payload_name_(codec),
use_nack_(use_nack), use_nack_(use_nack),
@ -750,7 +750,7 @@ class FlexfecObserver : public test::EndToEndTest {
const std::string& codec, const std::string& codec,
VideoEncoderFactory* encoder_factory, VideoEncoderFactory* encoder_factory,
size_t num_video_streams) size_t num_video_streams)
: EndToEndTest(VideoSendStreamTest::kDefaultTimeoutMs), : EndToEndTest(VideoSendStreamTest::kDefaultTimeout),
encoder_factory_(encoder_factory), encoder_factory_(encoder_factory),
payload_name_(codec), payload_name_(codec),
use_nack_(use_nack), use_nack_(use_nack),
@ -946,7 +946,7 @@ void VideoSendStreamTest::TestNackRetransmission(
public: public:
explicit NackObserver(uint32_t retransmit_ssrc, explicit NackObserver(uint32_t retransmit_ssrc,
uint8_t retransmit_payload_type) uint8_t retransmit_payload_type)
: SendTest(kDefaultTimeoutMs), : SendTest(kDefaultTimeout),
send_count_(0), send_count_(0),
retransmit_count_(0), retransmit_count_(0),
retransmit_ssrc_(retransmit_ssrc), retransmit_ssrc_(retransmit_ssrc),
@ -1085,7 +1085,7 @@ void VideoSendStreamTest::TestPacketFragmentationSize(VideoFormat format,
size_t stop_size, size_t stop_size,
bool test_generic_packetization, bool test_generic_packetization,
bool use_fec) bool use_fec)
: SendTest(kLongTimeoutMs), : SendTest(kLongTimeout),
encoder_(stop), encoder_(stop),
encoder_factory_(&encoder_), encoder_factory_(&encoder_),
max_packet_size_(max_packet_size), max_packet_size_(max_packet_size),
@ -1319,7 +1319,7 @@ TEST_F(VideoSendStreamTest, NoPaddingWhenVideoIsMuted) {
class NoPaddingWhenVideoIsMuted : public test::SendTest { class NoPaddingWhenVideoIsMuted : public test::SendTest {
public: public:
NoPaddingWhenVideoIsMuted() NoPaddingWhenVideoIsMuted()
: SendTest(kDefaultTimeoutMs), : SendTest(kDefaultTimeout),
clock_(Clock::GetRealTimeClock()), clock_(Clock::GetRealTimeClock()),
capturer_(nullptr) {} capturer_(nullptr) {}
@ -1408,7 +1408,7 @@ TEST_F(VideoSendStreamTest, PaddingIsPrimarilyRetransmissions) {
class PaddingIsPrimarilyRetransmissions : public test::EndToEndTest { class PaddingIsPrimarilyRetransmissions : public test::EndToEndTest {
public: public:
PaddingIsPrimarilyRetransmissions() PaddingIsPrimarilyRetransmissions()
: EndToEndTest(kDefaultTimeoutMs), : EndToEndTest(kDefaultTimeout),
clock_(Clock::GetRealTimeClock()), clock_(Clock::GetRealTimeClock()),
padding_length_(0), padding_length_(0),
total_length_(0), total_length_(0),
@ -1491,7 +1491,7 @@ TEST_F(VideoSendStreamTest, MinTransmitBitrateRespectsRemb) {
class BitrateObserver : public test::SendTest { class BitrateObserver : public test::SendTest {
public: public:
explicit BitrateObserver(TaskQueueBase* task_queue) explicit BitrateObserver(TaskQueueBase* task_queue)
: SendTest(kDefaultTimeoutMs), : SendTest(kDefaultTimeout),
task_queue_(task_queue), task_queue_(task_queue),
retranmission_rate_limiter_(Clock::GetRealTimeClock(), 1000), retranmission_rate_limiter_(Clock::GetRealTimeClock(), 1000),
stream_(nullptr), stream_(nullptr),
@ -1582,7 +1582,7 @@ TEST_F(VideoSendStreamTest, ChangingNetworkRoute) {
class ChangingNetworkRouteTest : public test::EndToEndTest { class ChangingNetworkRouteTest : public test::EndToEndTest {
public: public:
explicit ChangingNetworkRouteTest(TaskQueueBase* task_queue) explicit ChangingNetworkRouteTest(TaskQueueBase* task_queue)
: EndToEndTest(test::CallTest::kDefaultTimeoutMs), : EndToEndTest(test::CallTest::kDefaultTimeout),
task_queue_(task_queue), task_queue_(task_queue),
call_(nullptr) { call_(nullptr) {
module_process_thread_.Detach(); module_process_thread_.Detach();
@ -1707,7 +1707,7 @@ TEST_F(VideoSendStreamTest, DISABLED_RelayToDirectRoute) {
class RelayToDirectRouteTest : public test::EndToEndTest { class RelayToDirectRouteTest : public test::EndToEndTest {
public: public:
explicit RelayToDirectRouteTest(TaskQueueBase* task_queue) explicit RelayToDirectRouteTest(TaskQueueBase* task_queue)
: EndToEndTest(test::CallTest::kDefaultTimeoutMs), : EndToEndTest(test::CallTest::kDefaultTimeout),
task_queue_(task_queue), task_queue_(task_queue),
call_(nullptr), call_(nullptr),
packets_sent_(0), packets_sent_(0),
@ -1802,7 +1802,7 @@ TEST_F(VideoSendStreamTest, ChangingTransportOverhead) {
class ChangingTransportOverheadTest : public test::EndToEndTest { class ChangingTransportOverheadTest : public test::EndToEndTest {
public: public:
explicit ChangingTransportOverheadTest(TaskQueueBase* task_queue) explicit ChangingTransportOverheadTest(TaskQueueBase* task_queue)
: EndToEndTest(test::CallTest::kDefaultTimeoutMs), : EndToEndTest(test::CallTest::kDefaultTimeout),
task_queue_(task_queue), task_queue_(task_queue),
call_(nullptr), call_(nullptr),
packets_sent_(0), packets_sent_(0),
@ -1878,7 +1878,7 @@ class MaxPaddingSetTest : public test::SendTest {
MaxPaddingSetTest(bool test_switch_content_type, MaxPaddingSetTest(bool test_switch_content_type,
T* stream_reset_fun, T* stream_reset_fun,
TaskQueueBase* task_queue) TaskQueueBase* task_queue)
: SendTest(test::CallTest::kDefaultTimeoutMs), : SendTest(test::CallTest::kDefaultTimeout),
running_without_padding_(test_switch_content_type), running_without_padding_(test_switch_content_type),
stream_resetter_(stream_reset_fun), stream_resetter_(stream_reset_fun),
task_queue_(task_queue) { task_queue_(task_queue) {
@ -2036,7 +2036,7 @@ TEST_F(VideoSendStreamTest,
} }
} }
EXPECT_TRUE( EXPECT_TRUE(
init_encode_called_.Wait(VideoSendStreamTest::kDefaultTimeoutMs)); init_encode_called_.Wait(VideoSendStreamTest::kDefaultTimeout.ms()));
{ {
MutexLock lock(&mutex_); MutexLock lock(&mutex_);
EXPECT_EQ(width, last_initialized_frame_width_); EXPECT_EQ(width, last_initialized_frame_width_);
@ -2123,7 +2123,7 @@ TEST_F(VideoSendStreamTest, CanReconfigureToUseStartBitrateAbovePreviousMax) {
bool WaitForStartBitrate() { bool WaitForStartBitrate() {
return start_bitrate_changed_.Wait( return start_bitrate_changed_.Wait(
VideoSendStreamTest::kDefaultTimeoutMs); VideoSendStreamTest::kDefaultTimeout.ms());
} }
private: private:
@ -2201,7 +2201,7 @@ class StartStopBitrateObserver : public test::FakeEncoder {
} }
bool WaitForEncoderInit() { bool WaitForEncoderInit() {
return encoder_init_.Wait(VideoSendStreamTest::kDefaultTimeoutMs); return encoder_init_.Wait(VideoSendStreamTest::kDefaultTimeout.ms());
} }
bool WaitBitrateChanged(WaitUntil until) { bool WaitBitrateChanged(WaitUntil until) {
@ -2218,7 +2218,7 @@ class StartStopBitrateObserver : public test::FakeEncoder {
(until == WaitUntil::kZero && *bitrate_kbps == 0)) { (until == WaitUntil::kZero && *bitrate_kbps == 0)) {
return true; return true;
} }
} while (bitrate_changed_.Wait(VideoSendStreamTest::kDefaultTimeoutMs)); } while (bitrate_changed_.Wait(VideoSendStreamTest::kDefaultTimeout.ms()));
return false; return false;
} }
@ -2233,7 +2233,7 @@ TEST_F(VideoSendStreamTest, EncoderIsProperlyInitializedAndDestroyed) {
class EncoderStateObserver : public test::SendTest, public VideoEncoder { class EncoderStateObserver : public test::SendTest, public VideoEncoder {
public: public:
explicit EncoderStateObserver(TaskQueueBase* task_queue) explicit EncoderStateObserver(TaskQueueBase* task_queue)
: SendTest(kDefaultTimeoutMs), : SendTest(kDefaultTimeout),
task_queue_(task_queue), task_queue_(task_queue),
stream_(nullptr), stream_(nullptr),
initialized_(false), initialized_(false),
@ -2364,7 +2364,7 @@ class VideoCodecConfigObserver : public test::SendTest,
public: public:
VideoCodecConfigObserver(VideoCodecType video_codec_type, VideoCodecConfigObserver(VideoCodecType video_codec_type,
TaskQueueBase* task_queue) TaskQueueBase* task_queue)
: SendTest(VideoSendStreamTest::kDefaultTimeoutMs), : SendTest(VideoSendStreamTest::kDefaultTimeout),
FakeEncoder(Clock::GetRealTimeClock()), FakeEncoder(Clock::GetRealTimeClock()),
video_codec_type_(video_codec_type), video_codec_type_(video_codec_type),
stream_(nullptr), stream_(nullptr),
@ -2411,7 +2411,7 @@ class VideoCodecConfigObserver : public test::SendTest,
void PerformTest() override { void PerformTest() override {
EXPECT_TRUE( EXPECT_TRUE(
init_encode_event_.Wait(VideoSendStreamTest::kDefaultTimeoutMs)); init_encode_event_.Wait(VideoSendStreamTest::kDefaultTimeout.ms()));
ASSERT_EQ(1, FakeEncoder::GetNumInitializations()) ASSERT_EQ(1, FakeEncoder::GetNumInitializations())
<< "VideoEncoder not initialized."; << "VideoEncoder not initialized.";
@ -2422,7 +2422,7 @@ class VideoCodecConfigObserver : public test::SendTest,
stream_->ReconfigureVideoEncoder(std::move(encoder_config_)); stream_->ReconfigureVideoEncoder(std::move(encoder_config_));
}); });
ASSERT_TRUE( ASSERT_TRUE(
init_encode_event_.Wait(VideoSendStreamTest::kDefaultTimeoutMs)); init_encode_event_.Wait(VideoSendStreamTest::kDefaultTimeout.ms()));
EXPECT_EQ(2, FakeEncoder::GetNumInitializations()) EXPECT_EQ(2, FakeEncoder::GetNumInitializations())
<< "ReconfigureVideoEncoder did not reinitialize the encoder with " << "ReconfigureVideoEncoder did not reinitialize the encoder with "
"new encoder settings."; "new encoder settings.";
@ -2567,7 +2567,7 @@ TEST_F(VideoSendStreamTest, RtcpSenderReportContainsMediaBytesSent) {
class RtcpSenderReportTest : public test::SendTest { class RtcpSenderReportTest : public test::SendTest {
public: public:
RtcpSenderReportTest() RtcpSenderReportTest()
: SendTest(kDefaultTimeoutMs), : SendTest(kDefaultTimeout),
rtp_packets_sent_(0), rtp_packets_sent_(0),
media_bytes_sent_(0) {} media_bytes_sent_(0) {}
@ -2642,7 +2642,7 @@ TEST_F(VideoSendStreamTest, TranslatesTwoLayerScreencastToTargetBitrate) {
public test::FakeEncoder { public test::FakeEncoder {
public: public:
ScreencastTargetBitrateTest() ScreencastTargetBitrateTest()
: SendTest(kDefaultTimeoutMs), : SendTest(kDefaultTimeout),
test::FakeEncoder(Clock::GetRealTimeClock()), test::FakeEncoder(Clock::GetRealTimeClock()),
encoder_factory_(this) {} encoder_factory_(this) {}
@ -2702,7 +2702,7 @@ TEST_F(VideoSendStreamTest, ReconfigureBitratesSetsEncoderBitratesCorrectly) {
public test::FakeEncoder { public test::FakeEncoder {
public: public:
explicit EncoderBitrateThresholdObserver(TaskQueueBase* task_queue) explicit EncoderBitrateThresholdObserver(TaskQueueBase* task_queue)
: SendTest(kDefaultTimeoutMs), : SendTest(kDefaultTimeout),
FakeEncoder(Clock::GetRealTimeClock()), FakeEncoder(Clock::GetRealTimeClock()),
task_queue_(task_queue), task_queue_(task_queue),
target_bitrate_(0), target_bitrate_(0),
@ -2785,7 +2785,7 @@ TEST_F(VideoSendStreamTest, ReconfigureBitratesSetsEncoderBitratesCorrectly) {
return; return;
} }
} while (bitrate_changed_event_.Wait( } while (bitrate_changed_event_.Wait(
std::max(int64_t{1}, VideoSendStreamTest::kDefaultTimeoutMs - std::max(int64_t{1}, VideoSendStreamTest::kDefaultTimeout.ms() -
(rtc::TimeMillis() - start_time)))); (rtc::TimeMillis() - start_time))));
MutexLock lock(&mutex_); MutexLock lock(&mutex_);
EXPECT_EQ(target_bitrate_, expected_bitrate) EXPECT_EQ(target_bitrate_, expected_bitrate)
@ -2826,10 +2826,10 @@ TEST_F(VideoSendStreamTest, ReconfigureBitratesSetsEncoderBitratesCorrectly) {
void PerformTest() override { void PerformTest() override {
ASSERT_TRUE(create_rate_allocator_event_.Wait( ASSERT_TRUE(create_rate_allocator_event_.Wait(
VideoSendStreamTest::kDefaultTimeoutMs)) VideoSendStreamTest::kDefaultTimeout.ms()))
<< "Timed out while waiting for rate allocator to be created."; << "Timed out while waiting for rate allocator to be created.";
ASSERT_TRUE( ASSERT_TRUE(
init_encode_event_.Wait(VideoSendStreamTest::kDefaultTimeoutMs)) init_encode_event_.Wait(VideoSendStreamTest::kDefaultTimeout.ms()))
<< "Timed out while waiting for encoder to be configured."; << "Timed out while waiting for encoder to be configured.";
WaitForSetRates(kStartBitrateKbps); WaitForSetRates(kStartBitrateKbps);
BitrateConstraints bitrate_config; BitrateConstraints bitrate_config;
@ -2846,7 +2846,7 @@ TEST_F(VideoSendStreamTest, ReconfigureBitratesSetsEncoderBitratesCorrectly) {
send_stream_->ReconfigureVideoEncoder(encoder_config_.Copy()); send_stream_->ReconfigureVideoEncoder(encoder_config_.Copy());
}); });
ASSERT_TRUE(create_rate_allocator_event_.Wait( ASSERT_TRUE(create_rate_allocator_event_.Wait(
VideoSendStreamTest::kDefaultTimeoutMs)); VideoSendStreamTest::kDefaultTimeout.ms()));
EXPECT_EQ(2, num_rate_allocator_creations_) EXPECT_EQ(2, num_rate_allocator_creations_)
<< "Rate allocator should have been recreated."; << "Rate allocator should have been recreated.";
@ -2858,7 +2858,7 @@ TEST_F(VideoSendStreamTest, ReconfigureBitratesSetsEncoderBitratesCorrectly) {
send_stream_->ReconfigureVideoEncoder(encoder_config_.Copy()); send_stream_->ReconfigureVideoEncoder(encoder_config_.Copy());
}); });
ASSERT_TRUE(create_rate_allocator_event_.Wait( ASSERT_TRUE(create_rate_allocator_event_.Wait(
VideoSendStreamTest::kDefaultTimeoutMs)); VideoSendStreamTest::kDefaultTimeout.ms()));
EXPECT_EQ(3, num_rate_allocator_creations_) EXPECT_EQ(3, num_rate_allocator_creations_)
<< "Rate allocator should have been recreated."; << "Rate allocator should have been recreated.";
@ -2898,7 +2898,7 @@ TEST_F(VideoSendStreamTest, ReportsSentResolution) {
public test::FakeEncoder { public test::FakeEncoder {
public: public:
explicit ScreencastTargetBitrateTest(TaskQueueBase* task_queue) explicit ScreencastTargetBitrateTest(TaskQueueBase* task_queue)
: SendTest(kDefaultTimeoutMs), : SendTest(kDefaultTimeout),
test::FakeEncoder(Clock::GetRealTimeClock()), test::FakeEncoder(Clock::GetRealTimeClock()),
send_stream_(nullptr), send_stream_(nullptr),
encoder_factory_(this), encoder_factory_(this),
@ -2983,7 +2983,7 @@ TEST_F(VideoSendStreamTest, ReportsSentResolution) {
class Vp9HeaderObserver : public test::SendTest { class Vp9HeaderObserver : public test::SendTest {
public: public:
explicit Vp9HeaderObserver(const Vp9TestParams& params) explicit Vp9HeaderObserver(const Vp9TestParams& params)
: SendTest(VideoSendStreamTest::kLongTimeoutMs), : SendTest(VideoSendStreamTest::kLongTimeout),
encoder_factory_([]() { return VP9Encoder::Create(); }), encoder_factory_([]() { return VP9Encoder::Create(); }),
params_(params), params_(params),
vp9_settings_(VideoEncoder::GetDefaultVp9Settings()) {} vp9_settings_(VideoEncoder::GetDefaultVp9Settings()) {}
@ -3643,7 +3643,7 @@ TEST_F(VideoSendStreamTest, EncoderConfigMaxFramerateReportedToSource) {
class FpsObserver : public test::SendTest, class FpsObserver : public test::SendTest,
public test::FrameGeneratorCapturer::SinkWantsObserver { public test::FrameGeneratorCapturer::SinkWantsObserver {
public: public:
FpsObserver() : SendTest(kDefaultTimeoutMs) {} FpsObserver() : SendTest(kDefaultTimeout) {}
void OnFrameGeneratorCapturerCreated( void OnFrameGeneratorCapturerCreated(
test::FrameGeneratorCapturer* frame_generator_capturer) override { test::FrameGeneratorCapturer* frame_generator_capturer) override {
@ -3681,7 +3681,7 @@ TEST_F(VideoSendStreamTest, RemoveOverheadFromBandwidth) {
public test::FakeEncoder { public test::FakeEncoder {
public: public:
explicit RemoveOverheadFromBandwidthTest(TaskQueueBase* task_queue) explicit RemoveOverheadFromBandwidthTest(TaskQueueBase* task_queue)
: EndToEndTest(test::CallTest::kDefaultTimeoutMs), : EndToEndTest(test::CallTest::kDefaultTimeout),
FakeEncoder(Clock::GetRealTimeClock()), FakeEncoder(Clock::GetRealTimeClock()),
task_queue_(task_queue), task_queue_(task_queue),
encoder_factory_(this), encoder_factory_(this),
@ -3736,8 +3736,8 @@ TEST_F(VideoSendStreamTest, RemoveOverheadFromBandwidth) {
// At a bitrate of 60kbps with a packet size of 1200B video and an // At a bitrate of 60kbps with a packet size of 1200B video and an
// overhead of 40B per packet video produces 2240bps overhead. // overhead of 40B per packet video produces 2240bps overhead.
// So the encoder BW should be set to 57760bps. // So the encoder BW should be set to 57760bps.
EXPECT_TRUE( EXPECT_TRUE(bitrate_changed_event_.Wait(
bitrate_changed_event_.Wait(VideoSendStreamTest::kDefaultTimeoutMs)); VideoSendStreamTest::kDefaultTimeout.ms()));
{ {
MutexLock lock(&mutex_); MutexLock lock(&mutex_);
EXPECT_LE(max_bitrate_bps_, 57760u); EXPECT_LE(max_bitrate_bps_, 57760u);
@ -3760,7 +3760,7 @@ class PacingFactorObserver : public test::SendTest {
public: public:
PacingFactorObserver(bool configure_send_side, PacingFactorObserver(bool configure_send_side,
absl::optional<float> expected_pacing_factor) absl::optional<float> expected_pacing_factor)
: test::SendTest(VideoSendStreamTest::kDefaultTimeoutMs), : test::SendTest(VideoSendStreamTest::kDefaultTimeout),
configure_send_side_(configure_send_side), configure_send_side_(configure_send_side),
expected_pacing_factor_(expected_pacing_factor) {} expected_pacing_factor_(expected_pacing_factor) {}
@ -3856,7 +3856,7 @@ class ContentSwitchTest : public test::SendTest {
static const uint32_t kMinPacketsToSend = 50; static const uint32_t kMinPacketsToSend = 50;
explicit ContentSwitchTest(T* stream_reset_fun, TaskQueueBase* task_queue) explicit ContentSwitchTest(T* stream_reset_fun, TaskQueueBase* task_queue)
: SendTest(test::CallTest::kDefaultTimeoutMs), : SendTest(test::CallTest::kDefaultTimeout),
call_(nullptr), call_(nullptr),
state_(StreamState::kBeforeSwitch), state_(StreamState::kBeforeSwitch),
send_stream_(nullptr), send_stream_(nullptr),
@ -3953,7 +3953,7 @@ class ContentSwitchTest : public test::SendTest {
void PerformTest() override { void PerformTest() override {
while (GetStreamState() != StreamState::kAfterSwitchBack) { while (GetStreamState() != StreamState::kAfterSwitchBack) {
ASSERT_TRUE( ASSERT_TRUE(
content_switch_event_.Wait(test::CallTest::kDefaultTimeoutMs)); content_switch_event_.Wait(test::CallTest::kDefaultTimeout.ms()));
(*stream_resetter_)(send_stream_config_, encoder_config_, this); (*stream_resetter_)(send_stream_config_, encoder_config_, this);
} }
@ -4017,7 +4017,7 @@ void VideoSendStreamTest::TestTemporalLayers(
const std::string& payload_name, const std::string& payload_name,
const std::vector<int>& num_temporal_layers, const std::vector<int>& num_temporal_layers,
const std::vector<ScalabilityMode>& scalability_mode) const std::vector<ScalabilityMode>& scalability_mode)
: EndToEndTest(kDefaultTimeoutMs), : EndToEndTest(kDefaultTimeout),
encoder_factory_(encoder_factory), encoder_factory_(encoder_factory),
payload_name_(payload_name), payload_name_(payload_name),
num_temporal_layers_(num_temporal_layers), num_temporal_layers_(num_temporal_layers),