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 {
public:
AudioSendTest() : SendTest(CallTest::kDefaultTimeoutMs) {}
AudioSendTest() : SendTest(CallTest::kDefaultTimeout) {}
size_t GetNumVideoStreams() const override { return 0; }
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;
} // namespace
AudioBweTest::AudioBweTest() : EndToEndTest(CallTest::kDefaultTimeoutMs) {}
AudioBweTest::AudioBweTest() : EndToEndTest(CallTest::kDefaultTimeout) {}
size_t AudioBweTest::GetNumVideoStreams() const {
return 0;

2
audio/test/audio_end_to_end_test.cc
View File

@ -29,7 +29,7 @@ constexpr int kSampleRate = 48000;
} // namespace
AudioEndToEndTest::AudioEndToEndTest()
: EndToEndTest(CallTest::kDefaultTimeoutMs) {}
: EndToEndTest(CallTest::kDefaultTimeout) {}
BuiltInNetworkBehaviorConfig AudioEndToEndTest::GetNetworkPipeConfig() const {
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) {
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,
Clock* clock,
absl::string_view test_label)
: test::RtpRtcpObserver(CallPerfTest::kLongTimeoutMs),
: test::RtpRtcpObserver(CallPerfTest::kLongTimeout),
clock_(clock),
test_label_(test_label),
creation_time_ms_(clock_->TimeInMilliseconds()),
@ -387,7 +387,7 @@ void CallPerfTest::TestCaptureNtpTime(
int threshold_ms,
int start_time_ms,
int run_time_ms)
: EndToEndTest(kLongTimeoutMs),
: EndToEndTest(kLongTimeout),
net_config_(net_config),
clock_(Clock::GetRealTimeClock()),
threshold_ms_(threshold_ms),
@ -552,7 +552,7 @@ TEST_F(CallPerfTest, ReceivesCpuOveruseAndUnderuse) {
class LoadObserver : public test::SendTest,
public test::FrameGeneratorCapturer::SinkWantsObserver {
public:
LoadObserver() : SendTest(kLongTimeoutMs), test_phase_(TestPhase::kInit) {}
LoadObserver() : SendTest(kLongTimeout), test_phase_(TestPhase::kInit) {}
void OnFrameGeneratorCapturerCreated(
test::FrameGeneratorCapturer* frame_generator_capturer) override {
@ -661,7 +661,7 @@ void CallPerfTest::TestMinTransmitBitrate(bool pad_to_min_bitrate) {
public:
explicit BitrateObserver(bool using_min_transmit_bitrate,
TaskQueueBase* task_queue)
: EndToEndTest(kLongTimeoutMs),
: EndToEndTest(kLongTimeout),
send_stream_(nullptr),
converged_(false),
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 {
public:
explicit BitrateObserver(TaskQueueBase* task_queue)
: EndToEndTest(kDefaultTimeoutMs),
: EndToEndTest(kDefaultTimeout),
FakeEncoder(Clock::GetRealTimeClock()),
encoder_inits_(0),
last_set_bitrate_kbps_(0),
@ -867,7 +867,7 @@ TEST_F(CallPerfTest, MAYBE_KeepsHighBitrateWhenReconfiguringSender) {
}
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.";
frame_generator_->ChangeResolution(kDefaultWidth * 2, kDefaultHeight * 2);
SendTask(task_queue_, [&]() {
@ -1071,7 +1071,7 @@ void CallPerfTest::TestEncodeFramerate(VideoEncoderFactory* encoder_factory,
absl::string_view payload_name,
const std::vector<int>& max_framerates,
TaskQueueBase* task_queue)
: EndToEndTest(kDefaultTimeoutMs),
: EndToEndTest(kDefaultTimeout),
clock_(Clock::GetRealTimeClock()),
encoder_factory_(encoder_factory),
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 report_perf_stats,
TaskQueueBase* task_queue)
: EndToEndTest(test::CallTest::kLongTimeoutMs),
: EndToEndTest(test::CallTest::kLongTimeout),
clock_(Clock::GetRealTimeClock()),
num_video_streams_(num_video_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/test/video:function_video_factory",
"../api/transport:field_trial_based_config",
"../api/units:time_delta",
"../api/video:builtin_video_bitrate_allocator_factory",
"../api/video:video_bitrate_allocator_factory",
"../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::kDefaultHeight;
const int CallTest::kDefaultFramerate;
const int CallTest::kDefaultTimeoutMs = 30 * 1000;
const int CallTest::kLongTimeoutMs = 120 * 1000;
const uint32_t CallTest::kSendRtxSsrcs[kNumSsrcs] = {
0xBADCAFD, 0xBADCAFE, 0xBADCAFF, 0xBADCB00, 0xBADCB01, 0xBADCB02};
const uint32_t CallTest::kVideoSendSsrcs[kNumSsrcs] = {
@ -724,7 +722,7 @@ const std::map<uint8_t, MediaType> CallTest::payload_type_map_ = {
BaseTest::BaseTest() {}
BaseTest::BaseTest(int timeout_ms) : RtpRtcpObserver(timeout_ms) {}
BaseTest::BaseTest(TimeDelta timeout) : RtpRtcpObserver(timeout) {}
BaseTest::~BaseTest() {}
@ -815,7 +813,7 @@ void BaseTest::OnFrameGeneratorCapturerCreated(
void BaseTest::OnStreamsStopped() {}
SendTest::SendTest(int timeout_ms) : BaseTest(timeout_ms) {}
SendTest::SendTest(TimeDelta timeout) : BaseTest(timeout) {}
bool SendTest::ShouldCreateReceivers() const {
return false;
@ -823,7 +821,7 @@ bool SendTest::ShouldCreateReceivers() const {
EndToEndTest::EndToEndTest() {}
EndToEndTest::EndToEndTest(int timeout_ms) : BaseTest(timeout_ms) {}
EndToEndTest::EndToEndTest(TimeDelta timeout) : BaseTest(timeout) {}
bool EndToEndTest::ShouldCreateReceivers() const {
return true;

11
test/call_test.h
View File

@ -21,6 +21,7 @@
#include "api/task_queue/task_queue_factory.h"
#include "api/test/video/function_video_decoder_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 "call/call.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 kDefaultHeight = 180;
static const int kDefaultFramerate = 30;
static const int kDefaultTimeoutMs;
static const int kLongTimeoutMs;
static constexpr TimeDelta kDefaultTimeout = TimeDelta::Seconds(30);
static constexpr TimeDelta kLongTimeout = TimeDelta::Seconds(120);
enum classPayloadTypes : uint8_t {
kSendRtxPayloadType = 98,
kRtxRedPayloadType = 99,
@ -246,7 +247,7 @@ class CallTest : public ::testing::Test, public RtpPacketSinkInterface {
class BaseTest : public RtpRtcpObserver {
public:
BaseTest();
explicit BaseTest(int timeout_ms);
explicit BaseTest(TimeDelta timeout);
virtual ~BaseTest();
virtual void PerformTest() = 0;
@ -307,7 +308,7 @@ class BaseTest : public RtpRtcpObserver {
class SendTest : public BaseTest {
public:
explicit SendTest(int timeout_ms);
explicit SendTest(TimeDelta timeout);
bool ShouldCreateReceivers() const override;
};
@ -315,7 +316,7 @@ class SendTest : public BaseTest {
class EndToEndTest : public BaseTest {
public:
EndToEndTest();
explicit EndToEndTest(int timeout_ms);
explicit EndToEndTest(TimeDelta timeout);
bool ShouldCreateReceivers() const override;
};

6
test/rtp_rtcp_observer.h
View File

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

2
video/cpu_scaling_tests.cc
View File

@ -55,7 +55,7 @@ void CpuOveruseTest::RunTestAndCheckForAdaptation(
public:
OveruseObserver(const DegradationPreference& degradation_preference,
bool expect_adaptation)
: SendTest(expect_adaptation ? kLongTimeoutMs : kDefaultTimeoutMs),
: SendTest(expect_adaptation ? kLongTimeout : kDefaultTimeout),
degradation_preference_(degradation_preference),
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) {
class RembObserver : public test::EndToEndTest {
public:
RembObserver() : EndToEndTest(kDefaultTimeoutMs) {}
RembObserver() : EndToEndTest(kDefaultTimeout) {}
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
@ -85,7 +85,7 @@ TEST_F(BandwidthEndToEndTest, ReceiveStreamSendsRemb) {
class BandwidthStatsTest : public test::EndToEndTest {
public:
BandwidthStatsTest(bool send_side_bwe, TaskQueueBase* task_queue)
: EndToEndTest(test::CallTest::kDefaultTimeoutMs),
: EndToEndTest(test::CallTest::kDefaultTimeout),
sender_call_(nullptr),
receiver_call_(nullptr),
has_seen_pacer_delay_(false),
@ -194,7 +194,7 @@ TEST_F(BandwidthEndToEndTest, RembWithSendSideBwe) {
class BweObserver : public test::EndToEndTest {
public:
explicit BweObserver(TaskQueueBase* task_queue)
: EndToEndTest(kDefaultTimeoutMs),
: EndToEndTest(kDefaultTimeout),
sender_call_(nullptr),
clock_(Clock::GetRealTimeClock()),
sender_ssrc_(0),
@ -320,7 +320,7 @@ TEST_F(BandwidthEndToEndTest, ReportsSetEncoderRates) {
public test::FakeEncoder {
public:
explicit EncoderRateStatsTest(TaskQueueBase* task_queue)
: EndToEndTest(kDefaultTimeoutMs),
: EndToEndTest(kDefaultTimeout),
FakeEncoder(Clock::GetRealTimeClock()),
task_queue_(task_queue),
send_stream_(nullptr),
@ -368,7 +368,7 @@ TEST_F(BandwidthEndToEndTest, ReportsSetEncoderRates) {
}
void WaitForEncoderTargetBitrateMatchStats() {
for (int i = 0; i < kDefaultTimeoutMs; ++i) {
for (int i = 0; i < kDefaultTimeout.ms(); ++i) {
VideoSendStream::Stats stats = send_stream_->GetStats();
{
MutexLock lock(&mutex_);
@ -384,7 +384,7 @@ TEST_F(BandwidthEndToEndTest, ReportsSetEncoderRates) {
}
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) {
return;
}

4
video/end_to_end_tests/call_operation_tests.cc
View File

@ -88,7 +88,7 @@ TEST_F(CallOperationEndToEndTest, RendersSingleDelayedFrame) {
event_.Set();
}
bool Wait() { return event_.Wait(kDefaultTimeoutMs); }
bool Wait() { return event_.Wait(kDefaultTimeout.ms()); }
rtc::Event event_;
} renderer;
@ -159,7 +159,7 @@ TEST_F(CallOperationEndToEndTest, TransmitsFirstFrame) {
public:
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_;
} 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,
VideoEncoderFactory* encoder_factory,
VideoDecoderFactory* decoder_factory)
: EndToEndTest(4 * CodecEndToEndTest::kDefaultTimeoutMs),
: EndToEndTest(4 * CodecEndToEndTest::kDefaultTimeout),
// TODO(hta): This timeout (120 seconds) is excessive.
// https://bugs.webrtc.org/6830
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 enable_zero_target_bitrate,
VideoEncoderConfig::ContentType content_type)
: EndToEndTest(test::CallTest::kDefaultTimeoutMs),
: EndToEndTest(test::CallTest::kDefaultTimeout),
enable_rrtr_(enable_rrtr),
expect_target_bitrate_(expect_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:
UlpfecRenderObserver()
: EndToEndTest(kDefaultTimeoutMs),
: EndToEndTest(kDefaultTimeout),
encoder_factory_([]() { return VP8Encoder::Create(); }),
random_(0xcafef00d1),
num_packets_sent_(0) {}
@ -159,7 +159,7 @@ class FlexfecRenderObserver : public test::EndToEndTest,
static constexpr uint32_t kFlexfecLocalSsrc = 456;
explicit FlexfecRenderObserver(bool enable_nack, bool expect_flexfec_rtcp)
: test::EndToEndTest(test::CallTest::kDefaultTimeoutMs),
: test::EndToEndTest(test::CallTest::kDefaultTimeout),
enable_nack_(enable_nack),
expect_flexfec_rtcp_(expect_flexfec_rtcp),
received_flexfec_rtcp_(false),
@ -352,7 +352,7 @@ TEST_F(FecEndToEndTest, ReceivedUlpfecPacketsNotNacked) {
class UlpfecNackObserver : public test::EndToEndTest {
public:
UlpfecNackObserver()
: EndToEndTest(kDefaultTimeoutMs),
: EndToEndTest(kDefaultTimeout),
state_(kFirstPacket),
ulpfec_sequence_number_(0),
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:
DecryptedFrameObserver()
: EndToEndTest(test::CallTest::kDefaultTimeoutMs),
: EndToEndTest(test::CallTest::kDefaultTimeout),
encoder_factory_([] { return VP8Encoder::Create(); }) {}
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:
FrameObserver(bool use_rtx, bool use_fec, bool screenshare)
: EndToEndTest(kLongTimeoutMs),
: EndToEndTest(kLongTimeout),
use_rtx_(use_rtx),
use_fec_(use_fec),
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,
public rtc::VideoSinkInterface<VideoFrame> {
public:
FrameObserver() : test::RtpRtcpObserver(test::CallTest::kDefaultTimeoutMs) {}
FrameObserver() : test::RtpRtcpObserver(test::CallTest::kDefaultTimeout) {}
void Reset(uint8_t expected_payload_type) {
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 {
public:
explicit NetworkStateTest(TaskQueueBase* task_queue)
: EndToEndTest(kDefaultTimeoutMs),
: EndToEndTest(kDefaultTimeout),
FakeEncoder(Clock::GetRealTimeClock()),
e2e_test_task_queue_(task_queue),
task_queue_(CreateDefaultTaskQueueFactory()->CreateTaskQueue(
@ -235,7 +235,7 @@ TEST_F(NetworkStateEndToEndTest, RespectsNetworkState) {
}
void PerformTest() override {
EXPECT_TRUE(encoded_frames_.Wait(kDefaultTimeoutMs))
EXPECT_TRUE(encoded_frames_.Wait(kDefaultTimeout.ms()))
<< "No frames received by the encoder.";
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,
const std::vector<TestConfig>& configs,
const std::vector<Expectation>& expectations)
: EndToEndTest(test::CallTest::kDefaultTimeoutMs),
: EndToEndTest(test::CallTest::kDefaultTimeout),
FakeEncoder(Clock::GetRealTimeClock()),
encoder_factory_(this),
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 {
public:
NackObserver()
: EndToEndTest(kLongTimeoutMs),
: EndToEndTest(kLongTimeout),
sent_rtp_packets_(0),
packets_left_to_drop_(0),
nacks_left_(kNumberOfNacksToObserve) {}
@ -133,7 +133,7 @@ TEST_F(RetransmissionEndToEndTest, ReceivesNackAndRetransmitsAudio) {
class NackObserver : public test::EndToEndTest {
public:
NackObserver()
: EndToEndTest(kLongTimeoutMs),
: EndToEndTest(kLongTimeout),
local_ssrc_(0),
remote_ssrc_(0),
receive_transport_(nullptr) {}
@ -282,7 +282,7 @@ void RetransmissionEndToEndTest::ReceivesPliAndRecovers(int rtp_history_ms) {
public rtc::VideoSinkInterface<VideoFrame> {
public:
explicit PliObserver(int rtp_history_ms)
: EndToEndTest(kLongTimeoutMs),
: EndToEndTest(kLongTimeout),
rtp_history_ms_(rtp_history_ms),
nack_enabled_(rtp_history_ms > 0),
highest_dropped_timestamp_(0),
@ -372,7 +372,7 @@ void RetransmissionEndToEndTest::DecodesRetransmittedFrame(bool enable_rtx,
public rtc::VideoSinkInterface<VideoFrame> {
public:
RetransmissionObserver(bool enable_rtx, bool enable_red)
: EndToEndTest(kDefaultTimeoutMs),
: EndToEndTest(kDefaultTimeout),
payload_type_(GetPayloadType(false, enable_red)),
retransmission_ssrc_(enable_rtx ? kSendRtxSsrcs[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 {
public:
explicit RtcpModeObserver(RtcpMode rtcp_mode)
: EndToEndTest(kDefaultTimeoutMs),
: EndToEndTest(kDefaultTimeout),
rtcp_mode_(rtcp_mode),
sent_rtp_(0),
sent_rtcp_(0) {}
@ -167,7 +167,7 @@ void RtpRtcpEndToEndTest::TestRtpStatePreservation(
class RtpSequenceObserver : public test::RtpRtcpObserver {
public:
explicit RtpSequenceObserver(bool use_rtx)
: test::RtpRtcpObserver(kDefaultTimeoutMs),
: test::RtpRtcpObserver(kDefaultTimeout),
ssrcs_to_observe_(kNumSimulcastStreams) {
for (size_t i = 0; i < kNumSimulcastStreams; ++i) {
ssrc_is_rtx_[kVideoSendSsrcs[i]] = false;
@ -187,7 +187,7 @@ void RtpRtcpEndToEndTest::TestRtpStatePreservation(
uint32_t timestamp,
bool only_padding)
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);
if (timestamp_it == last_observed_timestamp_.end()) {
EXPECT_FALSE(only_padding);
@ -409,7 +409,7 @@ TEST_F(RtpRtcpEndToEndTest, DISABLED_TestFlexfecRtpStatePreservation) {
class RtpSequenceObserver : public test::RtpRtcpObserver {
public:
RtpSequenceObserver()
: test::RtpRtcpObserver(kDefaultTimeoutMs),
: test::RtpRtcpObserver(kDefaultTimeout),
num_flexfec_packets_sent_(0) {}
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) {
class SyncRtcpObserver : public test::EndToEndTest {
public:
SyncRtcpObserver() : EndToEndTest(kDefaultTimeoutMs) {}
SyncRtcpObserver() : EndToEndTest(kDefaultTimeout) {}
Action OnReceiveRtcp(const uint8_t* packet, size_t length) override {
test::RtcpPacketParser parser;
@ -55,7 +55,7 @@ TEST_F(SsrcEndToEndTest, UnknownRtpPacketGivesUnknownSsrcReturnCode) {
explicit PacketInputObserver(PacketReceiver* receiver)
: receiver_(receiver) {}
bool Wait() { return delivered_packet_.Wait(kDefaultTimeoutMs); }
bool Wait() { return delivered_packet_.Wait(kDefaultTimeout.ms()); }
private:
DeliveryStatus DeliverPacket(MediaType media_type,
@ -134,7 +134,7 @@ void SsrcEndToEndTest::TestSendsSetSsrcs(size_t num_ssrcs,
size_t num_ssrcs,
bool send_single_ssrc_first,
TaskQueueBase* task_queue)
: EndToEndTest(kDefaultTimeoutMs),
: EndToEndTest(kDefaultTimeout),
num_ssrcs_(num_ssrcs),
send_single_ssrc_first_(send_single_ssrc_first),
ssrcs_to_observe_(num_ssrcs),
@ -244,7 +244,7 @@ TEST_F(SsrcEndToEndTest, DISABLED_RedundantPayloadsTransmittedOnAllSsrcs) {
class ObserveRedundantPayloads : public test::EndToEndTest {
public:
ObserveRedundantPayloads()
: EndToEndTest(kDefaultTimeoutMs),
: EndToEndTest(kDefaultTimeout),
ssrcs_to_observe_(kNumSimulcastStreams) {
for (size_t i = 0; i < kNumSimulcastStreams; ++i) {
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 {
public:
StatsObserver()
: EndToEndTest(kLongTimeoutMs), encoder_factory_([]() {
: EndToEndTest(kLongTimeout), encoder_factory_([]() {
return std::make_unique<test::DelayedEncoder>(
Clock::GetRealTimeClock(), 10);
}) {}
@ -292,7 +292,7 @@ TEST_F(StatsEndToEndTest, GetStats) {
void PerformTest() override {
Clock* clock = Clock::GetRealTimeClock();
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 send_ok = false;
@ -347,7 +347,7 @@ TEST_F(StatsEndToEndTest, TimingFramesAreReported) {
class StatsObserver : public test::EndToEndTest {
public:
StatsObserver() : EndToEndTest(kLongTimeoutMs) {}
StatsObserver() : EndToEndTest(kLongTimeout) {}
private:
void ModifyVideoConfigs(
@ -400,7 +400,7 @@ TEST_F(StatsEndToEndTest, TestReceivedRtpPacketStats) {
class ReceivedRtpStatsObserver : public test::EndToEndTest {
public:
explicit ReceivedRtpStatsObserver(TaskQueueBase* task_queue)
: EndToEndTest(kDefaultTimeoutMs), task_queue_(task_queue) {}
: EndToEndTest(kDefaultTimeout), task_queue_(task_queue) {}
private:
void OnVideoStreamsCreated(VideoSendStream* send_stream,
@ -452,7 +452,7 @@ TEST_F(StatsEndToEndTest, MAYBE_ContentTypeSwitches) {
class StatsObserver : public test::BaseTest,
public rtc::VideoSinkInterface<VideoFrame> {
public:
StatsObserver() : BaseTest(kLongTimeoutMs), num_frames_received_(0) {}
StatsObserver() : BaseTest(kLongTimeout), num_frames_received_(0) {}
bool ShouldCreateReceivers() const override { return true; }
@ -583,7 +583,7 @@ TEST_F(StatsEndToEndTest, VerifyNackStats) {
class NackObserver : public test::EndToEndTest {
public:
explicit NackObserver(TaskQueueBase* task_queue)
: EndToEndTest(kLongTimeoutMs), task_queue_(task_queue) {}
: EndToEndTest(kLongTimeout), task_queue_(task_queue) {}
private:
Action OnSendRtp(const uint8_t* packet, size_t length) override {
@ -731,7 +731,8 @@ TEST_F(StatsEndToEndTest, CallReportsRttForSender) {
Call::Stats stats;
SendTask(task_queue(),
[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!";
if (stats.rtt_ms != -1) {
// 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 "api/task_queue/task_queue_base.h"
#include "api/units/time_delta.h"
#include "call/call.h"
#include "call/fake_network_pipe.h"
#include "call/simulated_network.h"
@ -246,8 +247,7 @@ class TransportFeedbackTester : public test::EndToEndTest {
TransportFeedbackTester(bool feedback_enabled,
size_t num_video_streams,
size_t num_audio_streams)
: EndToEndTest(
::webrtc::TransportFeedbackEndToEndTest::kDefaultTimeoutMs),
: EndToEndTest(::webrtc::TransportFeedbackEndToEndTest::kDefaultTimeout),
feedback_enabled_(feedback_enabled),
num_video_streams_(num_video_streams),
num_audio_streams_(num_audio_streams),
@ -276,11 +276,12 @@ class TransportFeedbackTester : public test::EndToEndTest {
}
void PerformTest() override {
const int64_t kDisabledFeedbackTimeoutMs = 5000;
constexpr TimeDelta kDisabledFeedbackTimeout = TimeDelta::Seconds(5);
EXPECT_EQ(feedback_enabled_,
observation_complete_.Wait(feedback_enabled_
? test::CallTest::kDefaultTimeoutMs
: kDisabledFeedbackTimeoutMs));
observation_complete_.Wait((feedback_enabled_
? test::CallTest::kDefaultTimeout
: kDisabledFeedbackTimeout)
.ms()));
}
void OnCallsCreated(Call* sender_call, Call* receiver_call) override {
@ -350,7 +351,7 @@ TEST_F(TransportFeedbackEndToEndTest,
public:
TransportFeedbackTester(size_t num_video_streams, size_t num_audio_streams)
: EndToEndTest(
::webrtc::TransportFeedbackEndToEndTest::kDefaultTimeoutMs),
::webrtc::TransportFeedbackEndToEndTest::kDefaultTimeout),
num_video_streams_(num_video_streams),
num_audio_streams_(num_audio_streams),
media_sent_(0),
@ -438,7 +439,7 @@ TEST_F(TransportFeedbackEndToEndTest, TransportSeqNumOnAudioAndVideo) {
class TransportSequenceNumberTest : public test::EndToEndTest {
public:
TransportSequenceNumberTest()
: EndToEndTest(kDefaultTimeoutMs),
: EndToEndTest(kDefaultTimeout),
video_observed_(false),
audio_observed_(false) {
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 {
public:
explicit PictureIdObserver(VideoCodecType codec_type)
: test::RtpRtcpObserver(test::CallTest::kDefaultTimeoutMs),
: test::RtpRtcpObserver(test::CallTest::kDefaultTimeout),
depacketizer_(CreateVideoRtpDepacketizer(codec_type)),
max_expected_picture_id_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 kHighStartBps = 1000000;
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,
VideoCodecType type,
@ -82,7 +83,7 @@ class ScalingObserver : public test::SendTest {
int start_bps,
bool automatic_resize,
bool expect_scaling)
: SendTest(expect_scaling ? kTimeoutMs * 4 : kTimeoutMs),
: SendTest(expect_scaling ? kTimeout * 4 : kTimeout),
encoder_factory_(
[](const SdpVideoFormat& format) -> std::unique_ptr<VideoEncoder> {
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=";
class CNameObserver : public test::SendTest {
public:
CNameObserver() : SendTest(kDefaultTimeoutMs) {}
CNameObserver() : SendTest(kDefaultTimeout) {}
private:
Action OnSendRtcp(const uint8_t* packet, size_t length) override {
@ -216,7 +216,7 @@ TEST_F(VideoSendStreamTest, SupportsCName) {
TEST_F(VideoSendStreamTest, SupportsAbsoluteSendTime) {
class AbsoluteSendTimeObserver : public test::SendTest {
public:
AbsoluteSendTimeObserver() : SendTest(kDefaultTimeoutMs) {
AbsoluteSendTimeObserver() : SendTest(kDefaultTimeout) {
extensions_.Register<AbsoluteSendTime>(kAbsSendTimeExtensionId);
}
@ -267,7 +267,7 @@ TEST_F(VideoSendStreamTest, SupportsTransmissionTimeOffset) {
class TransmissionTimeOffsetObserver : public test::SendTest {
public:
TransmissionTimeOffsetObserver()
: SendTest(kDefaultTimeoutMs), encoder_factory_([]() {
: SendTest(kDefaultTimeout), encoder_factory_([]() {
return std::make_unique<test::DelayedEncoder>(
Clock::GetRealTimeClock(), kEncodeDelayMs);
}) {
@ -314,7 +314,7 @@ TEST_F(VideoSendStreamTest, SupportsTransportWideSequenceNumbers) {
class TransportWideSequenceNumberObserver : public test::SendTest {
public:
TransportWideSequenceNumberObserver()
: SendTest(kDefaultTimeoutMs), encoder_factory_([]() {
: SendTest(kDefaultTimeout), encoder_factory_([]() {
return std::make_unique<test::FakeEncoder>(
Clock::GetRealTimeClock());
}) {
@ -356,7 +356,7 @@ TEST_F(VideoSendStreamTest, SupportsTransportWideSequenceNumbers) {
TEST_F(VideoSendStreamTest, SupportsVideoRotation) {
class VideoRotationObserver : public test::SendTest {
public:
VideoRotationObserver() : SendTest(kDefaultTimeoutMs) {
VideoRotationObserver() : SendTest(kDefaultTimeout) {
extensions_.Register<VideoOrientation>(kVideoRotationExtensionId);
}
@ -400,7 +400,7 @@ TEST_F(VideoSendStreamTest, SupportsVideoContentType) {
class VideoContentTypeObserver : public test::SendTest {
public:
VideoContentTypeObserver()
: SendTest(kDefaultTimeoutMs), first_frame_sent_(false) {
: SendTest(kDefaultTimeout), first_frame_sent_(false) {
extensions_.Register<VideoContentTypeExtension>(
kVideoContentTypeExtensionId);
}
@ -446,7 +446,7 @@ TEST_F(VideoSendStreamTest, SupportsVideoTimingFrames) {
class VideoTimingObserver : public test::SendTest {
public:
VideoTimingObserver()
: SendTest(kDefaultTimeoutMs), first_frame_sent_(false) {
: SendTest(kDefaultTimeout), first_frame_sent_(false) {
extensions_.Register<VideoTimingExtension>(kVideoTimingExtensionId);
}
@ -510,7 +510,7 @@ class UlpfecObserver : public test::EndToEndTest {
public:
// Some of the test cases are expected to time out.
// 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,
bool use_nack,
@ -518,8 +518,8 @@ class UlpfecObserver : public test::EndToEndTest {
bool expect_ulpfec,
const std::string& codec,
VideoEncoderFactory* encoder_factory)
: EndToEndTest(expect_ulpfec ? VideoSendStreamTest::kDefaultTimeoutMs
: kReducedTimeoutMs),
: EndToEndTest(expect_ulpfec ? VideoSendStreamTest::kDefaultTimeout
: kReducedTimeout),
encoder_factory_(encoder_factory),
payload_name_(codec),
use_nack_(use_nack),
@ -750,7 +750,7 @@ class FlexfecObserver : public test::EndToEndTest {
const std::string& codec,
VideoEncoderFactory* encoder_factory,
size_t num_video_streams)
: EndToEndTest(VideoSendStreamTest::kDefaultTimeoutMs),
: EndToEndTest(VideoSendStreamTest::kDefaultTimeout),
encoder_factory_(encoder_factory),
payload_name_(codec),
use_nack_(use_nack),
@ -946,7 +946,7 @@ void VideoSendStreamTest::TestNackRetransmission(
public:
explicit NackObserver(uint32_t retransmit_ssrc,
uint8_t retransmit_payload_type)
: SendTest(kDefaultTimeoutMs),
: SendTest(kDefaultTimeout),
send_count_(0),
retransmit_count_(0),
retransmit_ssrc_(retransmit_ssrc),
@ -1085,7 +1085,7 @@ void VideoSendStreamTest::TestPacketFragmentationSize(VideoFormat format,
size_t stop_size,
bool test_generic_packetization,
bool use_fec)
: SendTest(kLongTimeoutMs),
: SendTest(kLongTimeout),
encoder_(stop),
encoder_factory_(&encoder_),
max_packet_size_(max_packet_size),
@ -1319,7 +1319,7 @@ TEST_F(VideoSendStreamTest, NoPaddingWhenVideoIsMuted) {
class NoPaddingWhenVideoIsMuted : public test::SendTest {
public:
NoPaddingWhenVideoIsMuted()
: SendTest(kDefaultTimeoutMs),
: SendTest(kDefaultTimeout),
clock_(Clock::GetRealTimeClock()),
capturer_(nullptr) {}
@ -1408,7 +1408,7 @@ TEST_F(VideoSendStreamTest, PaddingIsPrimarilyRetransmissions) {
class PaddingIsPrimarilyRetransmissions : public test::EndToEndTest {
public:
PaddingIsPrimarilyRetransmissions()
: EndToEndTest(kDefaultTimeoutMs),
: EndToEndTest(kDefaultTimeout),
clock_(Clock::GetRealTimeClock()),
padding_length_(0),
total_length_(0),
@ -1491,7 +1491,7 @@ TEST_F(VideoSendStreamTest, MinTransmitBitrateRespectsRemb) {
class BitrateObserver : public test::SendTest {
public:
explicit BitrateObserver(TaskQueueBase* task_queue)
: SendTest(kDefaultTimeoutMs),
: SendTest(kDefaultTimeout),
task_queue_(task_queue),
retranmission_rate_limiter_(Clock::GetRealTimeClock(), 1000),
stream_(nullptr),
@ -1582,7 +1582,7 @@ TEST_F(VideoSendStreamTest, ChangingNetworkRoute) {
class ChangingNetworkRouteTest : public test::EndToEndTest {
public:
explicit ChangingNetworkRouteTest(TaskQueueBase* task_queue)
: EndToEndTest(test::CallTest::kDefaultTimeoutMs),
: EndToEndTest(test::CallTest::kDefaultTimeout),
task_queue_(task_queue),
call_(nullptr) {
module_process_thread_.Detach();
@ -1707,7 +1707,7 @@ TEST_F(VideoSendStreamTest, DISABLED_RelayToDirectRoute) {
class RelayToDirectRouteTest : public test::EndToEndTest {
public:
explicit RelayToDirectRouteTest(TaskQueueBase* task_queue)
: EndToEndTest(test::CallTest::kDefaultTimeoutMs),
: EndToEndTest(test::CallTest::kDefaultTimeout),
task_queue_(task_queue),
call_(nullptr),
packets_sent_(0),
@ -1802,7 +1802,7 @@ TEST_F(VideoSendStreamTest, ChangingTransportOverhead) {
class ChangingTransportOverheadTest : public test::EndToEndTest {
public:
explicit ChangingTransportOverheadTest(TaskQueueBase* task_queue)
: EndToEndTest(test::CallTest::kDefaultTimeoutMs),
: EndToEndTest(test::CallTest::kDefaultTimeout),
task_queue_(task_queue),
call_(nullptr),
packets_sent_(0),
@ -1878,7 +1878,7 @@ class MaxPaddingSetTest : public test::SendTest {
MaxPaddingSetTest(bool test_switch_content_type,
T* stream_reset_fun,
TaskQueueBase* task_queue)
: SendTest(test::CallTest::kDefaultTimeoutMs),
: SendTest(test::CallTest::kDefaultTimeout),
running_without_padding_(test_switch_content_type),
stream_resetter_(stream_reset_fun),
task_queue_(task_queue) {
@ -2036,7 +2036,7 @@ TEST_F(VideoSendStreamTest,
}
}
EXPECT_TRUE(
init_encode_called_.Wait(VideoSendStreamTest::kDefaultTimeoutMs));
init_encode_called_.Wait(VideoSendStreamTest::kDefaultTimeout.ms()));
{
MutexLock lock(&mutex_);
EXPECT_EQ(width, last_initialized_frame_width_);
@ -2123,7 +2123,7 @@ TEST_F(VideoSendStreamTest, CanReconfigureToUseStartBitrateAbovePreviousMax) {
bool WaitForStartBitrate() {
return start_bitrate_changed_.Wait(
VideoSendStreamTest::kDefaultTimeoutMs);
VideoSendStreamTest::kDefaultTimeout.ms());
}
private:
@ -2201,7 +2201,7 @@ class StartStopBitrateObserver : public test::FakeEncoder {
}
bool WaitForEncoderInit() {
return encoder_init_.Wait(VideoSendStreamTest::kDefaultTimeoutMs);
return encoder_init_.Wait(VideoSendStreamTest::kDefaultTimeout.ms());
}
bool WaitBitrateChanged(WaitUntil until) {
@ -2218,7 +2218,7 @@ class StartStopBitrateObserver : public test::FakeEncoder {
(until == WaitUntil::kZero && *bitrate_kbps == 0)) {
return true;
}
} while (bitrate_changed_.Wait(VideoSendStreamTest::kDefaultTimeoutMs));
} while (bitrate_changed_.Wait(VideoSendStreamTest::kDefaultTimeout.ms()));
return false;
}
@ -2233,7 +2233,7 @@ TEST_F(VideoSendStreamTest, EncoderIsProperlyInitializedAndDestroyed) {
class EncoderStateObserver : public test::SendTest, public VideoEncoder {
public:
explicit EncoderStateObserver(TaskQueueBase* task_queue)
: SendTest(kDefaultTimeoutMs),
: SendTest(kDefaultTimeout),
task_queue_(task_queue),
stream_(nullptr),
initialized_(false),
@ -2364,7 +2364,7 @@ class VideoCodecConfigObserver : public test::SendTest,
public:
VideoCodecConfigObserver(VideoCodecType video_codec_type,
TaskQueueBase* task_queue)
: SendTest(VideoSendStreamTest::kDefaultTimeoutMs),
: SendTest(VideoSendStreamTest::kDefaultTimeout),
FakeEncoder(Clock::GetRealTimeClock()),
video_codec_type_(video_codec_type),
stream_(nullptr),
@ -2411,7 +2411,7 @@ class VideoCodecConfigObserver : public test::SendTest,
void PerformTest() override {
EXPECT_TRUE(
init_encode_event_.Wait(VideoSendStreamTest::kDefaultTimeoutMs));
init_encode_event_.Wait(VideoSendStreamTest::kDefaultTimeout.ms()));
ASSERT_EQ(1, FakeEncoder::GetNumInitializations())
<< "VideoEncoder not initialized.";
@ -2422,7 +2422,7 @@ class VideoCodecConfigObserver : public test::SendTest,
stream_->ReconfigureVideoEncoder(std::move(encoder_config_));
});
ASSERT_TRUE(
init_encode_event_.Wait(VideoSendStreamTest::kDefaultTimeoutMs));
init_encode_event_.Wait(VideoSendStreamTest::kDefaultTimeout.ms()));
EXPECT_EQ(2, FakeEncoder::GetNumInitializations())
<< "ReconfigureVideoEncoder did not reinitialize the encoder with "
"new encoder settings.";
@ -2567,7 +2567,7 @@ TEST_F(VideoSendStreamTest, RtcpSenderReportContainsMediaBytesSent) {
class RtcpSenderReportTest : public test::SendTest {
public:
RtcpSenderReportTest()
: SendTest(kDefaultTimeoutMs),
: SendTest(kDefaultTimeout),
rtp_packets_sent_(0),
media_bytes_sent_(0) {}
@ -2642,7 +2642,7 @@ TEST_F(VideoSendStreamTest, TranslatesTwoLayerScreencastToTargetBitrate) {
public test::FakeEncoder {
public:
ScreencastTargetBitrateTest()
: SendTest(kDefaultTimeoutMs),
: SendTest(kDefaultTimeout),
test::FakeEncoder(Clock::GetRealTimeClock()),
encoder_factory_(this) {}
@ -2702,7 +2702,7 @@ TEST_F(VideoSendStreamTest, ReconfigureBitratesSetsEncoderBitratesCorrectly) {
public test::FakeEncoder {
public:
explicit EncoderBitrateThresholdObserver(TaskQueueBase* task_queue)
: SendTest(kDefaultTimeoutMs),
: SendTest(kDefaultTimeout),
FakeEncoder(Clock::GetRealTimeClock()),
task_queue_(task_queue),
target_bitrate_(0),
@ -2785,7 +2785,7 @@ TEST_F(VideoSendStreamTest, ReconfigureBitratesSetsEncoderBitratesCorrectly) {
return;
}
} while (bitrate_changed_event_.Wait(
std::max(int64_t{1}, VideoSendStreamTest::kDefaultTimeoutMs -
std::max(int64_t{1}, VideoSendStreamTest::kDefaultTimeout.ms() -
(rtc::TimeMillis() - start_time))));
MutexLock lock(&mutex_);
EXPECT_EQ(target_bitrate_, expected_bitrate)
@ -2826,10 +2826,10 @@ TEST_F(VideoSendStreamTest, ReconfigureBitratesSetsEncoderBitratesCorrectly) {
void PerformTest() override {
ASSERT_TRUE(create_rate_allocator_event_.Wait(
VideoSendStreamTest::kDefaultTimeoutMs))
VideoSendStreamTest::kDefaultTimeout.ms()))
<< "Timed out while waiting for rate allocator to be created.";
ASSERT_TRUE(
init_encode_event_.Wait(VideoSendStreamTest::kDefaultTimeoutMs))
init_encode_event_.Wait(VideoSendStreamTest::kDefaultTimeout.ms()))
<< "Timed out while waiting for encoder to be configured.";
WaitForSetRates(kStartBitrateKbps);
BitrateConstraints bitrate_config;
@ -2846,7 +2846,7 @@ TEST_F(VideoSendStreamTest, ReconfigureBitratesSetsEncoderBitratesCorrectly) {
send_stream_->ReconfigureVideoEncoder(encoder_config_.Copy());
});
ASSERT_TRUE(create_rate_allocator_event_.Wait(
VideoSendStreamTest::kDefaultTimeoutMs));
VideoSendStreamTest::kDefaultTimeout.ms()));
EXPECT_EQ(2, num_rate_allocator_creations_)
<< "Rate allocator should have been recreated.";
@ -2858,7 +2858,7 @@ TEST_F(VideoSendStreamTest, ReconfigureBitratesSetsEncoderBitratesCorrectly) {
send_stream_->ReconfigureVideoEncoder(encoder_config_.Copy());
});
ASSERT_TRUE(create_rate_allocator_event_.Wait(
VideoSendStreamTest::kDefaultTimeoutMs));
VideoSendStreamTest::kDefaultTimeout.ms()));
EXPECT_EQ(3, num_rate_allocator_creations_)
<< "Rate allocator should have been recreated.";
@ -2898,7 +2898,7 @@ TEST_F(VideoSendStreamTest, ReportsSentResolution) {
public test::FakeEncoder {
public:
explicit ScreencastTargetBitrateTest(TaskQueueBase* task_queue)
: SendTest(kDefaultTimeoutMs),
: SendTest(kDefaultTimeout),
test::FakeEncoder(Clock::GetRealTimeClock()),
send_stream_(nullptr),
encoder_factory_(this),
@ -2983,7 +2983,7 @@ TEST_F(VideoSendStreamTest, ReportsSentResolution) {
class Vp9HeaderObserver : public test::SendTest {
public:
explicit Vp9HeaderObserver(const Vp9TestParams& params)
: SendTest(VideoSendStreamTest::kLongTimeoutMs),
: SendTest(VideoSendStreamTest::kLongTimeout),
encoder_factory_([]() { return VP9Encoder::Create(); }),
params_(params),
vp9_settings_(VideoEncoder::GetDefaultVp9Settings()) {}
@ -3643,7 +3643,7 @@ TEST_F(VideoSendStreamTest, EncoderConfigMaxFramerateReportedToSource) {
class FpsObserver : public test::SendTest,
public test::FrameGeneratorCapturer::SinkWantsObserver {
public:
FpsObserver() : SendTest(kDefaultTimeoutMs) {}
FpsObserver() : SendTest(kDefaultTimeout) {}
void OnFrameGeneratorCapturerCreated(
test::FrameGeneratorCapturer* frame_generator_capturer) override {
@ -3681,7 +3681,7 @@ TEST_F(VideoSendStreamTest, RemoveOverheadFromBandwidth) {
public test::FakeEncoder {
public:
explicit RemoveOverheadFromBandwidthTest(TaskQueueBase* task_queue)
: EndToEndTest(test::CallTest::kDefaultTimeoutMs),
: EndToEndTest(test::CallTest::kDefaultTimeout),
FakeEncoder(Clock::GetRealTimeClock()),
task_queue_(task_queue),
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
// overhead of 40B per packet video produces 2240bps overhead.
// So the encoder BW should be set to 57760bps.
EXPECT_TRUE(
bitrate_changed_event_.Wait(VideoSendStreamTest::kDefaultTimeoutMs));
EXPECT_TRUE(bitrate_changed_event_.Wait(
VideoSendStreamTest::kDefaultTimeout.ms()));
{
MutexLock lock(&mutex_);
EXPECT_LE(max_bitrate_bps_, 57760u);
@ -3760,7 +3760,7 @@ class PacingFactorObserver : public test::SendTest {
public:
PacingFactorObserver(bool configure_send_side,
absl::optional<float> expected_pacing_factor)
: test::SendTest(VideoSendStreamTest::kDefaultTimeoutMs),
: test::SendTest(VideoSendStreamTest::kDefaultTimeout),
configure_send_side_(configure_send_side),
expected_pacing_factor_(expected_pacing_factor) {}
@ -3856,7 +3856,7 @@ class ContentSwitchTest : public test::SendTest {
static const uint32_t kMinPacketsToSend = 50;
explicit ContentSwitchTest(T* stream_reset_fun, TaskQueueBase* task_queue)
: SendTest(test::CallTest::kDefaultTimeoutMs),
: SendTest(test::CallTest::kDefaultTimeout),
call_(nullptr),
state_(StreamState::kBeforeSwitch),
send_stream_(nullptr),
@ -3953,7 +3953,7 @@ class ContentSwitchTest : public test::SendTest {
void PerformTest() override {
while (GetStreamState() != StreamState::kAfterSwitchBack) {
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);
}
@ -4017,7 +4017,7 @@ void VideoSendStreamTest::TestTemporalLayers(
const std::string& payload_name,
const std::vector<int>& num_temporal_layers,
const std::vector<ScalabilityMode>& scalability_mode)
: EndToEndTest(kDefaultTimeoutMs),
: EndToEndTest(kDefaultTimeout),
encoder_factory_(encoder_factory),
payload_name_(payload_name),
num_temporal_layers_(num_temporal_layers),