mollyim/webrtc
1
0
Fork 0
mirror of https://github.com/mollyim/webrtc.git synced 2025-05-12 21:30:45 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Remove rtc::Location from SendTask test helper

Browse source 
that rtc::Location parameter was used only as extra information for the
RTC_CHECKs directly in the function, thus call stack of the crash should
provide all the information about the caller.

Bug: webrtc:11318
Change-Id: Iec6dd2c5de547f3e1601647a614be7ce57a55734
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/270920
Reviewed-by: Tomas Gunnarsson <tommi@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#37748}
This commit is contained in:
Danil Chapovalov 2022-08-11 12:26:09 +02:00 committed by WebRTC LUCI CQ
parent e2d829cf77
commit e519f38eaa
37 changed files with 352 additions and 470 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

27
api/sequence_checker_unittest.cc
View file

@ -76,20 +76,16 @@ TEST(SequenceCheckerTest, DetachFromThreadAndUseOnTaskQueue) {
SequenceChecker sequence_checker; SequenceChecker sequence_checker;
sequence_checker.Detach(); sequence_checker.Detach();
TaskQueueForTest queue; TaskQueueForTest queue;
queue.SendTask([&] { EXPECT_TRUE(sequence_checker.IsCurrent()); }, queue.SendTask([&] { EXPECT_TRUE(sequence_checker.IsCurrent()); });
RTC_FROM_HERE);
} }
TEST(SequenceCheckerTest, DetachFromTaskQueueAndUseOnThread) { TEST(SequenceCheckerTest, DetachFromTaskQueueAndUseOnThread) {
TaskQueueForTest queue; TaskQueueForTest queue;
queue.SendTask( queue.SendTask([] {
[] { SequenceChecker sequence_checker;
SequenceChecker sequence_checker; sequence_checker.Detach();
sequence_checker.Detach(); RunOnDifferentThread([&] { EXPECT_TRUE(sequence_checker.IsCurrent()); });
RunOnDifferentThread( });
[&] { EXPECT_TRUE(sequence_checker.IsCurrent()); });
},
RTC_FROM_HERE);
} }
TEST(SequenceCheckerTest, MethodNotAllowedOnDifferentThreadInDebug) { TEST(SequenceCheckerTest, MethodNotAllowedOnDifferentThreadInDebug) {
@ -102,8 +98,7 @@ TEST(SequenceCheckerTest, MethodNotAllowedOnDifferentTaskQueueInDebug) {
SequenceChecker sequence_checker; SequenceChecker sequence_checker;
TaskQueueForTest queue; TaskQueueForTest queue;
queue.SendTask( queue.SendTask(
[&] { EXPECT_EQ(sequence_checker.IsCurrent(), !RTC_DCHECK_IS_ON); }, [&] { EXPECT_EQ(sequence_checker.IsCurrent(), !RTC_DCHECK_IS_ON); });
RTC_FROM_HERE);
} }
TEST(SequenceCheckerTest, DetachFromTaskQueueInDebug) { TEST(SequenceCheckerTest, DetachFromTaskQueueInDebug) {
@ -111,15 +106,13 @@ TEST(SequenceCheckerTest, DetachFromTaskQueueInDebug) {
sequence_checker.Detach(); sequence_checker.Detach();
TaskQueueForTest queue1; TaskQueueForTest queue1;
queue1.SendTask([&] { EXPECT_TRUE(sequence_checker.IsCurrent()); }, queue1.SendTask([&] { EXPECT_TRUE(sequence_checker.IsCurrent()); });
RTC_FROM_HERE);
// IsCurrent should return false in debug builds after moving to // IsCurrent should return false in debug builds after moving to
// another task queue. // another task queue.
TaskQueueForTest queue2; TaskQueueForTest queue2;
queue2.SendTask( queue2.SendTask(
[&] { EXPECT_EQ(sequence_checker.IsCurrent(), !RTC_DCHECK_IS_ON); }, [&] { EXPECT_EQ(sequence_checker.IsCurrent(), !RTC_DCHECK_IS_ON); });
RTC_FROM_HERE);
} }
class TestAnnotations { class TestAnnotations {
@ -146,7 +139,7 @@ TEST(SequenceCheckerTest, TestAnnotations) {
void TestAnnotationsOnWrongQueue() { void TestAnnotationsOnWrongQueue() {
TestAnnotations annotations; TestAnnotations annotations;
TaskQueueForTest queue; TaskQueueForTest queue;
queue.SendTask([&] { annotations.ModifyTestVar(); }, RTC_FROM_HERE); queue.SendTask([&] { annotations.ModifyTestVar(); });
} }
#if RTC_DCHECK_IS_ON #if RTC_DCHECK_IS_ON

32
api/task_queue/pending_task_safety_flag_unittest.cc
View file

@ -85,20 +85,16 @@ TEST(PendingTaskSafetyFlagTest, PendingTaskSuccess) {
}; };
std::unique_ptr<Owner> owner; std::unique_ptr<Owner> owner;
tq1.SendTask( tq1.SendTask([&owner]() {
[&owner]() { owner = std::make_unique<Owner>();
owner = std::make_unique<Owner>(); EXPECT_FALSE(owner->stuff_done());
EXPECT_FALSE(owner->stuff_done()); });
},
RTC_FROM_HERE);
ASSERT_TRUE(owner); ASSERT_TRUE(owner);
tq2.SendTask([&owner]() { owner->DoStuff(); }, RTC_FROM_HERE); tq2.SendTask([&owner]() { owner->DoStuff(); });
tq1.SendTask( tq1.SendTask([&owner]() {
[&owner]() { EXPECT_TRUE(owner->stuff_done());
EXPECT_TRUE(owner->stuff_done()); owner.reset();
owner.reset(); });
},
RTC_FROM_HERE);
ASSERT_FALSE(owner); ASSERT_FALSE(owner);
} }
@ -129,9 +125,9 @@ TEST(PendingTaskSafetyFlagTest, PendingTaskDropped) {
std::unique_ptr<Owner> owner; std::unique_ptr<Owner> owner;
bool stuff_done = false; bool stuff_done = false;
tq1.SendTask( tq1.SendTask([&owner, &stuff_done]() {
[&owner, &stuff_done]() { owner = std::make_unique<Owner>(&stuff_done); }, owner = std::make_unique<Owner>(&stuff_done);
RTC_FROM_HERE); });
ASSERT_TRUE(owner); ASSERT_TRUE(owner);
// Queue up a task on tq1 that will execute before the 'DoStuff' task // Queue up a task on tq1 that will execute before the 'DoStuff' task
// can, and delete the `owner` before the 'stuff' task can execute. // can, and delete the `owner` before the 'stuff' task can execute.
@ -142,7 +138,7 @@ TEST(PendingTaskSafetyFlagTest, PendingTaskDropped) {
}); });
// Queue up a DoStuff... // Queue up a DoStuff...
tq2.SendTask([&owner]() { owner->DoStuff(); }, RTC_FROM_HERE); tq2.SendTask([&owner]() { owner->DoStuff(); });
ASSERT_TRUE(owner); ASSERT_TRUE(owner);
blocker.Set(); blocker.Set();
@ -158,7 +154,7 @@ TEST(PendingTaskSafetyFlagTest, PendingTaskNotAliveInitialized) {
// Create a new flag that initially not `alive`. // Create a new flag that initially not `alive`.
auto flag = PendingTaskSafetyFlag::CreateDetachedInactive(); auto flag = PendingTaskSafetyFlag::CreateDetachedInactive();
tq.SendTask([&flag]() { EXPECT_FALSE(flag->alive()); }, RTC_FROM_HERE); tq.SendTask([&flag]() { EXPECT_FALSE(flag->alive()); });
bool task_1_ran = false; bool task_1_ran = false;
bool task_2_ran = false; bool task_2_ran = false;

33
audio/audio_send_stream_unittest.cc
View file

@ -638,8 +638,7 @@ TEST(AudioSendStreamTest, DoesNotPassHigherBitrateThanMaxBitrate) {
update.packet_loss_ratio = 0; update.packet_loss_ratio = 0;
update.round_trip_time = TimeDelta::Millis(50); update.round_trip_time = TimeDelta::Millis(50);
update.bwe_period = TimeDelta::Millis(6000); update.bwe_period = TimeDelta::Millis(6000);
helper.worker()->SendTask([&] { send_stream->OnBitrateUpdated(update); }, helper.worker()->SendTask([&] { send_stream->OnBitrateUpdated(update); });
RTC_FROM_HERE);
} }
} }
@ -655,8 +654,7 @@ TEST(AudioSendStreamTest, SSBweTargetInRangeRespected) {
BitrateAllocationUpdate update; BitrateAllocationUpdate update;
update.target_bitrate = update.target_bitrate =
DataRate::BitsPerSec(helper.config().max_bitrate_bps - 5000); DataRate::BitsPerSec(helper.config().max_bitrate_bps - 5000);
helper.worker()->SendTask([&] { send_stream->OnBitrateUpdated(update); }, helper.worker()->SendTask([&] { send_stream->OnBitrateUpdated(update); });
RTC_FROM_HERE);
} }
} }
@ -672,8 +670,7 @@ TEST(AudioSendStreamTest, SSBweFieldTrialMinRespected) {
Eq(DataRate::KilobitsPerSec(6))))); Eq(DataRate::KilobitsPerSec(6)))));
BitrateAllocationUpdate update; BitrateAllocationUpdate update;
update.target_bitrate = DataRate::KilobitsPerSec(1); update.target_bitrate = DataRate::KilobitsPerSec(1);
helper.worker()->SendTask([&] { send_stream->OnBitrateUpdated(update); }, helper.worker()->SendTask([&] { send_stream->OnBitrateUpdated(update); });
RTC_FROM_HERE);
} }
} }
@ -689,8 +686,7 @@ TEST(AudioSendStreamTest, SSBweFieldTrialMaxRespected) {
Eq(DataRate::KilobitsPerSec(64))))); Eq(DataRate::KilobitsPerSec(64)))));
BitrateAllocationUpdate update; BitrateAllocationUpdate update;
update.target_bitrate = DataRate::KilobitsPerSec(128); update.target_bitrate = DataRate::KilobitsPerSec(128);
helper.worker()->SendTask([&] { send_stream->OnBitrateUpdated(update); }, helper.worker()->SendTask([&] { send_stream->OnBitrateUpdated(update); });
RTC_FROM_HERE);
} }
} }
@ -710,8 +706,7 @@ TEST(AudioSendStreamTest, SSBweWithOverhead) {
&BitrateAllocationUpdate::target_bitrate, Eq(bitrate)))); &BitrateAllocationUpdate::target_bitrate, Eq(bitrate))));
BitrateAllocationUpdate update; BitrateAllocationUpdate update;
update.target_bitrate = bitrate; update.target_bitrate = bitrate;
helper.worker()->SendTask([&] { send_stream->OnBitrateUpdated(update); }, helper.worker()->SendTask([&] { send_stream->OnBitrateUpdated(update); });
RTC_FROM_HERE);
} }
} }
@ -731,8 +726,7 @@ TEST(AudioSendStreamTest, SSBweWithOverheadMinRespected) {
&BitrateAllocationUpdate::target_bitrate, Eq(bitrate)))); &BitrateAllocationUpdate::target_bitrate, Eq(bitrate))));
BitrateAllocationUpdate update; BitrateAllocationUpdate update;
update.target_bitrate = DataRate::KilobitsPerSec(1); update.target_bitrate = DataRate::KilobitsPerSec(1);
helper.worker()->SendTask([&] { send_stream->OnBitrateUpdated(update); }, helper.worker()->SendTask([&] { send_stream->OnBitrateUpdated(update); });
RTC_FROM_HERE);
} }
} }
@ -752,8 +746,7 @@ TEST(AudioSendStreamTest, SSBweWithOverheadMaxRespected) {
&BitrateAllocationUpdate::target_bitrate, Eq(bitrate)))); &BitrateAllocationUpdate::target_bitrate, Eq(bitrate))));
BitrateAllocationUpdate update; BitrateAllocationUpdate update;
update.target_bitrate = DataRate::KilobitsPerSec(128); update.target_bitrate = DataRate::KilobitsPerSec(128);
helper.worker()->SendTask([&] { send_stream->OnBitrateUpdated(update); }, helper.worker()->SendTask([&] { send_stream->OnBitrateUpdated(update); });
RTC_FROM_HERE);
} }
} }
@ -771,8 +764,7 @@ TEST(AudioSendStreamTest, ProbingIntervalOnBitrateUpdated) {
update.packet_loss_ratio = 0; update.packet_loss_ratio = 0;
update.round_trip_time = TimeDelta::Millis(50); update.round_trip_time = TimeDelta::Millis(50);
update.bwe_period = TimeDelta::Millis(5000); update.bwe_period = TimeDelta::Millis(5000);
helper.worker()->SendTask([&] { send_stream->OnBitrateUpdated(update); }, helper.worker()->SendTask([&] { send_stream->OnBitrateUpdated(update); });
RTC_FROM_HERE);
} }
} }
@ -874,8 +866,7 @@ TEST(AudioSendStreamTest, AudioOverheadChanged) {
DataRate::BitsPerSec(helper.config().max_bitrate_bps) + DataRate::BitsPerSec(helper.config().max_bitrate_bps) +
kMaxOverheadRate; kMaxOverheadRate;
EXPECT_CALL(*helper.channel_send(), OnBitrateAllocation); EXPECT_CALL(*helper.channel_send(), OnBitrateAllocation);
helper.worker()->SendTask([&] { send_stream->OnBitrateUpdated(update); }, helper.worker()->SendTask([&] { send_stream->OnBitrateUpdated(update); });
RTC_FROM_HERE);
EXPECT_EQ(audio_overhead_per_packet_bytes, EXPECT_EQ(audio_overhead_per_packet_bytes,
send_stream->TestOnlyGetPerPacketOverheadBytes()); send_stream->TestOnlyGetPerPacketOverheadBytes());
@ -883,8 +874,7 @@ TEST(AudioSendStreamTest, AudioOverheadChanged) {
EXPECT_CALL(*helper.rtp_rtcp(), ExpectedPerPacketOverhead) EXPECT_CALL(*helper.rtp_rtcp(), ExpectedPerPacketOverhead)
.WillRepeatedly(Return(audio_overhead_per_packet_bytes + 20)); .WillRepeatedly(Return(audio_overhead_per_packet_bytes + 20));
EXPECT_CALL(*helper.channel_send(), OnBitrateAllocation); EXPECT_CALL(*helper.channel_send(), OnBitrateAllocation);
helper.worker()->SendTask([&] { send_stream->OnBitrateUpdated(update); }, helper.worker()->SendTask([&] { send_stream->OnBitrateUpdated(update); });
RTC_FROM_HERE);
EXPECT_EQ(audio_overhead_per_packet_bytes + 20, EXPECT_EQ(audio_overhead_per_packet_bytes + 20,
send_stream->TestOnlyGetPerPacketOverheadBytes()); send_stream->TestOnlyGetPerPacketOverheadBytes());
@ -908,8 +898,7 @@ TEST(AudioSendStreamTest, OnAudioAndTransportOverheadChanged) {
DataRate::BitsPerSec(helper.config().max_bitrate_bps) + DataRate::BitsPerSec(helper.config().max_bitrate_bps) +
kMaxOverheadRate; kMaxOverheadRate;
EXPECT_CALL(*helper.channel_send(), OnBitrateAllocation); EXPECT_CALL(*helper.channel_send(), OnBitrateAllocation);
helper.worker()->SendTask([&] { send_stream->OnBitrateUpdated(update); }, helper.worker()->SendTask([&] { send_stream->OnBitrateUpdated(update); });
RTC_FROM_HERE);
EXPECT_EQ( EXPECT_EQ(
transport_overhead_per_packet_bytes + audio_overhead_per_packet_bytes, transport_overhead_per_packet_bytes + audio_overhead_per_packet_bytes,

18
call/bitrate_estimator_tests.cc
View file

@ -110,7 +110,7 @@ class BitrateEstimatorTest : public test::CallTest {
virtual ~BitrateEstimatorTest() { EXPECT_TRUE(streams_.empty()); } virtual ~BitrateEstimatorTest() { EXPECT_TRUE(streams_.empty()); }
virtual void SetUp() { virtual void SetUp() {
SendTask(RTC_FROM_HERE, task_queue(), [this]() { SendTask(task_queue(), [this]() {
CreateCalls(); CreateCalls();
send_transport_.reset(new test::DirectTransport( send_transport_.reset(new test::DirectTransport(
@ -154,7 +154,7 @@ class BitrateEstimatorTest : public test::CallTest {
} }
virtual void TearDown() { virtual void TearDown() {
SendTask(RTC_FROM_HERE, task_queue(), [this]() { SendTask(task_queue(), [this]() {
for (auto* stream : streams_) { for (auto* stream : streams_) {
stream->StopSending(); stream->StopSending();
delete stream; delete stream;
@ -257,7 +257,7 @@ static const char* kSingleStreamLog =
"RemoteBitrateEstimatorSingleStream: Instantiating."; "RemoteBitrateEstimatorSingleStream: Instantiating.";
TEST_F(BitrateEstimatorTest, InstantiatesTOFPerDefaultForVideo) { TEST_F(BitrateEstimatorTest, InstantiatesTOFPerDefaultForVideo) {
SendTask(RTC_FROM_HERE, task_queue(), [this]() { SendTask(task_queue(), [this]() {
GetVideoSendConfig()->rtp.extensions.push_back( GetVideoSendConfig()->rtp.extensions.push_back(
RtpExtension(RtpExtension::kTimestampOffsetUri, kTOFExtensionId)); RtpExtension(RtpExtension::kTimestampOffsetUri, kTOFExtensionId));
receiver_log_.PushExpectedLogLine(kSingleStreamLog); receiver_log_.PushExpectedLogLine(kSingleStreamLog);
@ -268,7 +268,7 @@ TEST_F(BitrateEstimatorTest, InstantiatesTOFPerDefaultForVideo) {
} }
TEST_F(BitrateEstimatorTest, ImmediatelySwitchToASTForVideo) { TEST_F(BitrateEstimatorTest, ImmediatelySwitchToASTForVideo) {
SendTask(RTC_FROM_HERE, task_queue(), [this]() { SendTask(task_queue(), [this]() {
GetVideoSendConfig()->rtp.extensions.push_back( GetVideoSendConfig()->rtp.extensions.push_back(
RtpExtension(RtpExtension::kAbsSendTimeUri, kASTExtensionId)); RtpExtension(RtpExtension::kAbsSendTimeUri, kASTExtensionId));
receiver_log_.PushExpectedLogLine(kSingleStreamLog); receiver_log_.PushExpectedLogLine(kSingleStreamLog);
@ -281,7 +281,7 @@ TEST_F(BitrateEstimatorTest, ImmediatelySwitchToASTForVideo) {
} }
TEST_F(BitrateEstimatorTest, SwitchesToASTForVideo) { TEST_F(BitrateEstimatorTest, SwitchesToASTForVideo) {
SendTask(RTC_FROM_HERE, task_queue(), [this]() { SendTask(task_queue(), [this]() {
GetVideoSendConfig()->rtp.extensions.push_back( GetVideoSendConfig()->rtp.extensions.push_back(
RtpExtension(RtpExtension::kTimestampOffsetUri, kTOFExtensionId)); RtpExtension(RtpExtension::kTimestampOffsetUri, kTOFExtensionId));
receiver_log_.PushExpectedLogLine(kSingleStreamLog); receiver_log_.PushExpectedLogLine(kSingleStreamLog);
@ -290,7 +290,7 @@ TEST_F(BitrateEstimatorTest, SwitchesToASTForVideo) {
}); });
EXPECT_TRUE(receiver_log_.Wait()); EXPECT_TRUE(receiver_log_.Wait());
SendTask(RTC_FROM_HERE, task_queue(), [this]() { SendTask(task_queue(), [this]() {
GetVideoSendConfig()->rtp.extensions[0] = GetVideoSendConfig()->rtp.extensions[0] =
RtpExtension(RtpExtension::kAbsSendTimeUri, kASTExtensionId); RtpExtension(RtpExtension::kAbsSendTimeUri, kASTExtensionId);
receiver_log_.PushExpectedLogLine("Switching to absolute send time RBE."); receiver_log_.PushExpectedLogLine("Switching to absolute send time RBE.");
@ -302,7 +302,7 @@ TEST_F(BitrateEstimatorTest, SwitchesToASTForVideo) {
// This test is flaky. See webrtc:5790. // This test is flaky. See webrtc:5790.
TEST_F(BitrateEstimatorTest, DISABLED_SwitchesToASTThenBackToTOFForVideo) { TEST_F(BitrateEstimatorTest, DISABLED_SwitchesToASTThenBackToTOFForVideo) {
SendTask(RTC_FROM_HERE, task_queue(), [this]() { SendTask(task_queue(), [this]() {
GetVideoSendConfig()->rtp.extensions.push_back( GetVideoSendConfig()->rtp.extensions.push_back(
RtpExtension(RtpExtension::kTimestampOffsetUri, kTOFExtensionId)); RtpExtension(RtpExtension::kTimestampOffsetUri, kTOFExtensionId));
receiver_log_.PushExpectedLogLine(kSingleStreamLog); receiver_log_.PushExpectedLogLine(kSingleStreamLog);
@ -312,7 +312,7 @@ TEST_F(BitrateEstimatorTest, DISABLED_SwitchesToASTThenBackToTOFForVideo) {
}); });
EXPECT_TRUE(receiver_log_.Wait()); EXPECT_TRUE(receiver_log_.Wait());
SendTask(RTC_FROM_HERE, task_queue(), [this]() { SendTask(task_queue(), [this]() {
GetVideoSendConfig()->rtp.extensions[0] = GetVideoSendConfig()->rtp.extensions[0] =
RtpExtension(RtpExtension::kAbsSendTimeUri, kASTExtensionId); RtpExtension(RtpExtension::kAbsSendTimeUri, kASTExtensionId);
receiver_log_.PushExpectedLogLine(kAbsSendTimeLog); receiver_log_.PushExpectedLogLine(kAbsSendTimeLog);
@ -321,7 +321,7 @@ TEST_F(BitrateEstimatorTest, DISABLED_SwitchesToASTThenBackToTOFForVideo) {
}); });
EXPECT_TRUE(receiver_log_.Wait()); EXPECT_TRUE(receiver_log_.Wait());
SendTask(RTC_FROM_HERE, task_queue(), [this]() { SendTask(task_queue(), [this]() {
GetVideoSendConfig()->rtp.extensions[0] = GetVideoSendConfig()->rtp.extensions[0] =
RtpExtension(RtpExtension::kTimestampOffsetUri, kTOFExtensionId); RtpExtension(RtpExtension::kTimestampOffsetUri, kTOFExtensionId);
receiver_log_.PushExpectedLogLine(kAbsSendTimeLog); receiver_log_.PushExpectedLogLine(kAbsSendTimeLog);

8
call/call_perf_tests.cc
View file

@ -193,7 +193,7 @@ void CallPerfTest::TestAudioVideoSync(FecMode fec,
AudioReceiveStreamInterface* audio_receive_stream; AudioReceiveStreamInterface* audio_receive_stream;
std::unique_ptr<DriftingClock> drifting_clock; std::unique_ptr<DriftingClock> drifting_clock;
SendTask(RTC_FROM_HERE, task_queue(), [&]() { SendTask(task_queue(), [&]() {
metrics::Reset(); metrics::Reset();
rtc::scoped_refptr<TestAudioDeviceModule> fake_audio_device = rtc::scoped_refptr<TestAudioDeviceModule> fake_audio_device =
TestAudioDeviceModule::Create( TestAudioDeviceModule::Create(
@ -307,7 +307,7 @@ void CallPerfTest::TestAudioVideoSync(FecMode fec,
EXPECT_TRUE(observer->Wait()) EXPECT_TRUE(observer->Wait())
<< "Timed out while waiting for audio and video to be synchronized."; << "Timed out while waiting for audio and video to be synchronized.";
SendTask(RTC_FROM_HERE, task_queue(), [&]() { SendTask(task_queue(), [&]() {
// Clear the pointer to the receive stream since it will now be deleted. // Clear the pointer to the receive stream since it will now be deleted.
observer->set_receive_stream(nullptr); observer->set_receive_stream(nullptr);
@ -870,7 +870,7 @@ TEST_F(CallPerfTest, MAYBE_KeepsHighBitrateWhenReconfiguringSender) {
ASSERT_TRUE(time_to_reconfigure_.Wait(kDefaultTimeoutMs)) ASSERT_TRUE(time_to_reconfigure_.Wait(kDefaultTimeoutMs))
<< "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(RTC_FROM_HERE, task_queue_, [&]() { SendTask(task_queue_, [&]() {
send_stream_->ReconfigureVideoEncoder(encoder_config_.Copy()); send_stream_->ReconfigureVideoEncoder(encoder_config_.Copy());
}); });
EXPECT_TRUE(Wait()) EXPECT_TRUE(Wait())
@ -987,7 +987,7 @@ void CallPerfTest::TestMinAudioVideoBitrate(int test_bitrate_from,
int64_t avg_rtt = 0; int64_t avg_rtt = 0;
for (int i = 0; i < kBitrateMeasurements; i++) { for (int i = 0; i < kBitrateMeasurements; i++) {
Call::Stats call_stats; Call::Stats call_stats;
SendTask(RTC_FROM_HERE, task_queue_, [this, &call_stats]() { SendTask(task_queue_, [this, &call_stats]() {
call_stats = sender_call_->GetStats(); call_stats = sender_call_->GetStats();
}); });
avg_rtt += call_stats.rtt_ms; avg_rtt += call_stats.rtt_ms;

5
call/rampup_tests.cc
View file

@ -362,15 +362,14 @@ void RampUpTester::TriggerTestDone() {
// Stop polling stats. // Stop polling stats.
// Corner case for field_trials=WebRTC-QuickPerfTest/Enabled/ // Corner case for field_trials=WebRTC-QuickPerfTest/Enabled/
SendTask(RTC_FROM_HERE, task_queue_, [this] { pending_task_.Stop(); }); SendTask(task_queue_, [this] { pending_task_.Stop(); });
// TODO(holmer): Add audio send stats here too when those APIs are available. // TODO(holmer): Add audio send stats here too when those APIs are available.
if (!send_stream_) if (!send_stream_)
return; return;
VideoSendStream::Stats send_stats; VideoSendStream::Stats send_stats;
SendTask(RTC_FROM_HERE, task_queue_, SendTask(task_queue_, [&] { send_stats = send_stream_->GetStats(); });
[&] { send_stats = send_stream_->GetStats(); });
send_stream_ = nullptr; // To avoid dereferencing a bad pointer. send_stream_ = nullptr; // To avoid dereferencing a bad pointer.

6
modules/audio_mixer/audio_mixer_impl_unittest.cc
View file

@ -389,8 +389,7 @@ TEST(AudioMixer, RampedOutSourcesShouldNotBeMarkedMixed) {
TEST(AudioMixer, ConstructFromOtherThread) { TEST(AudioMixer, ConstructFromOtherThread) {
TaskQueueForTest init_queue("init"); TaskQueueForTest init_queue("init");
rtc::scoped_refptr<AudioMixer> mixer; rtc::scoped_refptr<AudioMixer> mixer;
init_queue.SendTask([&mixer]() { mixer = AudioMixerImpl::Create(); }, init_queue.SendTask([&mixer]() { mixer = AudioMixerImpl::Create(); });
RTC_FROM_HERE);
MockMixerAudioSource participant; MockMixerAudioSource participant;
EXPECT_CALL(participant, PreferredSampleRate()) EXPECT_CALL(participant, PreferredSampleRate())
@ -400,8 +399,7 @@ TEST(AudioMixer, ConstructFromOtherThread) {
TaskQueueForTest participant_queue("participant"); TaskQueueForTest participant_queue("participant");
participant_queue.SendTask( participant_queue.SendTask(
[&mixer, &participant]() { mixer->AddSource(&participant); }, [&mixer, &participant]() { mixer->AddSource(&participant); });
RTC_FROM_HERE);
EXPECT_CALL(participant, GetAudioFrameWithInfo(kDefaultSampleRateHz, _)) EXPECT_CALL(participant, GetAudioFrameWithInfo(kDefaultSampleRateHz, _))
.Times(Exactly(1)); .Times(Exactly(1));

3
modules/rtp_rtcp/source/rtp_sender_video_unittest.cc
View file

@ -1520,8 +1520,7 @@ TEST_F(RtpSenderVideoWithFrameTransformerTest, OnTransformedFrameSendsVideo) {
rtp_sender_video->SendEncodedImage( rtp_sender_video->SendEncodedImage(
kPayload, kType, kTimestamp, *encoded_image, video_header, kPayload, kType, kTimestamp, *encoded_image, video_header,
kDefaultExpectedRetransmissionTimeMs); kDefaultExpectedRetransmissionTimeMs);
}, });
RTC_FROM_HERE);
encoder_queue.WaitForPreviouslyPostedTasks(); encoder_queue.WaitForPreviouslyPostedTasks();
EXPECT_EQ(transport_.packets_sent(), 1); EXPECT_EQ(transport_.packets_sent(), 1);
} }

41
modules/video_coding/codecs/test/videocodec_test_fixture_impl.cc
View file

@ -503,7 +503,7 @@ void VideoCodecTestFixtureImpl::ProcessAllFrames(
task_queue->PostTask([this] { processor_->Finalize(); }); task_queue->PostTask([this] { processor_->Finalize(); });
// Wait until we know that the last frame has been sent for encode. // Wait until we know that the last frame has been sent for encode.
task_queue->SendTask([] {}, RTC_FROM_HERE); task_queue->SendTask([] {});
// Give the VideoProcessor pipeline some time to process the last frame, // Give the VideoProcessor pipeline some time to process the last frame,
// and then release the codecs. // and then release the codecs.
@ -720,11 +720,9 @@ bool VideoCodecTestFixtureImpl::SetUpAndInitObjects(
cpu_process_time_.reset(new CpuProcessTime(config_)); cpu_process_time_.reset(new CpuProcessTime(config_));
bool is_codec_created = false; bool is_codec_created = false;
task_queue->SendTask( task_queue->SendTask([this, &is_codec_created]() {
[this, &is_codec_created]() { is_codec_created = CreateEncoderAndDecoder();
is_codec_created = CreateEncoderAndDecoder(); });
},
RTC_FROM_HERE);
if (!is_codec_created) { if (!is_codec_created) {
return false; return false;
@ -778,20 +776,17 @@ bool VideoCodecTestFixtureImpl::SetUpAndInitObjects(
encoder_.get(), &decoders_, source_frame_reader_.get(), config_, encoder_.get(), &decoders_, source_frame_reader_.get(), config_,
&stats_, &encoded_frame_writers_, &stats_, &encoded_frame_writers_,
decoded_frame_writers_.empty() ? nullptr : &decoded_frame_writers_); decoded_frame_writers_.empty() ? nullptr : &decoded_frame_writers_);
}, });
RTC_FROM_HERE);
return true; return true;
} }
void VideoCodecTestFixtureImpl::ReleaseAndCloseObjects( void VideoCodecTestFixtureImpl::ReleaseAndCloseObjects(
TaskQueueForTest* task_queue) { TaskQueueForTest* task_queue) {
task_queue->SendTask( task_queue->SendTask([this]() {
[this]() { processor_.reset();
processor_.reset(); // The VideoProcessor must be destroyed before the codecs.
// The VideoProcessor must be destroyed before the codecs. DestroyEncoderAndDecoder();
DestroyEncoderAndDecoder(); });
},
RTC_FROM_HERE);
source_frame_reader_->Close(); source_frame_reader_->Close();
@ -810,15 +805,13 @@ std::string VideoCodecTestFixtureImpl::GetCodecName(
TaskQueueForTest* task_queue, TaskQueueForTest* task_queue,
bool is_encoder) const { bool is_encoder) const {
std::string codec_name; std::string codec_name;
task_queue->SendTask( task_queue->SendTask([this, is_encoder, &codec_name] {
[this, is_encoder, &codec_name] { if (is_encoder) {
if (is_encoder) { codec_name = encoder_->GetEncoderInfo().implementation_name;
codec_name = encoder_->GetEncoderInfo().implementation_name; } else {
} else { codec_name = decoders_.at(0)->ImplementationName();
codec_name = decoders_.at(0)->ImplementationName(); }
} });
},
RTC_FROM_HERE);
return codec_name; return codec_name;
} }

28
modules/video_coding/codecs/test/videoprocessor_unittest.cc
View file

@ -59,12 +59,11 @@ class VideoProcessorTest : public ::testing::Test {
video_processor_ = std::make_unique<VideoProcessor>( video_processor_ = std::make_unique<VideoProcessor>(
&encoder_mock_, &decoders_, &frame_reader_mock_, config_, &stats_, &encoder_mock_, &decoders_, &frame_reader_mock_, config_, &stats_,
&encoded_frame_writers_, /*decoded_frame_writers=*/nullptr); &encoded_frame_writers_, /*decoded_frame_writers=*/nullptr);
}, });
RTC_FROM_HERE);
} }
~VideoProcessorTest() { ~VideoProcessorTest() {
q_.SendTask([this] { video_processor_.reset(); }, RTC_FROM_HERE); q_.SendTask([this] { video_processor_.reset(); });
} }
void ExpectInit() { void ExpectInit() {
@ -106,8 +105,7 @@ TEST_F(VideoProcessorTest, ProcessFrames_FixedFramerate) {
SetRates(Field(&VideoEncoder::RateControlParameters::framerate_fps, SetRates(Field(&VideoEncoder::RateControlParameters::framerate_fps,
static_cast<double>(kFramerateFps)))) static_cast<double>(kFramerateFps))))
.Times(1); .Times(1);
q_.SendTask([=] { video_processor_->SetRates(kBitrateKbps, kFramerateFps); }, q_.SendTask([=] { video_processor_->SetRates(kBitrateKbps, kFramerateFps); });
RTC_FROM_HERE);
EXPECT_CALL(frame_reader_mock_, ReadFrame()) EXPECT_CALL(frame_reader_mock_, ReadFrame())
.WillRepeatedly(Return(I420Buffer::Create(kWidth, kHeight))); .WillRepeatedly(Return(I420Buffer::Create(kWidth, kHeight)));
@ -115,13 +113,13 @@ TEST_F(VideoProcessorTest, ProcessFrames_FixedFramerate) {
encoder_mock_, encoder_mock_,
Encode(Property(&VideoFrame::timestamp, 1 * 90000 / kFramerateFps), _)) Encode(Property(&VideoFrame::timestamp, 1 * 90000 / kFramerateFps), _))
.Times(1); .Times(1);
q_.SendTask([this] { video_processor_->ProcessFrame(); }, RTC_FROM_HERE); q_.SendTask([this] { video_processor_->ProcessFrame(); });
EXPECT_CALL( EXPECT_CALL(
encoder_mock_, encoder_mock_,
Encode(Property(&VideoFrame::timestamp, 2 * 90000 / kFramerateFps), _)) Encode(Property(&VideoFrame::timestamp, 2 * 90000 / kFramerateFps), _))
.Times(1); .Times(1);
q_.SendTask([this] { video_processor_->ProcessFrame(); }, RTC_FROM_HERE); q_.SendTask([this] { video_processor_->ProcessFrame(); });
ExpectRelease(); ExpectRelease();
} }
@ -136,15 +134,14 @@ TEST_F(VideoProcessorTest, ProcessFrames_VariableFramerate) {
static_cast<double>(kStartFramerateFps)))) static_cast<double>(kStartFramerateFps))))
.Times(1); .Times(1);
q_.SendTask( q_.SendTask(
[=] { video_processor_->SetRates(kBitrateKbps, kStartFramerateFps); }, [=] { video_processor_->SetRates(kBitrateKbps, kStartFramerateFps); });
RTC_FROM_HERE);
EXPECT_CALL(frame_reader_mock_, ReadFrame()) EXPECT_CALL(frame_reader_mock_, ReadFrame())
.WillRepeatedly(Return(I420Buffer::Create(kWidth, kHeight))); .WillRepeatedly(Return(I420Buffer::Create(kWidth, kHeight)));
EXPECT_CALL(encoder_mock_, EXPECT_CALL(encoder_mock_,
Encode(Property(&VideoFrame::timestamp, kStartTimestamp), _)) Encode(Property(&VideoFrame::timestamp, kStartTimestamp), _))
.Times(1); .Times(1);
q_.SendTask([this] { video_processor_->ProcessFrame(); }, RTC_FROM_HERE); q_.SendTask([this] { video_processor_->ProcessFrame(); });
const int kNewFramerateFps = 13; const int kNewFramerateFps = 13;
EXPECT_CALL( EXPECT_CALL(
@ -153,15 +150,14 @@ TEST_F(VideoProcessorTest, ProcessFrames_VariableFramerate) {
static_cast<double>(kNewFramerateFps)))) static_cast<double>(kNewFramerateFps))))
.Times(1); .Times(1);
q_.SendTask( q_.SendTask(
[=] { video_processor_->SetRates(kBitrateKbps, kNewFramerateFps); }, [=] { video_processor_->SetRates(kBitrateKbps, kNewFramerateFps); });
RTC_FROM_HERE);
EXPECT_CALL(encoder_mock_, EXPECT_CALL(encoder_mock_,
Encode(Property(&VideoFrame::timestamp, Encode(Property(&VideoFrame::timestamp,
kStartTimestamp + 90000 / kNewFramerateFps), kStartTimestamp + 90000 / kNewFramerateFps),
_)) _))
.Times(1); .Times(1);
q_.SendTask([this] { video_processor_->ProcessFrame(); }, RTC_FROM_HERE); q_.SendTask([this] { video_processor_->ProcessFrame(); });
ExpectRelease(); ExpectRelease();
} }
@ -180,8 +176,7 @@ TEST_F(VideoProcessorTest, SetRates) {
Field(&VideoEncoder::RateControlParameters::framerate_fps, Field(&VideoEncoder::RateControlParameters::framerate_fps,
static_cast<double>(kFramerateFps))))) static_cast<double>(kFramerateFps)))))
.Times(1); .Times(1);
q_.SendTask([=] { video_processor_->SetRates(kBitrateKbps, kFramerateFps); }, q_.SendTask([=] { video_processor_->SetRates(kBitrateKbps, kFramerateFps); });
RTC_FROM_HERE);
const uint32_t kNewBitrateKbps = 456; const uint32_t kNewBitrateKbps = 456;
const int kNewFramerateFps = 34; const int kNewFramerateFps = 34;
@ -196,8 +191,7 @@ TEST_F(VideoProcessorTest, SetRates) {
static_cast<double>(kNewFramerateFps))))) static_cast<double>(kNewFramerateFps)))))
.Times(1); .Times(1);
q_.SendTask( q_.SendTask(
[=] { video_processor_->SetRates(kNewBitrateKbps, kNewFramerateFps); }, [=] { video_processor_->SetRates(kNewBitrateKbps, kNewFramerateFps); });
RTC_FROM_HERE);
ExpectRelease(); ExpectRelease();
} }

9
modules/video_coding/utility/bandwidth_quality_scaler_unittest.cc
View file

@ -106,13 +106,11 @@ class BandwidthQualityScalerTest
GetDefaultSinglecastBitrateLimitsWhenQpIsUntrusted()); GetDefaultSinglecastBitrateLimitsWhenQpIsUntrusted());
// Only for testing. Set first_timestamp_ in RateStatistics to 0. // Only for testing. Set first_timestamp_ in RateStatistics to 0.
bandwidth_quality_scaler_->ReportEncodeInfo(0, 0, 0, 0); bandwidth_quality_scaler_->ReportEncodeInfo(0, 0, 0, 0);
}, });
RTC_FROM_HERE);
} }
~BandwidthQualityScalerTest() { ~BandwidthQualityScalerTest() {
task_queue_.SendTask([this] { bandwidth_quality_scaler_ = nullptr; }, task_queue_.SendTask([this] { bandwidth_quality_scaler_ = nullptr; });
RTC_FROM_HERE);
} }
int GetFrameSizeBytes( int GetFrameSizeBytes(
@ -180,8 +178,7 @@ class BandwidthQualityScalerTest
config.actual_width, config.actual_height); config.actual_width, config.actual_height);
} }
} }
}, });
RTC_FROM_HERE);
} }
test::ScopedFieldTrials scoped_field_trial_; test::ScopedFieldTrials scoped_field_trial_;

128
modules/video_coding/utility/quality_scaler_unittest.cc
View file

@ -75,12 +75,11 @@ class QualityScalerTest : public ::testing::Test,
[this] { [this] {
qs_ = std::unique_ptr<QualityScaler>(new QualityScalerUnderTest( qs_ = std::unique_ptr<QualityScaler>(new QualityScalerUnderTest(
handler_.get(), VideoEncoder::QpThresholds(kLowQp, kHighQp))); handler_.get(), VideoEncoder::QpThresholds(kLowQp, kHighQp)));
}, });
RTC_FROM_HERE);
} }
~QualityScalerTest() override { ~QualityScalerTest() override {
task_queue_.SendTask([this] { qs_ = nullptr; }, RTC_FROM_HERE); task_queue_.SendTask([this] { qs_ = nullptr; });
} }
void TriggerScale(ScaleDirection scale_direction) { void TriggerScale(ScaleDirection scale_direction) {
@ -119,52 +118,46 @@ INSTANTIATE_TEST_SUITE_P(
"WebRTC-Video-QualityScaling/Disabled/")); "WebRTC-Video-QualityScaling/Disabled/"));
TEST_P(QualityScalerTest, DownscalesAfterContinuousFramedrop) { TEST_P(QualityScalerTest, DownscalesAfterContinuousFramedrop) {
task_queue_.SendTask([this] { TriggerScale(kScaleDown); }, RTC_FROM_HERE); task_queue_.SendTask([this] { TriggerScale(kScaleDown); });
EXPECT_TRUE(handler_->event.Wait(kDefaultTimeoutMs)); EXPECT_TRUE(handler_->event.Wait(kDefaultTimeoutMs));
EXPECT_EQ(1, handler_->adapt_down_events_); EXPECT_EQ(1, handler_->adapt_down_events_);
EXPECT_EQ(0, handler_->adapt_up_events_); EXPECT_EQ(0, handler_->adapt_up_events_);
} }
TEST_P(QualityScalerTest, KeepsScaleAtHighQp) { TEST_P(QualityScalerTest, KeepsScaleAtHighQp) {
task_queue_.SendTask([this] { TriggerScale(kKeepScaleAtHighQp); }, task_queue_.SendTask([this] { TriggerScale(kKeepScaleAtHighQp); });
RTC_FROM_HERE);
EXPECT_FALSE(handler_->event.Wait(kDefaultTimeoutMs)); EXPECT_FALSE(handler_->event.Wait(kDefaultTimeoutMs));
EXPECT_EQ(0, handler_->adapt_down_events_); EXPECT_EQ(0, handler_->adapt_down_events_);
EXPECT_EQ(0, handler_->adapt_up_events_); EXPECT_EQ(0, handler_->adapt_up_events_);
} }
TEST_P(QualityScalerTest, DownscalesAboveHighQp) { TEST_P(QualityScalerTest, DownscalesAboveHighQp) {
task_queue_.SendTask([this] { TriggerScale(kScaleDownAboveHighQp); }, task_queue_.SendTask([this] { TriggerScale(kScaleDownAboveHighQp); });
RTC_FROM_HERE);
EXPECT_TRUE(handler_->event.Wait(kDefaultTimeoutMs)); EXPECT_TRUE(handler_->event.Wait(kDefaultTimeoutMs));
EXPECT_EQ(1, handler_->adapt_down_events_); EXPECT_EQ(1, handler_->adapt_down_events_);
EXPECT_EQ(0, handler_->adapt_up_events_); EXPECT_EQ(0, handler_->adapt_up_events_);
} }
TEST_P(QualityScalerTest, DownscalesAfterTwoThirdsFramedrop) { TEST_P(QualityScalerTest, DownscalesAfterTwoThirdsFramedrop) {
task_queue_.SendTask( task_queue_.SendTask([this] {
[this] { for (int i = 0; i < kFramerate * 5; ++i) {
for (int i = 0; i < kFramerate * 5; ++i) { qs_->ReportDroppedFrameByMediaOpt();
qs_->ReportDroppedFrameByMediaOpt(); qs_->ReportDroppedFrameByMediaOpt();
qs_->ReportDroppedFrameByMediaOpt(); qs_->ReportQp(kHighQp, 0);
qs_->ReportQp(kHighQp, 0); }
} });
},
RTC_FROM_HERE);
EXPECT_TRUE(handler_->event.Wait(kDefaultTimeoutMs)); EXPECT_TRUE(handler_->event.Wait(kDefaultTimeoutMs));
EXPECT_EQ(1, handler_->adapt_down_events_); EXPECT_EQ(1, handler_->adapt_down_events_);
EXPECT_EQ(0, handler_->adapt_up_events_); EXPECT_EQ(0, handler_->adapt_up_events_);
} }
TEST_P(QualityScalerTest, DoesNotDownscaleAfterHalfFramedrop) { TEST_P(QualityScalerTest, DoesNotDownscaleAfterHalfFramedrop) {
task_queue_.SendTask( task_queue_.SendTask([this] {
[this] { for (int i = 0; i < kFramerate * 5; ++i) {
for (int i = 0; i < kFramerate * 5; ++i) { qs_->ReportDroppedFrameByMediaOpt();
qs_->ReportDroppedFrameByMediaOpt(); qs_->ReportQp(kHighQp, 0);
qs_->ReportQp(kHighQp, 0); }
} });
},
RTC_FROM_HERE);
EXPECT_FALSE(handler_->event.Wait(kDefaultTimeoutMs)); EXPECT_FALSE(handler_->event.Wait(kDefaultTimeoutMs));
EXPECT_EQ(0, handler_->adapt_down_events_); EXPECT_EQ(0, handler_->adapt_down_events_);
EXPECT_EQ(0, handler_->adapt_up_events_); EXPECT_EQ(0, handler_->adapt_up_events_);
@ -173,98 +166,85 @@ TEST_P(QualityScalerTest, DoesNotDownscaleAfterHalfFramedrop) {
TEST_P(QualityScalerTest, DownscalesAfterTwoThirdsIfFieldTrialEnabled) { TEST_P(QualityScalerTest, DownscalesAfterTwoThirdsIfFieldTrialEnabled) {
const bool kDownScaleExpected = const bool kDownScaleExpected =
GetParam().find("Enabled") != std::string::npos; GetParam().find("Enabled") != std::string::npos;
task_queue_.SendTask( task_queue_.SendTask([this] {
[this] { for (int i = 0; i < kFramerate * 5; ++i) {
for (int i = 0; i < kFramerate * 5; ++i) { qs_->ReportDroppedFrameByMediaOpt();
qs_->ReportDroppedFrameByMediaOpt(); qs_->ReportDroppedFrameByEncoder();
qs_->ReportDroppedFrameByEncoder(); qs_->ReportQp(kHighQp, 0);
qs_->ReportQp(kHighQp, 0); }
} });
},
RTC_FROM_HERE);
EXPECT_EQ(kDownScaleExpected, handler_->event.Wait(kDefaultTimeoutMs)); EXPECT_EQ(kDownScaleExpected, handler_->event.Wait(kDefaultTimeoutMs));
EXPECT_EQ(kDownScaleExpected ? 1 : 0, handler_->adapt_down_events_); EXPECT_EQ(kDownScaleExpected ? 1 : 0, handler_->adapt_down_events_);
EXPECT_EQ(0, handler_->adapt_up_events_); EXPECT_EQ(0, handler_->adapt_up_events_);
} }
TEST_P(QualityScalerTest, KeepsScaleOnNormalQp) { TEST_P(QualityScalerTest, KeepsScaleOnNormalQp) {
task_queue_.SendTask([this] { TriggerScale(kKeepScaleAboveLowQp); }, task_queue_.SendTask([this] { TriggerScale(kKeepScaleAboveLowQp); });
RTC_FROM_HERE);
EXPECT_FALSE(handler_->event.Wait(kDefaultTimeoutMs)); EXPECT_FALSE(handler_->event.Wait(kDefaultTimeoutMs));
EXPECT_EQ(0, handler_->adapt_down_events_); EXPECT_EQ(0, handler_->adapt_down_events_);
EXPECT_EQ(0, handler_->adapt_up_events_); EXPECT_EQ(0, handler_->adapt_up_events_);
} }
TEST_P(QualityScalerTest, UpscalesAfterLowQp) { TEST_P(QualityScalerTest, UpscalesAfterLowQp) {
task_queue_.SendTask([this] { TriggerScale(kScaleUp); }, RTC_FROM_HERE); task_queue_.SendTask([this] { TriggerScale(kScaleUp); });
EXPECT_TRUE(handler_->event.Wait(kDefaultTimeoutMs)); EXPECT_TRUE(handler_->event.Wait(kDefaultTimeoutMs));
EXPECT_EQ(0, handler_->adapt_down_events_); EXPECT_EQ(0, handler_->adapt_down_events_);
EXPECT_EQ(1, handler_->adapt_up_events_); EXPECT_EQ(1, handler_->adapt_up_events_);
} }
TEST_P(QualityScalerTest, ScalesDownAndBackUp) { TEST_P(QualityScalerTest, ScalesDownAndBackUp) {
task_queue_.SendTask([this] { TriggerScale(kScaleDown); }, RTC_FROM_HERE); task_queue_.SendTask([this] { TriggerScale(kScaleDown); });
EXPECT_TRUE(handler_->event.Wait(kDefaultTimeoutMs)); EXPECT_TRUE(handler_->event.Wait(kDefaultTimeoutMs));
EXPECT_EQ(1, handler_->adapt_down_events_); EXPECT_EQ(1, handler_->adapt_down_events_);
EXPECT_EQ(0, handler_->adapt_up_events_); EXPECT_EQ(0, handler_->adapt_up_events_);
task_queue_.SendTask([this] { TriggerScale(kScaleUp); }, RTC_FROM_HERE); task_queue_.SendTask([this] { TriggerScale(kScaleUp); });
EXPECT_TRUE(handler_->event.Wait(kDefaultTimeoutMs)); EXPECT_TRUE(handler_->event.Wait(kDefaultTimeoutMs));
EXPECT_EQ(1, handler_->adapt_down_events_); EXPECT_EQ(1, handler_->adapt_down_events_);
EXPECT_EQ(1, handler_->adapt_up_events_); EXPECT_EQ(1, handler_->adapt_up_events_);
} }
TEST_P(QualityScalerTest, DoesNotScaleUntilEnoughFramesObserved) { TEST_P(QualityScalerTest, DoesNotScaleUntilEnoughFramesObserved) {
task_queue_.SendTask( task_queue_.SendTask([this] {
[this] { // Not enough frames to make a decision.
// Not enough frames to make a decision. for (int i = 0; i < kMinFramesNeededToScale - 1; ++i) {
for (int i = 0; i < kMinFramesNeededToScale - 1; ++i) { qs_->ReportQp(kLowQp, 0);
qs_->ReportQp(kLowQp, 0); }
} });
},
RTC_FROM_HERE);
EXPECT_FALSE(handler_->event.Wait(kDefaultTimeoutMs)); EXPECT_FALSE(handler_->event.Wait(kDefaultTimeoutMs));
task_queue_.SendTask( task_queue_.SendTask([this] {
[this] { // Send 1 more. Enough frames observed, should result in an adapt
// Send 1 more. Enough frames observed, should result in an adapt // request.
// request. qs_->ReportQp(kLowQp, 0);
qs_->ReportQp(kLowQp, 0); });
},
RTC_FROM_HERE);
EXPECT_TRUE(handler_->event.Wait(kDefaultTimeoutMs)); EXPECT_TRUE(handler_->event.Wait(kDefaultTimeoutMs));
EXPECT_EQ(0, handler_->adapt_down_events_); EXPECT_EQ(0, handler_->adapt_down_events_);
EXPECT_EQ(1, handler_->adapt_up_events_); EXPECT_EQ(1, handler_->adapt_up_events_);
// Samples should be cleared after an adapt request. // Samples should be cleared after an adapt request.
task_queue_.SendTask( task_queue_.SendTask([this] {
[this] { // Not enough frames to make a decision.
// Not enough frames to make a decision. qs_->ReportQp(kLowQp, 0);
qs_->ReportQp(kLowQp, 0); });
},
RTC_FROM_HERE);
EXPECT_FALSE(handler_->event.Wait(kDefaultTimeoutMs)); EXPECT_FALSE(handler_->event.Wait(kDefaultTimeoutMs));
EXPECT_EQ(0, handler_->adapt_down_events_); EXPECT_EQ(0, handler_->adapt_down_events_);
EXPECT_EQ(1, handler_->adapt_up_events_); EXPECT_EQ(1, handler_->adapt_up_events_);
} }
TEST_P(QualityScalerTest, ScalesDownAndBackUpWithMinFramesNeeded) { TEST_P(QualityScalerTest, ScalesDownAndBackUpWithMinFramesNeeded) {
task_queue_.SendTask( task_queue_.SendTask([this] {
[this] { for (int i = 0; i < kMinFramesNeededToScale; ++i) {
for (int i = 0; i < kMinFramesNeededToScale; ++i) { qs_->ReportQp(kHighQp + 1, 0);
qs_->ReportQp(kHighQp + 1, 0); }
} });
},
RTC_FROM_HERE);
EXPECT_TRUE(handler_->event.Wait(kDefaultTimeoutMs)); EXPECT_TRUE(handler_->event.Wait(kDefaultTimeoutMs));
EXPECT_EQ(1, handler_->adapt_down_events_); EXPECT_EQ(1, handler_->adapt_down_events_);
EXPECT_EQ(0, handler_->adapt_up_events_); EXPECT_EQ(0, handler_->adapt_up_events_);
// Samples cleared. // Samples cleared.
task_queue_.SendTask( task_queue_.SendTask([this] {
[this] { for (int i = 0; i < kMinFramesNeededToScale; ++i) {
for (int i = 0; i < kMinFramesNeededToScale; ++i) { qs_->ReportQp(kLowQp, 0);
qs_->ReportQp(kLowQp, 0); }
} });
},
RTC_FROM_HERE);
EXPECT_TRUE(handler_->event.Wait(kDefaultTimeoutMs)); EXPECT_TRUE(handler_->event.Wait(kDefaultTimeoutMs));
EXPECT_EQ(1, handler_->adapt_down_events_); EXPECT_EQ(1, handler_->adapt_down_events_);
EXPECT_EQ(1, handler_->adapt_up_events_); EXPECT_EQ(1, handler_->adapt_up_events_);

1
rtc_base/BUILD.gn
View file

@ -1415,7 +1415,6 @@ rtc_library("task_queue_for_test") {
] ]
deps = [ deps = [
":checks", ":checks",
":location",
":macromagic", ":macromagic",
":rtc_event", ":rtc_event",
":rtc_task_queue", ":rtc_task_queue",

15
rtc_base/task_queue_for_test.h
View file

@ -19,23 +19,20 @@
#include "api/task_queue/task_queue_base.h" #include "api/task_queue/task_queue_base.h"
#include "rtc_base/checks.h" #include "rtc_base/checks.h"
#include "rtc_base/event.h" #include "rtc_base/event.h"
#include "rtc_base/location.h"
#include "rtc_base/task_queue.h" #include "rtc_base/task_queue.h"
#include "rtc_base/thread_annotations.h" #include "rtc_base/thread_annotations.h"
namespace webrtc { namespace webrtc {
inline void SendTask(rtc::Location loc, inline void SendTask(TaskQueueBase* task_queue,
TaskQueueBase* task_queue,
rtc::FunctionView<void()> task) { rtc::FunctionView<void()> task) {
RTC_CHECK(!task_queue->IsCurrent()) RTC_CHECK(!task_queue->IsCurrent())
<< "Called SendTask to a queue from the same queue at " << loc.ToString(); << "Called SendTask to a queue from the same queue";
rtc::Event event; rtc::Event event;
absl::Cleanup cleanup = [&event] { event.Set(); }; absl::Cleanup cleanup = [&event] { event.Set(); };
task_queue->PostTask([task, cleanup = std::move(cleanup)] { task(); }); task_queue->PostTask([task, cleanup = std::move(cleanup)] { task(); });
RTC_CHECK(event.Wait(/*give_up_after_ms=*/rtc::Event::kForever, RTC_CHECK(event.Wait(/*give_up_after_ms=*/rtc::Event::kForever,
/*warn_after_ms=*/10'000)) /*warn_after_ms=*/10'000));
<< "Waited too long at " << loc.ToString();
} }
class RTC_LOCKABLE TaskQueueForTest : public rtc::TaskQueue { class RTC_LOCKABLE TaskQueueForTest : public rtc::TaskQueue {
@ -49,8 +46,8 @@ class RTC_LOCKABLE TaskQueueForTest : public rtc::TaskQueue {
// A convenience, test-only method that blocks the current thread while // A convenience, test-only method that blocks the current thread while
// a task executes on the task queue. // a task executes on the task queue.
void SendTask(rtc::FunctionView<void()> task, rtc::Location loc) { void SendTask(rtc::FunctionView<void()> task) {
::webrtc::SendTask(loc, Get(), task); ::webrtc::SendTask(Get(), task);
} }
// Wait for the completion of all tasks posted prior to the // Wait for the completion of all tasks posted prior to the
@ -58,7 +55,7 @@ class RTC_LOCKABLE TaskQueueForTest : public rtc::TaskQueue {
void WaitForPreviouslyPostedTasks() { void WaitForPreviouslyPostedTasks() {
// Post an empty task on the queue and wait for it to finish, to ensure // Post an empty task on the queue and wait for it to finish, to ensure
// that all already posted tasks on the queue get executed. // that all already posted tasks on the queue get executed.
SendTask([]() {}, RTC_FROM_HERE); SendTask([]() {});
} }
}; };

14
rtc_base/weak_ptr_unittest.cc
View file

@ -204,7 +204,7 @@ template <class T>
std::unique_ptr<T> NewObjectCreatedOnTaskQueue() { std::unique_ptr<T> NewObjectCreatedOnTaskQueue() {
std::unique_ptr<T> obj; std::unique_ptr<T> obj;
webrtc::TaskQueueForTest queue("NewObjectCreatedOnTaskQueue"); webrtc::TaskQueueForTest queue("NewObjectCreatedOnTaskQueue");
queue.SendTask([&] { obj = std::make_unique<T>(); }, RTC_FROM_HERE); queue.SendTask([&] { obj = std::make_unique<T>(); });
return obj; return obj;
} }
@ -226,13 +226,11 @@ TEST(WeakPtrTest, WeakPtrInitiateAndUseOnDifferentThreads) {
// Create weak ptr on main thread // Create weak ptr on main thread
WeakPtr<Target> weak_ptr = target->factory.GetWeakPtr(); WeakPtr<Target> weak_ptr = target->factory.GetWeakPtr();
webrtc::TaskQueueForTest queue("queue"); webrtc::TaskQueueForTest queue("queue");
queue.SendTask( queue.SendTask([&] {
[&] { // Dereference and invalide weak_ptr on another thread.
// Dereference and invalide weak_ptr on another thread. EXPECT_EQ(weak_ptr.get(), target.get());
EXPECT_EQ(weak_ptr.get(), target.get()); target.reset();
target.reset(); });
},
RTC_FROM_HERE);
} }
} // namespace rtc } // namespace rtc

4
test/call_test.cc
View file

@ -87,7 +87,7 @@ void CallTest::RegisterRtpExtension(const RtpExtension& extension) {
} }
void CallTest::RunBaseTest(BaseTest* test) { void CallTest::RunBaseTest(BaseTest* test) {
SendTask(RTC_FROM_HERE, task_queue(), [this, test]() { SendTask(task_queue(), [this, test]() {
num_video_streams_ = test->GetNumVideoStreams(); num_video_streams_ = test->GetNumVideoStreams();
num_audio_streams_ = test->GetNumAudioStreams(); num_audio_streams_ = test->GetNumAudioStreams();
num_flexfec_streams_ = test->GetNumFlexfecStreams(); num_flexfec_streams_ = test->GetNumFlexfecStreams();
@ -187,7 +187,7 @@ void CallTest::RunBaseTest(BaseTest* test) {
test->PerformTest(); test->PerformTest();
SendTask(RTC_FROM_HERE, task_queue(), [this, test]() { SendTask(task_queue(), [this, test]() {
Stop(); Stop();
test->OnStreamsStopped(); test->OnStreamsStopped();
DestroyStreams(); DestroyStreams();

37
test/network/network_emulation_manager.cc
View file

@ -188,27 +188,24 @@ EmulatedRoute* NetworkEmulationManagerImpl::CreateDefaultRoute(
void NetworkEmulationManagerImpl::ClearRoute(EmulatedRoute* route) { void NetworkEmulationManagerImpl::ClearRoute(EmulatedRoute* route) {
RTC_CHECK(route->active) << "Route already cleared"; RTC_CHECK(route->active) << "Route already cleared";
task_queue_.SendTask( task_queue_.SendTask([route]() {
[route]() { // Remove receiver from intermediate nodes.
// Remove receiver from intermediate nodes. for (auto* node : route->via_nodes) {
for (auto* node : route->via_nodes) { if (route->is_default) {
if (route->is_default) { node->router()->RemoveDefaultReceiver();
node->router()->RemoveDefaultReceiver(); } else {
} else { node->router()->RemoveReceiver(route->to->GetPeerLocalAddress());
node->router()->RemoveReceiver(route->to->GetPeerLocalAddress()); }
} }
} // Remove destination endpoint from source endpoint's router.
// Remove destination endpoint from source endpoint's router. if (route->is_default) {
if (route->is_default) { route->from->router()->RemoveDefaultReceiver();
route->from->router()->RemoveDefaultReceiver(); } else {
} else { route->from->router()->RemoveReceiver(route->to->GetPeerLocalAddress());
route->from->router()->RemoveReceiver( }
route->to->GetPeerLocalAddress());
}
route->active = false; route->active = false;
}, });
RTC_FROM_HERE);
} }
TcpMessageRoute* NetworkEmulationManagerImpl::CreateTcpRoute( TcpMessageRoute* NetworkEmulationManagerImpl::CreateTcpRoute(

1
test/pc/e2e/BUILD.gn
View file

@ -355,7 +355,6 @@ if (!build_with_chromium) {
"../../../api/units:timestamp", "../../../api/units:timestamp",
"../../../rtc_base:checks", "../../../rtc_base:checks",
"../../../rtc_base:criticalsection", "../../../rtc_base:criticalsection",
"../../../rtc_base:location",
"../../../rtc_base:logging", "../../../rtc_base:logging",
"../../../rtc_base:task_queue_for_test", "../../../rtc_base:task_queue_for_test",
"../../../rtc_base/synchronization:mutex", "../../../rtc_base/synchronization:mutex",

10
test/pc/e2e/peer_connection_quality_test.cc
View file

@ -379,12 +379,10 @@ void PeerConnectionE2EQualityTest::Run(RunParams run_params) {
// There is no guarantee, that last stats collection will happen at the end // There is no guarantee, that last stats collection will happen at the end
// of the call, so we force it after executor, which is among others is doing // of the call, so we force it after executor, which is among others is doing
// stats collection, was stopped. // stats collection, was stopped.
task_queue_->SendTask( task_queue_->SendTask([&stats_poller]() {
[&stats_poller]() { // Get final end-of-call stats.
// Get final end-of-call stats. stats_poller.PollStatsAndNotifyObservers();
stats_poller.PollStatsAndNotifyObservers(); });
},
RTC_FROM_HERE);
// We need to detach AEC dumping from peers, because dump uses `task_queue_` // We need to detach AEC dumping from peers, because dump uses `task_queue_`
// inside. // inside.
alice_->DetachAecDump(); alice_->DetachAecDump();

3
test/pc/e2e/test_activities_executor.cc
View file

@ -15,7 +15,6 @@
#include "absl/memory/memory.h" #include "absl/memory/memory.h"
#include "rtc_base/checks.h" #include "rtc_base/checks.h"
#include "rtc_base/location.h"
#include "rtc_base/logging.h" #include "rtc_base/logging.h"
#include "rtc_base/task_queue_for_test.h" #include "rtc_base/task_queue_for_test.h"
@ -38,7 +37,7 @@ void TestActivitiesExecutor::Stop() {
// Already stopped or not started. // Already stopped or not started.
return; return;
} }
SendTask(RTC_FROM_HERE, task_queue_, [this]() { SendTask(task_queue_, [this]() {
MutexLock lock(&lock_); MutexLock lock(&lock_);
for (auto& handle : repeating_task_handles_) { for (auto& handle : repeating_task_handles_) {
handle.Stop(); handle.Stop();

2
test/scenario/call_client.cc
View file

@ -334,7 +334,7 @@ uint32_t CallClient::GetNextRtxSsrc() {
} }
void CallClient::SendTask(std::function<void()> task) { void CallClient::SendTask(std::function<void()> task) {
task_queue_.SendTask(std::move(task), RTC_FROM_HERE); task_queue_.SendTask(std::move(task));
} }
int16_t CallClient::Bind(EmulatedEndpoint* endpoint) { int16_t CallClient::Bind(EmulatedEndpoint* endpoint) {

2
test/scenario/video_frame_matcher.cc
View file

@ -29,7 +29,7 @@ VideoFrameMatcher::VideoFrameMatcher(
task_queue_("VideoAnalyzer") {} task_queue_("VideoAnalyzer") {}
VideoFrameMatcher::~VideoFrameMatcher() { VideoFrameMatcher::~VideoFrameMatcher() {
task_queue_.SendTask([this] { Finalize(); }, RTC_FROM_HERE); task_queue_.SendTask([this] { Finalize(); });
} }
void VideoFrameMatcher::RegisterLayer(int layer_id) { void VideoFrameMatcher::RegisterLayer(int layer_id) {

1
video/BUILD.gn
View file

@ -868,7 +868,6 @@ if (rtc_include_tests) {
"../rtc_base:byte_buffer", "../rtc_base:byte_buffer",
"../rtc_base:checks", "../rtc_base:checks",
"../rtc_base:gunit_helpers", "../rtc_base:gunit_helpers",
"../rtc_base:location",
"../rtc_base:logging", "../rtc_base:logging",
"../rtc_base:macromagic", "../rtc_base:macromagic",
"../rtc_base:platform_thread", "../rtc_base:platform_thread",

18
video/adaptation/overuse_frame_detector_unittest.cc
View file

@ -432,12 +432,9 @@ TEST_F(OveruseFrameDetectorTest, UpdatesExistingSamples) {
TEST_F(OveruseFrameDetectorTest, RunOnTqNormalUsage) { TEST_F(OveruseFrameDetectorTest, RunOnTqNormalUsage) {
TaskQueueForTest queue("OveruseFrameDetectorTestQueue"); TaskQueueForTest queue("OveruseFrameDetectorTestQueue");
queue.SendTask( queue.SendTask([&] {
[&] { overuse_detector_->StartCheckForOveruse(queue.Get(), options_, observer_);
overuse_detector_->StartCheckForOveruse(queue.Get(), options_, });
observer_);
},
RTC_FROM_HERE);
rtc::Event event; rtc::Event event;
// Expect NormalUsage(). When called, stop the `overuse_detector_` and then // Expect NormalUsage(). When called, stop the `overuse_detector_` and then
@ -917,12 +914,9 @@ TEST_F(OveruseFrameDetectorTest2, UpdatesExistingSamples) {
TEST_F(OveruseFrameDetectorTest2, RunOnTqNormalUsage) { TEST_F(OveruseFrameDetectorTest2, RunOnTqNormalUsage) {
TaskQueueForTest queue("OveruseFrameDetectorTestQueue"); TaskQueueForTest queue("OveruseFrameDetectorTestQueue");
queue.SendTask( queue.SendTask([&] {
[&] { overuse_detector_->StartCheckForOveruse(queue.Get(), options_, observer_);
overuse_detector_->StartCheckForOveruse(queue.Get(), options_, });
observer_);
},
RTC_FROM_HERE);
rtc::Event event; rtc::Event event;
// Expect NormalUsage(). When called, stop the `overuse_detector_` and then // Expect NormalUsage(). When called, stop the `overuse_detector_` and then

4
video/end_to_end_tests/bandwidth_tests.cc
View file

@ -95,7 +95,7 @@ class BandwidthStatsTest : public test::EndToEndTest {
~BandwidthStatsTest() override { ~BandwidthStatsTest() override {
// Block until all already posted tasks run to avoid races when such task // Block until all already posted tasks run to avoid races when such task
// accesses `this`. // accesses `this`.
SendTask(RTC_FROM_HERE, task_queue_, [] {}); SendTask(task_queue_, [] {});
} }
void ModifyVideoConfigs( void ModifyVideoConfigs(
@ -358,7 +358,7 @@ TEST_F(BandwidthEndToEndTest, ReportsSetEncoderRates) {
ASSERT_TRUE(Wait()) ASSERT_TRUE(Wait())
<< "Timed out while waiting for encoder SetRates() call."; << "Timed out while waiting for encoder SetRates() call.";
SendTask(RTC_FROM_HERE, task_queue_, [this]() { SendTask(task_queue_, [this]() {
WaitForEncoderTargetBitrateMatchStats(); WaitForEncoderTargetBitrateMatchStats();
send_stream_->Stop(); send_stream_->Stop();
WaitForStatsReportZeroTargetBitrate(); WaitForStatsReportZeroTargetBitrate();

40
video/end_to_end_tests/call_operation_tests.cc
View file

@ -98,9 +98,8 @@ TEST_F(CallOperationEndToEndTest, RendersSingleDelayedFrame) {
std::unique_ptr<test::DirectTransport> receiver_transport; std::unique_ptr<test::DirectTransport> receiver_transport;
SendTask( SendTask(
RTC_FROM_HERE, task_queue(), task_queue(), [this, &renderer, &frame_forwarder, &sender_transport,
[this, &renderer, &frame_forwarder, &sender_transport, &receiver_transport]() {
&receiver_transport]() {
CreateCalls(); CreateCalls();
sender_transport = std::make_unique<test::DirectTransport>( sender_transport = std::make_unique<test::DirectTransport>(
@ -146,14 +145,13 @@ TEST_F(CallOperationEndToEndTest, RendersSingleDelayedFrame) {
EXPECT_TRUE(renderer.Wait()) EXPECT_TRUE(renderer.Wait())
<< "Timed out while waiting for the frame to render."; << "Timed out while waiting for the frame to render.";
SendTask(RTC_FROM_HERE, task_queue(), SendTask(task_queue(), [this, &sender_transport, &receiver_transport]() {
[this, &sender_transport, &receiver_transport]() { Stop();
Stop(); DestroyStreams();
DestroyStreams(); sender_transport.reset();
sender_transport.reset(); receiver_transport.reset();
receiver_transport.reset(); DestroyCalls();
DestroyCalls(); });
});
} }
TEST_F(CallOperationEndToEndTest, TransmitsFirstFrame) { TEST_F(CallOperationEndToEndTest, TransmitsFirstFrame) {
@ -173,9 +171,8 @@ TEST_F(CallOperationEndToEndTest, TransmitsFirstFrame) {
std::unique_ptr<test::DirectTransport> receiver_transport; std::unique_ptr<test::DirectTransport> receiver_transport;
SendTask( SendTask(
RTC_FROM_HERE, task_queue(), task_queue(), [this, &renderer, &frame_generator, &frame_forwarder,
[this, &renderer, &frame_generator, &frame_forwarder, &sender_transport, &sender_transport, &receiver_transport]() {
&receiver_transport]() {
CreateCalls(); CreateCalls();
sender_transport = std::make_unique<test::DirectTransport>( sender_transport = std::make_unique<test::DirectTransport>(
@ -216,14 +213,13 @@ TEST_F(CallOperationEndToEndTest, TransmitsFirstFrame) {
EXPECT_TRUE(renderer.Wait()) EXPECT_TRUE(renderer.Wait())
<< "Timed out while waiting for the frame to render."; << "Timed out while waiting for the frame to render.";
SendTask(RTC_FROM_HERE, task_queue(), SendTask(task_queue(), [this, &sender_transport, &receiver_transport]() {
[this, &sender_transport, &receiver_transport]() { Stop();
Stop(); DestroyStreams();
DestroyStreams(); sender_transport.reset();
sender_transport.reset(); receiver_transport.reset();
receiver_transport.reset(); DestroyCalls();
DestroyCalls(); });
});
} }
} // namespace webrtc } // namespace webrtc

27
video/end_to_end_tests/multi_codec_receive_tests.cc
View file

@ -129,7 +129,7 @@ class FrameObserver : public test::RtpRtcpObserver,
class MultiCodecReceiveTest : public test::CallTest { class MultiCodecReceiveTest : public test::CallTest {
public: public:
MultiCodecReceiveTest() { MultiCodecReceiveTest() {
SendTask(RTC_FROM_HERE, task_queue(), [this]() { SendTask(task_queue(), [this]() {
CreateCalls(); CreateCalls();
send_transport_.reset(new test::PacketTransport( send_transport_.reset(new test::PacketTransport(
@ -151,7 +151,7 @@ class MultiCodecReceiveTest : public test::CallTest {
} }
virtual ~MultiCodecReceiveTest() { virtual ~MultiCodecReceiveTest() {
SendTask(RTC_FROM_HERE, task_queue(), [this]() { SendTask(task_queue(), [this]() {
send_transport_.reset(); send_transport_.reset();
receive_transport_.reset(); receive_transport_.reset();
DestroyCalls(); DestroyCalls();
@ -243,7 +243,7 @@ void MultiCodecReceiveTest::RunTestWithCodecs(
return nullptr; return nullptr;
}); });
// Create and start call. // Create and start call.
SendTask(RTC_FROM_HERE, task_queue(), SendTask(task_queue(),
[this, &configs, &encoder_factory, &decoder_factory]() { [this, &configs, &encoder_factory, &decoder_factory]() {
CreateSendConfig(1, 0, 0, send_transport_.get()); CreateSendConfig(1, 0, 0, send_transport_.get());
ConfigureEncoder(configs[0], &encoder_factory); ConfigureEncoder(configs[0], &encoder_factory);
@ -261,21 +261,20 @@ void MultiCodecReceiveTest::RunTestWithCodecs(
for (size_t i = 1; i < configs.size(); ++i) { for (size_t i = 1; i < configs.size(); ++i) {
// Recreate VideoSendStream with new config (codec, temporal layers). // Recreate VideoSendStream with new config (codec, temporal layers).
SendTask( SendTask(task_queue(), [this, i, &configs, &encoder_factory]() {
RTC_FROM_HERE, task_queue(), [this, i, &configs, &encoder_factory]() { DestroyVideoSendStreams();
DestroyVideoSendStreams(); observer_.Reset(PayloadNameToPayloadType(configs[i].payload_name));
observer_.Reset(PayloadNameToPayloadType(configs[i].payload_name));
ConfigureEncoder(configs[i], &encoder_factory); ConfigureEncoder(configs[i], &encoder_factory);
CreateVideoSendStreams(); CreateVideoSendStreams();
GetVideoSendStream()->Start(); GetVideoSendStream()->Start();
CreateFrameGeneratorCapturer(kFps, kWidth / 2, kHeight / 2); CreateFrameGeneratorCapturer(kFps, kWidth / 2, kHeight / 2);
ConnectVideoSourcesToStreams(); ConnectVideoSourcesToStreams();
}); });
EXPECT_TRUE(observer_.Wait()) << "Timed out waiting for frames."; EXPECT_TRUE(observer_.Wait()) << "Timed out waiting for frames.";
} }
SendTask(RTC_FROM_HERE, task_queue(), [this]() { SendTask(task_queue(), [this]() {
Stop(); Stop();
DestroyStreams(); DestroyStreams();
}); });

4
video/end_to_end_tests/multi_stream_tester.cc
View file

@ -67,7 +67,7 @@ void MultiStreamTester::RunTest() {
CreateBuiltinVideoBitrateAllocatorFactory(); CreateBuiltinVideoBitrateAllocatorFactory();
InternalDecoderFactory decoder_factory; InternalDecoderFactory decoder_factory;
SendTask(RTC_FROM_HERE, task_queue.get(), [&]() { SendTask(task_queue.get(), [&]() {
sender_call = absl::WrapUnique(Call::Create(config)); sender_call = absl::WrapUnique(Call::Create(config));
receiver_call = absl::WrapUnique(Call::Create(config)); receiver_call = absl::WrapUnique(Call::Create(config));
sender_transport = CreateSendTransport(task_queue.get(), sender_call.get()); sender_transport = CreateSendTransport(task_queue.get(), sender_call.get());
@ -129,7 +129,7 @@ void MultiStreamTester::RunTest() {
Wait(); Wait();
SendTask(RTC_FROM_HERE, task_queue.get(), [&]() { SendTask(task_queue.get(), [&]() {
for (size_t i = 0; i < kNumStreams; ++i) { for (size_t i = 0; i < kNumStreams; ++i) {
frame_generators[i]->Stop(); frame_generators[i]->Stop();
sender_call->DestroyVideoSendStream(send_streams[i]); sender_call->DestroyVideoSendStream(send_streams[i]);

18
video/end_to_end_tests/network_state_tests.cc
View file

@ -19,7 +19,6 @@
#include "call/fake_network_pipe.h" #include "call/fake_network_pipe.h"
#include "call/simulated_network.h" #include "call/simulated_network.h"
#include "modules/rtp_rtcp/source/rtp_packet.h" #include "modules/rtp_rtcp/source/rtp_packet.h"
#include "rtc_base/location.h"
#include "rtc_base/synchronization/mutex.h" #include "rtc_base/synchronization/mutex.h"
#include "rtc_base/task_queue_for_test.h" #include "rtc_base/task_queue_for_test.h"
#include "system_wrappers/include/sleep.h" #include "system_wrappers/include/sleep.h"
@ -95,7 +94,7 @@ void NetworkStateEndToEndTest::VerifyNewVideoSendStreamsRespectNetworkState(
Transport* transport) { Transport* transport) {
test::VideoEncoderProxyFactory encoder_factory(encoder); test::VideoEncoderProxyFactory encoder_factory(encoder);
SendTask(RTC_FROM_HERE, task_queue(), SendTask(task_queue(),
[this, network_to_bring_up, &encoder_factory, transport]() { [this, network_to_bring_up, &encoder_factory, transport]() {
CreateSenderCall(Call::Config(send_event_log_.get())); CreateSenderCall(Call::Config(send_event_log_.get()));
sender_call_->SignalChannelNetworkState(network_to_bring_up, sender_call_->SignalChannelNetworkState(network_to_bring_up,
@ -113,7 +112,7 @@ void NetworkStateEndToEndTest::VerifyNewVideoSendStreamsRespectNetworkState(
SleepMs(kSilenceTimeoutMs); SleepMs(kSilenceTimeoutMs);
SendTask(RTC_FROM_HERE, task_queue(), [this]() { SendTask(task_queue(), [this]() {
Stop(); Stop();
DestroyStreams(); DestroyStreams();
DestroyCalls(); DestroyCalls();
@ -126,7 +125,7 @@ void NetworkStateEndToEndTest::VerifyNewVideoReceiveStreamsRespectNetworkState(
std::unique_ptr<test::DirectTransport> sender_transport; std::unique_ptr<test::DirectTransport> sender_transport;
SendTask( SendTask(
RTC_FROM_HERE, task_queue(), task_queue(),
[this, &sender_transport, network_to_bring_up, transport]() { [this, &sender_transport, network_to_bring_up, transport]() {
CreateCalls(); CreateCalls();
receiver_call_->SignalChannelNetworkState(network_to_bring_up, receiver_call_->SignalChannelNetworkState(network_to_bring_up,
@ -148,7 +147,7 @@ void NetworkStateEndToEndTest::VerifyNewVideoReceiveStreamsRespectNetworkState(
SleepMs(kSilenceTimeoutMs); SleepMs(kSilenceTimeoutMs);
SendTask(RTC_FROM_HERE, task_queue(), [this, &sender_transport]() { SendTask(task_queue(), [this, &sender_transport]() {
Stop(); Stop();
DestroyStreams(); DestroyStreams();
sender_transport.reset(); sender_transport.reset();
@ -230,17 +229,16 @@ TEST_F(NetworkStateEndToEndTest, RespectsNetworkState) {
void SignalChannelNetworkState(Call* call, void SignalChannelNetworkState(Call* call,
MediaType media_type, MediaType media_type,
NetworkState network_state) { NetworkState network_state) {
SendTask(RTC_FROM_HERE, e2e_test_task_queue_, SendTask(e2e_test_task_queue_, [call, media_type, network_state] {
[call, media_type, network_state] { call->SignalChannelNetworkState(media_type, network_state);
call->SignalChannelNetworkState(media_type, network_state); });
});
} }
void PerformTest() override { void PerformTest() override {
EXPECT_TRUE(encoded_frames_.Wait(kDefaultTimeoutMs)) EXPECT_TRUE(encoded_frames_.Wait(kDefaultTimeoutMs))
<< "No frames received by the encoder."; << "No frames received by the encoder.";
SendTask(RTC_FROM_HERE, task_queue_.get(), [this]() { SendTask(task_queue_.get(), [this]() {
// Wait for packets from both sender/receiver. // Wait for packets from both sender/receiver.
WaitForPacketsOrSilence(false, false); WaitForPacketsOrSilence(false, false);

49
video/end_to_end_tests/rtp_rtcp_tests.cc
View file

@ -284,9 +284,8 @@ void RtpRtcpEndToEndTest::TestRtpStatePreservation(
VideoEncoderConfig one_stream; VideoEncoderConfig one_stream;
SendTask( SendTask(
RTC_FROM_HERE, task_queue(), task_queue(), [this, &observer, &send_transport, &receive_transport,
[this, &observer, &send_transport, &receive_transport, &one_stream, &one_stream, use_rtx]() {
use_rtx]() {
CreateCalls(); CreateCalls();
send_transport = std::make_unique<test::PacketTransport>( send_transport = std::make_unique<test::PacketTransport>(
@ -336,7 +335,7 @@ void RtpRtcpEndToEndTest::TestRtpStatePreservation(
// Test stream resetting more than once to make sure that the state doesn't // Test stream resetting more than once to make sure that the state doesn't
// get set once (this could be due to using std::map::insert for instance). // get set once (this could be due to using std::map::insert for instance).
for (size_t i = 0; i < 3; ++i) { for (size_t i = 0; i < 3; ++i) {
SendTask(RTC_FROM_HERE, task_queue(), [&]() { SendTask(task_queue(), [&]() {
DestroyVideoSendStreams(); DestroyVideoSendStreams();
// Re-create VideoSendStream with only one stream. // Re-create VideoSendStream with only one stream.
@ -358,7 +357,7 @@ void RtpRtcpEndToEndTest::TestRtpStatePreservation(
EXPECT_TRUE(observer.Wait()) << "Timed out waiting for single RTP packet."; EXPECT_TRUE(observer.Wait()) << "Timed out waiting for single RTP packet.";
// Reconfigure back to use all streams. // Reconfigure back to use all streams.
SendTask(RTC_FROM_HERE, task_queue(), [this]() { SendTask(task_queue(), [this]() {
GetVideoSendStream()->ReconfigureVideoEncoder( GetVideoSendStream()->ReconfigureVideoEncoder(
GetVideoEncoderConfig()->Copy()); GetVideoEncoderConfig()->Copy());
}); });
@ -367,14 +366,14 @@ void RtpRtcpEndToEndTest::TestRtpStatePreservation(
<< "Timed out waiting for all SSRCs to send packets."; << "Timed out waiting for all SSRCs to send packets.";
// Reconfigure down to one stream. // Reconfigure down to one stream.
SendTask(RTC_FROM_HERE, task_queue(), [this, &one_stream]() { SendTask(task_queue(), [this, &one_stream]() {
GetVideoSendStream()->ReconfigureVideoEncoder(one_stream.Copy()); GetVideoSendStream()->ReconfigureVideoEncoder(one_stream.Copy());
}); });
observer.ResetExpectedSsrcs(1); observer.ResetExpectedSsrcs(1);
EXPECT_TRUE(observer.Wait()) << "Timed out waiting for single RTP packet."; EXPECT_TRUE(observer.Wait()) << "Timed out waiting for single RTP packet.";
// Reconfigure back to use all streams. // Reconfigure back to use all streams.
SendTask(RTC_FROM_HERE, task_queue(), [this]() { SendTask(task_queue(), [this]() {
GetVideoSendStream()->ReconfigureVideoEncoder( GetVideoSendStream()->ReconfigureVideoEncoder(
GetVideoEncoderConfig()->Copy()); GetVideoEncoderConfig()->Copy());
}); });
@ -383,14 +382,13 @@ void RtpRtcpEndToEndTest::TestRtpStatePreservation(
<< "Timed out waiting for all SSRCs to send packets."; << "Timed out waiting for all SSRCs to send packets.";
} }
SendTask(RTC_FROM_HERE, task_queue(), SendTask(task_queue(), [this, &send_transport, &receive_transport]() {
[this, &send_transport, &receive_transport]() { Stop();
Stop(); DestroyStreams();
DestroyStreams(); send_transport.reset();
send_transport.reset(); receive_transport.reset();
receive_transport.reset(); DestroyCalls();
DestroyCalls(); });
});
} }
TEST_F(RtpRtcpEndToEndTest, RestartingSendStreamPreservesRtpState) { TEST_F(RtpRtcpEndToEndTest, RestartingSendStreamPreservesRtpState) {
@ -484,7 +482,7 @@ TEST_F(RtpRtcpEndToEndTest, DISABLED_TestFlexfecRtpStatePreservation) {
test::FunctionVideoEncoderFactory encoder_factory( test::FunctionVideoEncoderFactory encoder_factory(
[]() { return VP8Encoder::Create(); }); []() { return VP8Encoder::Create(); });
SendTask(RTC_FROM_HERE, task_queue(), [&]() { SendTask(task_queue(), [&]() {
CreateCalls(); CreateCalls();
BuiltInNetworkBehaviorConfig lossy_delayed_link; BuiltInNetworkBehaviorConfig lossy_delayed_link;
@ -563,7 +561,7 @@ TEST_F(RtpRtcpEndToEndTest, DISABLED_TestFlexfecRtpStatePreservation) {
// Initial test. // Initial test.
EXPECT_TRUE(observer.Wait()) << "Timed out waiting for packets."; EXPECT_TRUE(observer.Wait()) << "Timed out waiting for packets.";
SendTask(RTC_FROM_HERE, task_queue(), [this, &observer]() { SendTask(task_queue(), [this, &observer]() {
// Ensure monotonicity when the VideoSendStream is restarted. // Ensure monotonicity when the VideoSendStream is restarted.
Stop(); Stop();
observer.ResetPacketCount(); observer.ResetPacketCount();
@ -572,7 +570,7 @@ TEST_F(RtpRtcpEndToEndTest, DISABLED_TestFlexfecRtpStatePreservation) {
EXPECT_TRUE(observer.Wait()) << "Timed out waiting for packets."; EXPECT_TRUE(observer.Wait()) << "Timed out waiting for packets.";
SendTask(RTC_FROM_HERE, task_queue(), [this, &observer]() { SendTask(task_queue(), [this, &observer]() {
// Ensure monotonicity when the VideoSendStream is recreated. // Ensure monotonicity when the VideoSendStream is recreated.
DestroyVideoSendStreams(); DestroyVideoSendStreams();
observer.ResetPacketCount(); observer.ResetPacketCount();
@ -584,13 +582,12 @@ TEST_F(RtpRtcpEndToEndTest, DISABLED_TestFlexfecRtpStatePreservation) {
EXPECT_TRUE(observer.Wait()) << "Timed out waiting for packets."; EXPECT_TRUE(observer.Wait()) << "Timed out waiting for packets.";
// Cleanup. // Cleanup.
SendTask(RTC_FROM_HERE, task_queue(), SendTask(task_queue(), [this, &send_transport, &receive_transport]() {
[this, &send_transport, &receive_transport]() { Stop();
Stop(); DestroyStreams();
DestroyStreams(); send_transport.reset();
send_transport.reset(); receive_transport.reset();
receive_transport.reset(); DestroyCalls();
DestroyCalls(); });
});
} }
} // namespace webrtc } // namespace webrtc

19
video/end_to_end_tests/ssrc_tests.cc
View file

@ -81,7 +81,7 @@ TEST_F(SsrcEndToEndTest, UnknownRtpPacketGivesUnknownSsrcReturnCode) {
std::unique_ptr<PacketInputObserver> input_observer; std::unique_ptr<PacketInputObserver> input_observer;
SendTask( SendTask(
RTC_FROM_HERE, task_queue(), task_queue(),
[this, &send_transport, &receive_transport, &input_observer]() { [this, &send_transport, &receive_transport, &input_observer]() {
CreateCalls(); CreateCalls();
@ -117,14 +117,13 @@ TEST_F(SsrcEndToEndTest, UnknownRtpPacketGivesUnknownSsrcReturnCode) {
// Wait() waits for a received packet. // Wait() waits for a received packet.
EXPECT_TRUE(input_observer->Wait()); EXPECT_TRUE(input_observer->Wait());
SendTask(RTC_FROM_HERE, task_queue(), SendTask(task_queue(), [this, &send_transport, &receive_transport]() {
[this, &send_transport, &receive_transport]() { Stop();
Stop(); DestroyStreams();
DestroyStreams(); send_transport.reset();
send_transport.reset(); receive_transport.reset();
receive_transport.reset(); DestroyCalls();
DestroyCalls(); });
});
} }
void SsrcEndToEndTest::TestSendsSetSsrcs(size_t num_ssrcs, void SsrcEndToEndTest::TestSendsSetSsrcs(size_t num_ssrcs,
@ -203,7 +202,7 @@ void SsrcEndToEndTest::TestSendsSetSsrcs(size_t num_ssrcs,
if (send_single_ssrc_first_) { if (send_single_ssrc_first_) {
// Set full simulcast and continue with the rest of the SSRCs. // Set full simulcast and continue with the rest of the SSRCs.
SendTask(RTC_FROM_HERE, task_queue_, [&]() { SendTask(task_queue_, [&]() {
send_stream_->ReconfigureVideoEncoder( send_stream_->ReconfigureVideoEncoder(
std::move(video_encoder_config_all_streams_)); std::move(video_encoder_config_all_streams_));
}); });

49
video/end_to_end_tests/stats_tests.cc
View file

@ -145,8 +145,7 @@ TEST_F(StatsEndToEndTest, GetStats) {
RTC_DCHECK(send_stream_); RTC_DCHECK(send_stream_);
VideoSendStream::Stats stats; VideoSendStream::Stats stats;
SendTask(RTC_FROM_HERE, task_queue_, SendTask(task_queue_, [&]() { stats = send_stream_->GetStats(); });
[&]() { stats = send_stream_->GetStats(); });
size_t expected_num_streams = size_t expected_num_streams =
kNumSimulcastStreams + expected_send_ssrcs_.size(); kNumSimulcastStreams + expected_send_ssrcs_.size();
@ -299,8 +298,7 @@ TEST_F(StatsEndToEndTest, GetStats) {
while (now_ms < stop_time_ms) { while (now_ms < stop_time_ms) {
if (!receive_ok && task_queue_) { if (!receive_ok && task_queue_) {
SendTask(RTC_FROM_HERE, task_queue_, SendTask(task_queue_, [&]() { receive_ok = CheckReceiveStats(); });
[&]() { receive_ok = CheckReceiveStats(); });
} }
if (!send_ok) if (!send_ok)
send_ok = CheckSendStats(); send_ok = CheckSendStats();
@ -375,7 +373,7 @@ TEST_F(StatsEndToEndTest, TimingFramesAreReported) {
void PerformTest() override { void PerformTest() override {
// No frames reported initially. // No frames reported initially.
SendTask(RTC_FROM_HERE, task_queue_, [&]() { SendTask(task_queue_, [&]() {
for (const auto& receive_stream : receive_streams_) { for (const auto& receive_stream : receive_streams_) {
EXPECT_FALSE(receive_stream->GetStats().timing_frame_info); EXPECT_FALSE(receive_stream->GetStats().timing_frame_info);
} }
@ -383,7 +381,7 @@ TEST_F(StatsEndToEndTest, TimingFramesAreReported) {
// Wait for at least one timing frame to be sent with 100ms grace period. // Wait for at least one timing frame to be sent with 100ms grace period.
SleepMs(kDefaultTimingFramesDelayMs + 100); SleepMs(kDefaultTimingFramesDelayMs + 100);
// Check that timing frames are reported for each stream. // Check that timing frames are reported for each stream.
SendTask(RTC_FROM_HERE, task_queue_, [&]() { SendTask(task_queue_, [&]() {
for (const auto& receive_stream : receive_streams_) { for (const auto& receive_stream : receive_streams_) {
EXPECT_TRUE(receive_stream->GetStats().timing_frame_info); EXPECT_TRUE(receive_stream->GetStats().timing_frame_info);
} }
@ -507,9 +505,8 @@ TEST_F(StatsEndToEndTest, MAYBE_ContentTypeSwitches) {
VideoEncoderConfig encoder_config_with_screenshare; VideoEncoderConfig encoder_config_with_screenshare;
SendTask( SendTask(
RTC_FROM_HERE, task_queue(), task_queue(), [this, &test, &send_config, &recv_config,
[this, &test, &send_config, &recv_config, &encoder_config_with_screenshare]() {
&encoder_config_with_screenshare]() {
CreateSenderCall(send_config); CreateSenderCall(send_config);
CreateReceiverCall(recv_config); CreateReceiverCall(recv_config);
@ -547,18 +544,17 @@ TEST_F(StatsEndToEndTest, MAYBE_ContentTypeSwitches) {
test.PerformTest(); test.PerformTest();
// Replace old send stream. // Replace old send stream.
SendTask(RTC_FROM_HERE, task_queue(), SendTask(task_queue(), [this, &encoder_config_with_screenshare]() {
[this, &encoder_config_with_screenshare]() { DestroyVideoSendStreams();
DestroyVideoSendStreams(); CreateVideoSendStream(encoder_config_with_screenshare);
CreateVideoSendStream(encoder_config_with_screenshare); SetVideoDegradation(DegradationPreference::BALANCED);
SetVideoDegradation(DegradationPreference::BALANCED); GetVideoSendStream()->Start();
GetVideoSendStream()->Start(); });
});
// Continue to run test but now with screenshare. // Continue to run test but now with screenshare.
test.PerformTest(); test.PerformTest();
SendTask(RTC_FROM_HERE, task_queue(), [this]() { SendTask(task_queue(), [this]() {
Stop(); Stop();
DestroyStreams(); DestroyStreams();
send_transport_.reset(); send_transport_.reset();
@ -700,7 +696,7 @@ TEST_F(StatsEndToEndTest, CallReportsRttForSender) {
std::unique_ptr<test::DirectTransport> sender_transport; std::unique_ptr<test::DirectTransport> sender_transport;
std::unique_ptr<test::DirectTransport> receiver_transport; std::unique_ptr<test::DirectTransport> receiver_transport;
SendTask(RTC_FROM_HERE, task_queue(), SendTask(task_queue(),
[this, &sender_transport, &receiver_transport]() { [this, &sender_transport, &receiver_transport]() {
BuiltInNetworkBehaviorConfig config; BuiltInNetworkBehaviorConfig config;
config.queue_delay_ms = kSendDelayMs; config.queue_delay_ms = kSendDelayMs;
@ -733,7 +729,7 @@ TEST_F(StatsEndToEndTest, CallReportsRttForSender) {
int64_t start_time_ms = clock_->TimeInMilliseconds(); int64_t start_time_ms = clock_->TimeInMilliseconds();
while (true) { while (true) {
Call::Stats stats; Call::Stats stats;
SendTask(RTC_FROM_HERE, 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 + kDefaultTimeoutMs, clock_->TimeInMilliseconds())
<< "No RTT stats before timeout!"; << "No RTT stats before timeout!";
@ -747,13 +743,12 @@ TEST_F(StatsEndToEndTest, CallReportsRttForSender) {
SleepMs(10); SleepMs(10);
} }
SendTask(RTC_FROM_HERE, task_queue(), SendTask(task_queue(), [this, &sender_transport, &receiver_transport]() {
[this, &sender_transport, &receiver_transport]() { Stop();
Stop(); DestroyStreams();
DestroyStreams(); sender_transport.reset();
sender_transport.reset(); receiver_transport.reset();
receiver_transport.reset(); DestroyCalls();
DestroyCalls(); });
});
} }
} // namespace webrtc } // namespace webrtc

16
video/picture_id_tests.cc
View file

@ -217,7 +217,7 @@ class PictureIdTest : public test::CallTest,
PictureIdTest() : num_temporal_layers_(GetParam()) {} PictureIdTest() : num_temporal_layers_(GetParam()) {}
virtual ~PictureIdTest() { virtual ~PictureIdTest() {
SendTask(RTC_FROM_HERE, task_queue(), [this]() { SendTask(task_queue(), [this]() {
send_transport_.reset(); send_transport_.reset();
receive_transport_.reset(); receive_transport_.reset();
DestroyCalls(); DestroyCalls();
@ -254,7 +254,7 @@ void PictureIdTest::SetupEncoder(VideoEncoderFactory* encoder_factory,
new PictureIdObserver(PayloadStringToCodecType(payload_name))); new PictureIdObserver(PayloadStringToCodecType(payload_name)));
SendTask( SendTask(
RTC_FROM_HERE, task_queue(), [this, encoder_factory, payload_name]() { task_queue(), [this, encoder_factory, payload_name]() {
CreateCalls(); CreateCalls();
send_transport_.reset(new test::PacketTransport( send_transport_.reset(new test::PacketTransport(
@ -299,7 +299,7 @@ void PictureIdTest::SetVideoEncoderConfig(int num_streams) {
void PictureIdTest::TestPictureIdContinuousAfterReconfigure( void PictureIdTest::TestPictureIdContinuousAfterReconfigure(
const std::vector<int>& ssrc_counts) { const std::vector<int>& ssrc_counts) {
SendTask(RTC_FROM_HERE, task_queue(), [this]() { SendTask(task_queue(), [this]() {
CreateVideoStreams(); CreateVideoStreams();
CreateFrameGeneratorCapturer(kFrameRate, kFrameMaxWidth, kFrameMaxHeight); CreateFrameGeneratorCapturer(kFrameRate, kFrameMaxWidth, kFrameMaxHeight);
@ -317,14 +317,14 @@ void PictureIdTest::TestPictureIdContinuousAfterReconfigure(
observer_->SetExpectedSsrcs(ssrc_count); observer_->SetExpectedSsrcs(ssrc_count);
observer_->ResetObservedSsrcs(); observer_->ResetObservedSsrcs();
// Make sure the picture_id sequence is continuous on reinit and recreate. // Make sure the picture_id sequence is continuous on reinit and recreate.
SendTask(RTC_FROM_HERE, task_queue(), [this]() { SendTask(task_queue(), [this]() {
GetVideoSendStream()->ReconfigureVideoEncoder( GetVideoSendStream()->ReconfigureVideoEncoder(
GetVideoEncoderConfig()->Copy()); GetVideoEncoderConfig()->Copy());
}); });
EXPECT_TRUE(observer_->Wait()) << "Timed out waiting for packets."; EXPECT_TRUE(observer_->Wait()) << "Timed out waiting for packets.";
} }
SendTask(RTC_FROM_HERE, task_queue(), [this]() { SendTask(task_queue(), [this]() {
Stop(); Stop();
DestroyStreams(); DestroyStreams();
}); });
@ -332,7 +332,7 @@ void PictureIdTest::TestPictureIdContinuousAfterReconfigure(
void PictureIdTest::TestPictureIdIncreaseAfterRecreateStreams( void PictureIdTest::TestPictureIdIncreaseAfterRecreateStreams(
const std::vector<int>& ssrc_counts) { const std::vector<int>& ssrc_counts) {
SendTask(RTC_FROM_HERE, task_queue(), [this]() { SendTask(task_queue(), [this]() {
CreateVideoStreams(); CreateVideoStreams();
CreateFrameGeneratorCapturer(kFrameRate, kFrameMaxWidth, kFrameMaxHeight); CreateFrameGeneratorCapturer(kFrameRate, kFrameMaxWidth, kFrameMaxHeight);
@ -347,7 +347,7 @@ void PictureIdTest::TestPictureIdIncreaseAfterRecreateStreams(
// with it, therefore it is expected that some frames might be lost. // with it, therefore it is expected that some frames might be lost.
observer_->SetMaxExpectedPictureIdGap(kMaxFramesLost); observer_->SetMaxExpectedPictureIdGap(kMaxFramesLost);
for (int ssrc_count : ssrc_counts) { for (int ssrc_count : ssrc_counts) {
SendTask(RTC_FROM_HERE, task_queue(), [this, &ssrc_count]() { SendTask(task_queue(), [this, &ssrc_count]() {
DestroyVideoSendStreams(); DestroyVideoSendStreams();
SetVideoEncoderConfig(ssrc_count); SetVideoEncoderConfig(ssrc_count);
@ -362,7 +362,7 @@ void PictureIdTest::TestPictureIdIncreaseAfterRecreateStreams(
EXPECT_TRUE(observer_->Wait()) << "Timed out waiting for packets."; EXPECT_TRUE(observer_->Wait()) << "Timed out waiting for packets.";
} }
SendTask(RTC_FROM_HERE, task_queue(), [this]() { SendTask(task_queue(), [this]() {
Stop(); Stop();
DestroyStreams(); DestroyStreams();
}); });

2
video/video_analyzer.cc
View file

@ -397,7 +397,7 @@ void VideoAnalyzer::Wait() {
if (iteration > 0) if (iteration > 0)
printf("- Farewell, sweet Concorde!\n"); printf("- Farewell, sweet Concorde!\n");
SendTask(RTC_FROM_HERE, task_queue_, [&] { stats_polling_task.Stop(); }); SendTask(task_queue_, [&] { stats_polling_task.Stop(); });
PrintResults(); PrintResults();
if (graph_data_output_file_) if (graph_data_output_file_)

35
video/video_quality_test.cc
View file

@ -278,7 +278,7 @@ void PressEnterToContinue(TaskQueueBase* task_queue) {
while (!_kbhit() || _getch() != '\r') { while (!_kbhit() || _getch() != '\r') {
// Drive the message loop for the thread running the task_queue // Drive the message loop for the thread running the task_queue
SendTask(RTC_FROM_HERE, task_queue, [&]() { SendTask(task_queue, [&]() {
MSG msg; MSG msg;
if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) { if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
TranslateMessage(&msg); TranslateMessage(&msg);
@ -1237,20 +1237,19 @@ void VideoQualityTest::RunWithAnalyzer(const Params& params) {
recv_event_log_ = std::make_unique<RtcEventLogNull>(); recv_event_log_ = std::make_unique<RtcEventLogNull>();
} }
SendTask(RTC_FROM_HERE, task_queue(), SendTask(task_queue(), [this, &params, &send_transport, &recv_transport]() {
[this, &params, &send_transport, &recv_transport]() { Call::Config send_call_config(send_event_log_.get());
Call::Config send_call_config(send_event_log_.get()); Call::Config recv_call_config(recv_event_log_.get());
Call::Config recv_call_config(recv_event_log_.get()); send_call_config.bitrate_config = params.call.call_bitrate_config;
send_call_config.bitrate_config = params.call.call_bitrate_config; recv_call_config.bitrate_config = params.call.call_bitrate_config;
recv_call_config.bitrate_config = params.call.call_bitrate_config; if (params_.audio.enabled)
if (params_.audio.enabled) InitializeAudioDevice(&send_call_config, &recv_call_config,
InitializeAudioDevice(&send_call_config, &recv_call_config, params_.audio.use_real_adm);
params_.audio.use_real_adm);
CreateCalls(send_call_config, recv_call_config); CreateCalls(send_call_config, recv_call_config);
send_transport = CreateSendTransport(); send_transport = CreateSendTransport();
recv_transport = CreateReceiveTransport(); recv_transport = CreateReceiveTransport();
}); });
std::string graph_title = params_.analyzer.graph_title; std::string graph_title = params_.analyzer.graph_title;
if (graph_title.empty()) if (graph_title.empty())
@ -1273,7 +1272,7 @@ void VideoQualityTest::RunWithAnalyzer(const Params& params) {
is_quick_test_enabled, clock_, params_.logging.rtp_dump_name, is_quick_test_enabled, clock_, params_.logging.rtp_dump_name,
task_queue()); task_queue());
SendTask(RTC_FROM_HERE, task_queue(), [&]() { SendTask(task_queue(), [&]() {
analyzer_->SetCall(sender_call_.get()); analyzer_->SetCall(sender_call_.get());
analyzer_->SetReceiver(receiver_call_->Receiver()); analyzer_->SetReceiver(receiver_call_->Receiver());
send_transport->SetReceiver(analyzer_.get()); send_transport->SetReceiver(analyzer_.get());
@ -1319,7 +1318,7 @@ void VideoQualityTest::RunWithAnalyzer(const Params& params) {
analyzer_->Wait(); analyzer_->Wait();
SendTask(RTC_FROM_HERE, task_queue(), [&]() { SendTask(task_queue(), [&]() {
StopThumbnails(); StopThumbnails();
Stop(); Stop();
@ -1461,7 +1460,7 @@ void VideoQualityTest::RunWithRenderers(const Params& params) {
recv_event_log_ = std::make_unique<RtcEventLogNull>(); recv_event_log_ = std::make_unique<RtcEventLogNull>();
} }
SendTask(RTC_FROM_HERE, task_queue(), [&]() { SendTask(task_queue(), [&]() {
params_ = params; params_ = params;
CheckParamsAndInjectionComponents(); CheckParamsAndInjectionComponents();
@ -1550,7 +1549,7 @@ void VideoQualityTest::RunWithRenderers(const Params& params) {
PressEnterToContinue(task_queue()); PressEnterToContinue(task_queue());
SendTask(RTC_FROM_HERE, task_queue(), [&]() { SendTask(task_queue(), [&]() {
Stop(); Stop();
DestroyStreams(); DestroyStreams();

68
video/video_send_stream_impl_unittest.cc
View file

@ -195,14 +195,11 @@ TEST_F(VideoSendStreamImplTest, RegistersAsBitrateObserverOnStart) {
EXPECT_EQ(config.enforce_min_bitrate, !kSuspend); EXPECT_EQ(config.enforce_min_bitrate, !kSuspend);
EXPECT_EQ(config.bitrate_priority, kDefaultBitratePriority); EXPECT_EQ(config.bitrate_priority, kDefaultBitratePriority);
})); }));
test_queue_.SendTask( test_queue_.SendTask([&] {
[&] { vss_impl->Start();
vss_impl->Start(); EXPECT_CALL(bitrate_allocator_, RemoveObserver(vss_impl.get())).Times(1);
EXPECT_CALL(bitrate_allocator_, RemoveObserver(vss_impl.get())) vss_impl->Stop();
.Times(1); });
vss_impl->Stop();
},
RTC_FROM_HERE);
} }
TEST_F(VideoSendStreamImplTest, UpdatesObserverOnConfigurationChange) { TEST_F(VideoSendStreamImplTest, UpdatesObserverOnConfigurationChange) {
@ -267,8 +264,7 @@ TEST_F(VideoSendStreamImplTest, UpdatesObserverOnConfigurationChange) {
VideoEncoderConfig::ContentType::kRealtimeVideo, VideoEncoderConfig::ContentType::kRealtimeVideo,
min_transmit_bitrate_bps); min_transmit_bitrate_bps);
vss_impl->Stop(); vss_impl->Stop();
}, });
RTC_FROM_HERE);
} }
TEST_F(VideoSendStreamImplTest, UpdatesObserverOnConfigurationChangeWithAlr) { TEST_F(VideoSendStreamImplTest, UpdatesObserverOnConfigurationChangeWithAlr) {
@ -335,8 +331,7 @@ TEST_F(VideoSendStreamImplTest, UpdatesObserverOnConfigurationChangeWithAlr) {
VideoEncoderConfig::ContentType::kScreen, VideoEncoderConfig::ContentType::kScreen,
min_transmit_bitrate_bps); min_transmit_bitrate_bps);
vss_impl->Stop(); vss_impl->Stop();
}, });
RTC_FROM_HERE);
} }
TEST_F(VideoSendStreamImplTest, TEST_F(VideoSendStreamImplTest,
@ -398,8 +393,7 @@ TEST_F(VideoSendStreamImplTest,
VideoEncoderConfig::ContentType::kRealtimeVideo, VideoEncoderConfig::ContentType::kRealtimeVideo,
/*min_transmit_bitrate_bps=*/0); /*min_transmit_bitrate_bps=*/0);
vss_impl->Stop(); vss_impl->Stop();
}, });
RTC_FROM_HERE);
} }
TEST_F(VideoSendStreamImplTest, SetsScreensharePacingFactorWithFeedback) { TEST_F(VideoSendStreamImplTest, SetsScreensharePacingFactorWithFeedback) {
@ -414,12 +408,10 @@ TEST_F(VideoSendStreamImplTest, SetsScreensharePacingFactorWithFeedback) {
auto vss_impl = CreateVideoSendStreamImpl( auto vss_impl = CreateVideoSendStreamImpl(
kDefaultInitialBitrateBps, kDefaultBitratePriority, kDefaultInitialBitrateBps, kDefaultBitratePriority,
VideoEncoderConfig::ContentType::kScreen); VideoEncoderConfig::ContentType::kScreen);
test_queue_.SendTask( test_queue_.SendTask([&] {
[&] { vss_impl->Start();
vss_impl->Start(); vss_impl->Stop();
vss_impl->Stop(); });
},
RTC_FROM_HERE);
} }
TEST_F(VideoSendStreamImplTest, DoesNotSetPacingFactorWithoutFeedback) { TEST_F(VideoSendStreamImplTest, DoesNotSetPacingFactorWithoutFeedback) {
@ -427,13 +419,11 @@ TEST_F(VideoSendStreamImplTest, DoesNotSetPacingFactorWithoutFeedback) {
auto vss_impl = CreateVideoSendStreamImpl( auto vss_impl = CreateVideoSendStreamImpl(
kDefaultInitialBitrateBps, kDefaultBitratePriority, kDefaultInitialBitrateBps, kDefaultBitratePriority,
VideoEncoderConfig::ContentType::kScreen); VideoEncoderConfig::ContentType::kScreen);
test_queue_.SendTask( test_queue_.SendTask([&] {
[&] { EXPECT_CALL(transport_controller_, SetPacingFactor(_)).Times(0);
EXPECT_CALL(transport_controller_, SetPacingFactor(_)).Times(0); vss_impl->Start();
vss_impl->Start(); vss_impl->Stop();
vss_impl->Stop(); });
},
RTC_FROM_HERE);
} }
TEST_F(VideoSendStreamImplTest, ForwardsVideoBitrateAllocationWhenEnabled) { TEST_F(VideoSendStreamImplTest, ForwardsVideoBitrateAllocationWhenEnabled) {
@ -482,8 +472,7 @@ TEST_F(VideoSendStreamImplTest, ForwardsVideoBitrateAllocationWhenEnabled) {
sink->OnBitrateAllocationUpdated(alloc); sink->OnBitrateAllocationUpdated(alloc);
vss_impl->Stop(); vss_impl->Stop();
}, });
RTC_FROM_HERE);
} }
TEST_F(VideoSendStreamImplTest, ThrottlesVideoBitrateAllocationWhenTooSimilar) { TEST_F(VideoSendStreamImplTest, ThrottlesVideoBitrateAllocationWhenTooSimilar) {
@ -542,8 +531,7 @@ TEST_F(VideoSendStreamImplTest, ThrottlesVideoBitrateAllocationWhenTooSimilar) {
sink->OnBitrateAllocationUpdated(updated_alloc); sink->OnBitrateAllocationUpdated(updated_alloc);
vss_impl->Stop(); vss_impl->Stop();
}, });
RTC_FROM_HERE);
} }
TEST_F(VideoSendStreamImplTest, ForwardsVideoBitrateAllocationOnLayerChange) { TEST_F(VideoSendStreamImplTest, ForwardsVideoBitrateAllocationOnLayerChange) {
@ -588,8 +576,7 @@ TEST_F(VideoSendStreamImplTest, ForwardsVideoBitrateAllocationOnLayerChange) {
sink->OnBitrateAllocationUpdated(updated_alloc); sink->OnBitrateAllocationUpdated(updated_alloc);
vss_impl->Stop(); vss_impl->Stop();
}, });
RTC_FROM_HERE);
} }
TEST_F(VideoSendStreamImplTest, ForwardsVideoBitrateAllocationAfterTimeout) { TEST_F(VideoSendStreamImplTest, ForwardsVideoBitrateAllocationAfterTimeout) {
@ -686,8 +673,7 @@ TEST_F(VideoSendStreamImplTest, ForwardsVideoBitrateAllocationAfterTimeout) {
} }
vss_impl->Stop(); vss_impl->Stop();
}, });
RTC_FROM_HERE);
} }
TEST_F(VideoSendStreamImplTest, CallsVideoStreamEncoderOnBitrateUpdate) { TEST_F(VideoSendStreamImplTest, CallsVideoStreamEncoderOnBitrateUpdate) {
@ -790,8 +776,7 @@ TEST_F(VideoSendStreamImplTest, CallsVideoStreamEncoderOnBitrateUpdate) {
OnBitrateUpdated(DataRate::Zero(), DataRate::Zero(), OnBitrateUpdated(DataRate::Zero(), DataRate::Zero(),
DataRate::Zero(), 0, 0, 0)); DataRate::Zero(), 0, 0, 0));
vss_impl->Stop(); vss_impl->Stop();
}, });
RTC_FROM_HERE);
} }
TEST_F(VideoSendStreamImplTest, DisablesPaddingOnPausedEncoder) { TEST_F(VideoSendStreamImplTest, DisablesPaddingOnPausedEncoder) {
@ -863,8 +848,7 @@ TEST_F(VideoSendStreamImplTest, DisablesPaddingOnPausedEncoder) {
->OnEncodedImage(encoded_image, &codec_specific); ->OnEncodedImage(encoded_image, &codec_specific);
// Only after actual frame is encoded are we enabling the padding. // Only after actual frame is encoded are we enabling the padding.
EXPECT_GT(padding_bitrate, 0); EXPECT_GT(padding_bitrate, 0);
}, });
RTC_FROM_HERE);
rtc::Event done; rtc::Event done;
test_queue_.Get()->PostDelayedTask( test_queue_.Get()->PostDelayedTask(
@ -901,8 +885,7 @@ TEST_F(VideoSendStreamImplTest, KeepAliveOnDroppedFrame) {
EncodedImageCallback::DropReason::kDroppedByEncoder); EncodedImageCallback::DropReason::kDroppedByEncoder);
EXPECT_CALL(bitrate_allocator_, RemoveObserver(vss_impl.get())) EXPECT_CALL(bitrate_allocator_, RemoveObserver(vss_impl.get()))
.Times(0); .Times(0);
}, });
RTC_FROM_HERE);
rtc::Event done; rtc::Event done;
test_queue_.Get()->PostDelayedTask( test_queue_.Get()->PostDelayedTask(
@ -1025,8 +1008,7 @@ TEST_F(VideoSendStreamImplTest, ConfiguresBitratesForSvc) {
::testing::Mock::VerifyAndClearExpectations(&bitrate_allocator_); ::testing::Mock::VerifyAndClearExpectations(&bitrate_allocator_);
vss_impl->Stop(); vss_impl->Stop();
}, });
RTC_FROM_HERE);
} }
} }
} // namespace internal } // namespace internal

45
video/video_send_stream_tests.cc
View file

@ -151,7 +151,7 @@ class VideoSendStreamTest : public test::CallTest {
}; };
TEST_F(VideoSendStreamTest, CanStartStartedStream) { TEST_F(VideoSendStreamTest, CanStartStartedStream) {
SendTask(RTC_FROM_HERE, task_queue(), [this]() { SendTask(task_queue(), [this]() {
CreateSenderCall(); CreateSenderCall();
test::NullTransport transport; test::NullTransport transport;
@ -165,7 +165,7 @@ TEST_F(VideoSendStreamTest, CanStartStartedStream) {
} }
TEST_F(VideoSendStreamTest, CanStopStoppedStream) { TEST_F(VideoSendStreamTest, CanStopStoppedStream) {
SendTask(RTC_FROM_HERE, task_queue(), [this]() { SendTask(task_queue(), [this]() {
CreateSenderCall(); CreateSenderCall();
test::NullTransport transport; test::NullTransport transport;
@ -1593,7 +1593,7 @@ TEST_F(VideoSendStreamTest, ChangingNetworkRoute) {
~ChangingNetworkRouteTest() { ~ChangingNetworkRouteTest() {
// Block until all already posted tasks run to avoid 'use after free' // Block until all already posted tasks run to avoid 'use after free'
// when such task accesses `this`. // when such task accesses `this`.
SendTask(RTC_FROM_HERE, task_queue_, [] {}); SendTask(task_queue_, [] {});
} }
void OnCallsCreated(Call* sender_call, Call* receiver_call) override { void OnCallsCreated(Call* sender_call, Call* receiver_call) override {
@ -1651,7 +1651,7 @@ TEST_F(VideoSendStreamTest, ChangingNetworkRoute) {
new_route.remote = rtc::RouteEndpoint::CreateWithNetworkId(20); new_route.remote = rtc::RouteEndpoint::CreateWithNetworkId(20);
BitrateConstraints bitrate_config; BitrateConstraints bitrate_config;
SendTask(RTC_FROM_HERE, task_queue_, SendTask(task_queue_,
[this, &new_route, &bitrate_config]() { [this, &new_route, &bitrate_config]() {
RTC_DCHECK_RUN_ON(&task_queue_thread_); RTC_DCHECK_RUN_ON(&task_queue_thread_);
call_->GetTransportControllerSend()->OnNetworkRouteChanged( call_->GetTransportControllerSend()->OnNetworkRouteChanged(
@ -1665,7 +1665,7 @@ TEST_F(VideoSendStreamTest, ChangingNetworkRoute) {
<< "Timed out while waiting for start bitrate to be exceeded."; << "Timed out while waiting for start bitrate to be exceeded.";
SendTask( SendTask(
RTC_FROM_HERE, task_queue_, [this, &new_route, &bitrate_config]() { task_queue_, [this, &new_route, &bitrate_config]() {
RTC_DCHECK_RUN_ON(&task_queue_thread_); RTC_DCHECK_RUN_ON(&task_queue_thread_);
bitrate_config.start_bitrate_bps = -1; bitrate_config.start_bitrate_bps = -1;
bitrate_config.max_bitrate_bps = kNewMaxBitrateBps; bitrate_config.max_bitrate_bps = kNewMaxBitrateBps;
@ -1719,7 +1719,7 @@ TEST_F(VideoSendStreamTest, DISABLED_RelayToDirectRoute) {
~RelayToDirectRouteTest() { ~RelayToDirectRouteTest() {
// Block until all already posted tasks run to avoid 'use after free' // Block until all already posted tasks run to avoid 'use after free'
// when such task accesses `this`. // when such task accesses `this`.
SendTask(RTC_FROM_HERE, task_queue_, [] {}); SendTask(task_queue_, [] {});
} }
void OnCallsCreated(Call* sender_call, Call* receiver_call) override { void OnCallsCreated(Call* sender_call, Call* receiver_call) override {
@ -1755,7 +1755,7 @@ TEST_F(VideoSendStreamTest, DISABLED_RelayToDirectRoute) {
route.local = rtc::RouteEndpoint::CreateWithNetworkId(10); route.local = rtc::RouteEndpoint::CreateWithNetworkId(10);
route.remote = rtc::RouteEndpoint::CreateWithNetworkId(20); route.remote = rtc::RouteEndpoint::CreateWithNetworkId(20);
SendTask(RTC_FROM_HERE, task_queue_, [this, &route]() { SendTask(task_queue_, [this, &route]() {
RTC_DCHECK_RUN_ON(&task_queue_thread_); RTC_DCHECK_RUN_ON(&task_queue_thread_);
relayed_phase_ = true; relayed_phase_ = true;
route.remote = route.remote.CreateWithTurn(true); route.remote = route.remote.CreateWithTurn(true);
@ -1771,7 +1771,7 @@ TEST_F(VideoSendStreamTest, DISABLED_RelayToDirectRoute) {
EXPECT_TRUE(Wait()) EXPECT_TRUE(Wait())
<< "Timeout waiting for sufficient packets sent count."; << "Timeout waiting for sufficient packets sent count.";
SendTask(RTC_FROM_HERE, task_queue_, [this, &route]() { SendTask(task_queue_, [this, &route]() {
RTC_DCHECK_RUN_ON(&task_queue_thread_); RTC_DCHECK_RUN_ON(&task_queue_thread_);
EXPECT_LE(call_->GetStats().send_bandwidth_bps, kRelayBandwidthCapBps); EXPECT_LE(call_->GetStats().send_bandwidth_bps, kRelayBandwidthCapBps);
@ -1829,7 +1829,7 @@ TEST_F(VideoSendStreamTest, ChangingTransportOverhead) {
} }
void PerformTest() override { void PerformTest() override {
SendTask(RTC_FROM_HERE, task_queue_, [this]() { SendTask(task_queue_, [this]() {
transport_overhead_ = 100; transport_overhead_ = 100;
call_->GetTransportControllerSend()->OnTransportOverheadChanged( call_->GetTransportControllerSend()->OnTransportOverheadChanged(
transport_overhead_); transport_overhead_);
@ -1842,7 +1842,7 @@ TEST_F(VideoSendStreamTest, ChangingTransportOverhead) {
packets_sent_ = 0; packets_sent_ = 0;
} }
SendTask(RTC_FROM_HERE, task_queue_, [this]() { SendTask(task_queue_, [this]() {
transport_overhead_ = 500; transport_overhead_ = 500;
call_->GetTransportControllerSend()->OnTransportOverheadChanged( call_->GetTransportControllerSend()->OnTransportOverheadChanged(
transport_overhead_); transport_overhead_);
@ -1890,7 +1890,7 @@ class MaxPaddingSetTest : public test::SendTest {
~MaxPaddingSetTest() { ~MaxPaddingSetTest() {
// Block until all already posted tasks run to avoid 'use after free' // Block until all already posted tasks run to avoid 'use after free'
// when such task accesses `this`. // when such task accesses `this`.
SendTask(RTC_FROM_HERE, task_queue_, [] {}); SendTask(task_queue_, [] {});
} }
void ModifyVideoConfigs( void ModifyVideoConfigs(
@ -2071,7 +2071,7 @@ TEST_F(VideoSendStreamTest,
EncoderObserver encoder; EncoderObserver encoder;
test::VideoEncoderProxyFactory encoder_factory(&encoder); test::VideoEncoderProxyFactory encoder_factory(&encoder);
SendTask(RTC_FROM_HERE, task_queue(), [this, &transport, &encoder_factory]() { SendTask(task_queue(), [this, &transport, &encoder_factory]() {
CreateSenderCall(); CreateSenderCall();
CreateSendConfig(1, 0, 0, &transport); CreateSendConfig(1, 0, 0, &transport);
GetVideoSendConfig()->encoder_settings.encoder_factory = &encoder_factory; GetVideoSendConfig()->encoder_settings.encoder_factory = &encoder_factory;
@ -2083,14 +2083,14 @@ TEST_F(VideoSendStreamTest,
encoder.WaitForResolution(kDefaultWidth, kDefaultHeight); encoder.WaitForResolution(kDefaultWidth, kDefaultHeight);
SendTask(RTC_FROM_HERE, task_queue(), [this]() { SendTask(task_queue(), [this]() {
frame_generator_capturer_->ChangeResolution(kDefaultWidth * 2, frame_generator_capturer_->ChangeResolution(kDefaultWidth * 2,
kDefaultHeight * 2); kDefaultHeight * 2);
}); });
encoder.WaitForResolution(kDefaultWidth * 2, kDefaultHeight * 2); encoder.WaitForResolution(kDefaultWidth * 2, kDefaultHeight * 2);
SendTask(RTC_FROM_HERE, task_queue(), [this]() { SendTask(task_queue(), [this]() {
DestroyStreams(); DestroyStreams();
DestroyCalls(); DestroyCalls();
}); });
@ -2325,7 +2325,7 @@ TEST_F(VideoSendStreamTest, EncoderIsProperlyInitializedAndDestroyed) {
void PerformTest() override { void PerformTest() override {
EXPECT_TRUE(Wait()) << "Timed out while waiting for Encode."; EXPECT_TRUE(Wait()) << "Timed out while waiting for Encode.";
SendTask(RTC_FROM_HERE, task_queue_, [this]() { SendTask(task_queue_, [this]() {
EXPECT_EQ(0u, num_releases()); EXPECT_EQ(0u, num_releases());
stream_->ReconfigureVideoEncoder(std::move(encoder_config_)); stream_->ReconfigureVideoEncoder(std::move(encoder_config_));
EXPECT_EQ(0u, num_releases()); EXPECT_EQ(0u, num_releases());
@ -2418,7 +2418,7 @@ class VideoCodecConfigObserver : public test::SendTest,
// Change encoder settings to actually trigger reconfiguration. // Change encoder settings to actually trigger reconfiguration.
encoder_config_.frame_drop_enabled = !encoder_config_.frame_drop_enabled; encoder_config_.frame_drop_enabled = !encoder_config_.frame_drop_enabled;
encoder_config_.encoder_specific_settings = GetEncoderSpecificSettings(); encoder_config_.encoder_specific_settings = GetEncoderSpecificSettings();
SendTask(RTC_FROM_HERE, task_queue_, [&]() { SendTask(task_queue_, [&]() {
stream_->ReconfigureVideoEncoder(std::move(encoder_config_)); stream_->ReconfigureVideoEncoder(std::move(encoder_config_));
}); });
ASSERT_TRUE( ASSERT_TRUE(
@ -2835,14 +2835,14 @@ TEST_F(VideoSendStreamTest, ReconfigureBitratesSetsEncoderBitratesCorrectly) {
BitrateConstraints bitrate_config; BitrateConstraints bitrate_config;
bitrate_config.start_bitrate_bps = kIncreasedStartBitrateKbps * 1000; bitrate_config.start_bitrate_bps = kIncreasedStartBitrateKbps * 1000;
bitrate_config.max_bitrate_bps = kIncreasedMaxBitrateKbps * 1000; bitrate_config.max_bitrate_bps = kIncreasedMaxBitrateKbps * 1000;
SendTask(RTC_FROM_HERE, task_queue_, [this, &bitrate_config]() { SendTask(task_queue_, [this, &bitrate_config]() {
call_->GetTransportControllerSend()->SetSdpBitrateParameters( call_->GetTransportControllerSend()->SetSdpBitrateParameters(
bitrate_config); bitrate_config);
}); });
// Encoder rate is capped by EncoderConfig max_bitrate_bps. // Encoder rate is capped by EncoderConfig max_bitrate_bps.
WaitForSetRates(kMaxBitrateKbps); WaitForSetRates(kMaxBitrateKbps);
encoder_config_.max_bitrate_bps = kLowerMaxBitrateKbps * 1000; encoder_config_.max_bitrate_bps = kLowerMaxBitrateKbps * 1000;
SendTask(RTC_FROM_HERE, task_queue_, [&]() { SendTask(task_queue_, [&]() {
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(
@ -2854,7 +2854,7 @@ TEST_F(VideoSendStreamTest, ReconfigureBitratesSetsEncoderBitratesCorrectly) {
EXPECT_EQ(1, num_encoder_initializations_); EXPECT_EQ(1, num_encoder_initializations_);
encoder_config_.max_bitrate_bps = kIncreasedMaxBitrateKbps * 1000; encoder_config_.max_bitrate_bps = kIncreasedMaxBitrateKbps * 1000;
SendTask(RTC_FROM_HERE, task_queue_, [&]() { SendTask(task_queue_, [&]() {
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(
@ -2951,8 +2951,7 @@ TEST_F(VideoSendStreamTest, ReportsSentResolution) {
EXPECT_TRUE(Wait()) EXPECT_TRUE(Wait())
<< "Timed out while waiting for the encoder to send one frame."; << "Timed out while waiting for the encoder to send one frame.";
VideoSendStream::Stats stats; VideoSendStream::Stats stats;
SendTask(RTC_FROM_HERE, task_queue_, SendTask(task_queue_, [&]() { stats = send_stream_->GetStats(); });
[&]() { stats = send_stream_->GetStats(); });
for (size_t i = 0; i < kNumStreams; ++i) { for (size_t i = 0; i < kNumStreams; ++i) {
ASSERT_TRUE(stats.substreams.find(kVideoSendSsrcs[i]) != ASSERT_TRUE(stats.substreams.find(kVideoSendSsrcs[i]) !=
@ -3728,7 +3727,7 @@ TEST_F(VideoSendStreamTest, RemoveOverheadFromBandwidth) {
bitrate_config.start_bitrate_bps = kStartBitrateBps; bitrate_config.start_bitrate_bps = kStartBitrateBps;
bitrate_config.max_bitrate_bps = kMaxBitrateBps; bitrate_config.max_bitrate_bps = kMaxBitrateBps;
bitrate_config.min_bitrate_bps = kMinBitrateBps; bitrate_config.min_bitrate_bps = kMinBitrateBps;
SendTask(RTC_FROM_HERE, task_queue_, [this, &bitrate_config]() { SendTask(task_queue_, [this, &bitrate_config]() {
call_->GetTransportControllerSend()->SetSdpBitrateParameters( call_->GetTransportControllerSend()->SetSdpBitrateParameters(
bitrate_config); bitrate_config);
call_->GetTransportControllerSend()->OnTransportOverheadChanged(40); call_->GetTransportControllerSend()->OnTransportOverheadChanged(40);
@ -3985,7 +3984,7 @@ TEST_F(VideoSendStreamTest, SwitchesToScreenshareAndBack) {
auto reset_fun = [this](const VideoSendStream::Config& send_stream_config, auto reset_fun = [this](const VideoSendStream::Config& send_stream_config,
const VideoEncoderConfig& encoder_config, const VideoEncoderConfig& encoder_config,
test::BaseTest* test) { test::BaseTest* test) {
SendTask(RTC_FROM_HERE, task_queue(), SendTask(task_queue(),
[this, &send_stream_config, &encoder_config, &test]() { [this, &send_stream_config, &encoder_config, &test]() {
Stop(); Stop();
DestroyVideoSendStreams(); DestroyVideoSendStreams();