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;
sequence_checker.Detach();
TaskQueueForTest queue;
queue.SendTask([&] { EXPECT_TRUE(sequence_checker.IsCurrent()); },
RTC_FROM_HERE);
queue.SendTask([&] { EXPECT_TRUE(sequence_checker.IsCurrent()); });
}
TEST(SequenceCheckerTest, DetachFromTaskQueueAndUseOnThread) {
TaskQueueForTest queue;
queue.SendTask(
[] {
SequenceChecker sequence_checker;
sequence_checker.Detach();
RunOnDifferentThread(
[&] { EXPECT_TRUE(sequence_checker.IsCurrent()); });
},
RTC_FROM_HERE);
queue.SendTask([] {
SequenceChecker sequence_checker;
sequence_checker.Detach();
RunOnDifferentThread([&] { EXPECT_TRUE(sequence_checker.IsCurrent()); });
});
}
TEST(SequenceCheckerTest, MethodNotAllowedOnDifferentThreadInDebug) {
@ -102,8 +98,7 @@ TEST(SequenceCheckerTest, MethodNotAllowedOnDifferentTaskQueueInDebug) {
SequenceChecker sequence_checker;
TaskQueueForTest queue;
queue.SendTask(
[&] { EXPECT_EQ(sequence_checker.IsCurrent(), !RTC_DCHECK_IS_ON); },
RTC_FROM_HERE);
[&] { EXPECT_EQ(sequence_checker.IsCurrent(), !RTC_DCHECK_IS_ON); });
}
TEST(SequenceCheckerTest, DetachFromTaskQueueInDebug) {
@ -111,15 +106,13 @@ TEST(SequenceCheckerTest, DetachFromTaskQueueInDebug) {
sequence_checker.Detach();
TaskQueueForTest queue1;
queue1.SendTask([&] { EXPECT_TRUE(sequence_checker.IsCurrent()); },
RTC_FROM_HERE);
queue1.SendTask([&] { EXPECT_TRUE(sequence_checker.IsCurrent()); });
// IsCurrent should return false in debug builds after moving to
// another task queue.
TaskQueueForTest queue2;
queue2.SendTask(
[&] { EXPECT_EQ(sequence_checker.IsCurrent(), !RTC_DCHECK_IS_ON); },
RTC_FROM_HERE);
[&] { EXPECT_EQ(sequence_checker.IsCurrent(), !RTC_DCHECK_IS_ON); });
}
class TestAnnotations {
@ -146,7 +139,7 @@ TEST(SequenceCheckerTest, TestAnnotations) {
void TestAnnotationsOnWrongQueue() {
TestAnnotations annotations;
TaskQueueForTest queue;
queue.SendTask([&] { annotations.ModifyTestVar(); }, RTC_FROM_HERE);
queue.SendTask([&] { annotations.ModifyTestVar(); });
}
#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;
tq1.SendTask(
[&owner]() {
owner = std::make_unique<Owner>();
EXPECT_FALSE(owner->stuff_done());
},
RTC_FROM_HERE);
tq1.SendTask([&owner]() {
owner = std::make_unique<Owner>();
EXPECT_FALSE(owner->stuff_done());
});
ASSERT_TRUE(owner);
tq2.SendTask([&owner]() { owner->DoStuff(); }, RTC_FROM_HERE);
tq1.SendTask(
[&owner]() {
EXPECT_TRUE(owner->stuff_done());
owner.reset();
},
RTC_FROM_HERE);
tq2.SendTask([&owner]() { owner->DoStuff(); });
tq1.SendTask([&owner]() {
EXPECT_TRUE(owner->stuff_done());
owner.reset();
});
ASSERT_FALSE(owner);
}
@ -129,9 +125,9 @@ TEST(PendingTaskSafetyFlagTest, PendingTaskDropped) {
std::unique_ptr<Owner> owner;
bool stuff_done = false;
tq1.SendTask(
[&owner, &stuff_done]() { owner = std::make_unique<Owner>(&stuff_done); },
RTC_FROM_HERE);
tq1.SendTask([&owner, &stuff_done]() {
owner = std::make_unique<Owner>(&stuff_done);
});
ASSERT_TRUE(owner);
// Queue up a task on tq1 that will execute before the 'DoStuff' task
// can, and delete the `owner` before the 'stuff' task can execute.
@ -142,7 +138,7 @@ TEST(PendingTaskSafetyFlagTest, PendingTaskDropped) {
});
// Queue up a DoStuff...
tq2.SendTask([&owner]() { owner->DoStuff(); }, RTC_FROM_HERE);
tq2.SendTask([&owner]() { owner->DoStuff(); });
ASSERT_TRUE(owner);
blocker.Set();
@ -158,7 +154,7 @@ TEST(PendingTaskSafetyFlagTest, PendingTaskNotAliveInitialized) {
// Create a new flag that initially not `alive`.
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_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.round_trip_time = TimeDelta::Millis(50);
update.bwe_period = TimeDelta::Millis(6000);
helper.worker()->SendTask([&] { send_stream->OnBitrateUpdated(update); },
RTC_FROM_HERE);
helper.worker()->SendTask([&] { send_stream->OnBitrateUpdated(update); });
}
}
@ -655,8 +654,7 @@ TEST(AudioSendStreamTest, SSBweTargetInRangeRespected) {
BitrateAllocationUpdate update;
update.target_bitrate =
DataRate::BitsPerSec(helper.config().max_bitrate_bps - 5000);
helper.worker()->SendTask([&] { send_stream->OnBitrateUpdated(update); },
RTC_FROM_HERE);
helper.worker()->SendTask([&] { send_stream->OnBitrateUpdated(update); });
}
}
@ -672,8 +670,7 @@ TEST(AudioSendStreamTest, SSBweFieldTrialMinRespected) {
Eq(DataRate::KilobitsPerSec(6)))));
BitrateAllocationUpdate update;
update.target_bitrate = DataRate::KilobitsPerSec(1);
helper.worker()->SendTask([&] { send_stream->OnBitrateUpdated(update); },
RTC_FROM_HERE);
helper.worker()->SendTask([&] { send_stream->OnBitrateUpdated(update); });
}
}
@ -689,8 +686,7 @@ TEST(AudioSendStreamTest, SSBweFieldTrialMaxRespected) {
Eq(DataRate::KilobitsPerSec(64)))));
BitrateAllocationUpdate update;
update.target_bitrate = DataRate::KilobitsPerSec(128);
helper.worker()->SendTask([&] { send_stream->OnBitrateUpdated(update); },
RTC_FROM_HERE);
helper.worker()->SendTask([&] { send_stream->OnBitrateUpdated(update); });
}
}
@ -710,8 +706,7 @@ TEST(AudioSendStreamTest, SSBweWithOverhead) {
&BitrateAllocationUpdate::target_bitrate, Eq(bitrate))));
BitrateAllocationUpdate update;
update.target_bitrate = bitrate;
helper.worker()->SendTask([&] { send_stream->OnBitrateUpdated(update); },
RTC_FROM_HERE);
helper.worker()->SendTask([&] { send_stream->OnBitrateUpdated(update); });
}
}
@ -731,8 +726,7 @@ TEST(AudioSendStreamTest, SSBweWithOverheadMinRespected) {
&BitrateAllocationUpdate::target_bitrate, Eq(bitrate))));
BitrateAllocationUpdate update;
update.target_bitrate = DataRate::KilobitsPerSec(1);
helper.worker()->SendTask([&] { send_stream->OnBitrateUpdated(update); },
RTC_FROM_HERE);
helper.worker()->SendTask([&] { send_stream->OnBitrateUpdated(update); });
}
}
@ -752,8 +746,7 @@ TEST(AudioSendStreamTest, SSBweWithOverheadMaxRespected) {
&BitrateAllocationUpdate::target_bitrate, Eq(bitrate))));
BitrateAllocationUpdate update;
update.target_bitrate = DataRate::KilobitsPerSec(128);
helper.worker()->SendTask([&] { send_stream->OnBitrateUpdated(update); },
RTC_FROM_HERE);
helper.worker()->SendTask([&] { send_stream->OnBitrateUpdated(update); });
}
}
@ -771,8 +764,7 @@ TEST(AudioSendStreamTest, ProbingIntervalOnBitrateUpdated) {
update.packet_loss_ratio = 0;
update.round_trip_time = TimeDelta::Millis(50);
update.bwe_period = TimeDelta::Millis(5000);
helper.worker()->SendTask([&] { send_stream->OnBitrateUpdated(update); },
RTC_FROM_HERE);
helper.worker()->SendTask([&] { send_stream->OnBitrateUpdated(update); });
}
}
@ -874,8 +866,7 @@ TEST(AudioSendStreamTest, AudioOverheadChanged) {
DataRate::BitsPerSec(helper.config().max_bitrate_bps) +
kMaxOverheadRate;
EXPECT_CALL(*helper.channel_send(), OnBitrateAllocation);
helper.worker()->SendTask([&] { send_stream->OnBitrateUpdated(update); },
RTC_FROM_HERE);
helper.worker()->SendTask([&] { send_stream->OnBitrateUpdated(update); });
EXPECT_EQ(audio_overhead_per_packet_bytes,
send_stream->TestOnlyGetPerPacketOverheadBytes());
@ -883,8 +874,7 @@ TEST(AudioSendStreamTest, AudioOverheadChanged) {
EXPECT_CALL(*helper.rtp_rtcp(), ExpectedPerPacketOverhead)
.WillRepeatedly(Return(audio_overhead_per_packet_bytes + 20));
EXPECT_CALL(*helper.channel_send(), OnBitrateAllocation);
helper.worker()->SendTask([&] { send_stream->OnBitrateUpdated(update); },
RTC_FROM_HERE);
helper.worker()->SendTask([&] { send_stream->OnBitrateUpdated(update); });
EXPECT_EQ(audio_overhead_per_packet_bytes + 20,
send_stream->TestOnlyGetPerPacketOverheadBytes());
@ -908,8 +898,7 @@ TEST(AudioSendStreamTest, OnAudioAndTransportOverheadChanged) {
DataRate::BitsPerSec(helper.config().max_bitrate_bps) +
kMaxOverheadRate;
EXPECT_CALL(*helper.channel_send(), OnBitrateAllocation);
helper.worker()->SendTask([&] { send_stream->OnBitrateUpdated(update); },
RTC_FROM_HERE);
helper.worker()->SendTask([&] { send_stream->OnBitrateUpdated(update); });
EXPECT_EQ(
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 void SetUp() {
SendTask(RTC_FROM_HERE, task_queue(), [this]() {
SendTask(task_queue(), [this]() {
CreateCalls();
send_transport_.reset(new test::DirectTransport(
@ -154,7 +154,7 @@ class BitrateEstimatorTest : public test::CallTest {
}
virtual void TearDown() {
SendTask(RTC_FROM_HERE, task_queue(), [this]() {
SendTask(task_queue(), [this]() {
for (auto* stream : streams_) {
stream->StopSending();
delete stream;
@ -257,7 +257,7 @@ static const char* kSingleStreamLog =
"RemoteBitrateEstimatorSingleStream: Instantiating.";
TEST_F(BitrateEstimatorTest, InstantiatesTOFPerDefaultForVideo) {
SendTask(RTC_FROM_HERE, task_queue(), [this]() {
SendTask(task_queue(), [this]() {
GetVideoSendConfig()->rtp.extensions.push_back(
RtpExtension(RtpExtension::kTimestampOffsetUri, kTOFExtensionId));
receiver_log_.PushExpectedLogLine(kSingleStreamLog);
@ -268,7 +268,7 @@ TEST_F(BitrateEstimatorTest, InstantiatesTOFPerDefaultForVideo) {
}
TEST_F(BitrateEstimatorTest, ImmediatelySwitchToASTForVideo) {
SendTask(RTC_FROM_HERE, task_queue(), [this]() {
SendTask(task_queue(), [this]() {
GetVideoSendConfig()->rtp.extensions.push_back(
RtpExtension(RtpExtension::kAbsSendTimeUri, kASTExtensionId));
receiver_log_.PushExpectedLogLine(kSingleStreamLog);
@ -281,7 +281,7 @@ TEST_F(BitrateEstimatorTest, ImmediatelySwitchToASTForVideo) {
}
TEST_F(BitrateEstimatorTest, SwitchesToASTForVideo) {
SendTask(RTC_FROM_HERE, task_queue(), [this]() {
SendTask(task_queue(), [this]() {
GetVideoSendConfig()->rtp.extensions.push_back(
RtpExtension(RtpExtension::kTimestampOffsetUri, kTOFExtensionId));
receiver_log_.PushExpectedLogLine(kSingleStreamLog);
@ -290,7 +290,7 @@ TEST_F(BitrateEstimatorTest, SwitchesToASTForVideo) {
});
EXPECT_TRUE(receiver_log_.Wait());
SendTask(RTC_FROM_HERE, task_queue(), [this]() {
SendTask(task_queue(), [this]() {
GetVideoSendConfig()->rtp.extensions[0] =
RtpExtension(RtpExtension::kAbsSendTimeUri, kASTExtensionId);
receiver_log_.PushExpectedLogLine("Switching to absolute send time RBE.");
@ -302,7 +302,7 @@ TEST_F(BitrateEstimatorTest, SwitchesToASTForVideo) {
// This test is flaky. See webrtc:5790.
TEST_F(BitrateEstimatorTest, DISABLED_SwitchesToASTThenBackToTOFForVideo) {
SendTask(RTC_FROM_HERE, task_queue(), [this]() {
SendTask(task_queue(), [this]() {
GetVideoSendConfig()->rtp.extensions.push_back(
RtpExtension(RtpExtension::kTimestampOffsetUri, kTOFExtensionId));
receiver_log_.PushExpectedLogLine(kSingleStreamLog);
@ -312,7 +312,7 @@ TEST_F(BitrateEstimatorTest, DISABLED_SwitchesToASTThenBackToTOFForVideo) {
});
EXPECT_TRUE(receiver_log_.Wait());
SendTask(RTC_FROM_HERE, task_queue(), [this]() {
SendTask(task_queue(), [this]() {
GetVideoSendConfig()->rtp.extensions[0] =
RtpExtension(RtpExtension::kAbsSendTimeUri, kASTExtensionId);
receiver_log_.PushExpectedLogLine(kAbsSendTimeLog);
@ -321,7 +321,7 @@ TEST_F(BitrateEstimatorTest, DISABLED_SwitchesToASTThenBackToTOFForVideo) {
});
EXPECT_TRUE(receiver_log_.Wait());
SendTask(RTC_FROM_HERE, task_queue(), [this]() {
SendTask(task_queue(), [this]() {
GetVideoSendConfig()->rtp.extensions[0] =
RtpExtension(RtpExtension::kTimestampOffsetUri, kTOFExtensionId);
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;
std::unique_ptr<DriftingClock> drifting_clock;
SendTask(RTC_FROM_HERE, task_queue(), [&]() {
SendTask(task_queue(), [&]() {
metrics::Reset();
rtc::scoped_refptr<TestAudioDeviceModule> fake_audio_device =
TestAudioDeviceModule::Create(
@ -307,7 +307,7 @@ void CallPerfTest::TestAudioVideoSync(FecMode fec,
EXPECT_TRUE(observer->Wait())
<< "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.
observer->set_receive_stream(nullptr);
@ -870,7 +870,7 @@ TEST_F(CallPerfTest, MAYBE_KeepsHighBitrateWhenReconfiguringSender) {
ASSERT_TRUE(time_to_reconfigure_.Wait(kDefaultTimeoutMs))
<< "Timed out before receiving an initial high bitrate.";
frame_generator_->ChangeResolution(kDefaultWidth * 2, kDefaultHeight * 2);
SendTask(RTC_FROM_HERE, task_queue_, [&]() {
SendTask(task_queue_, [&]() {
send_stream_->ReconfigureVideoEncoder(encoder_config_.Copy());
});
EXPECT_TRUE(Wait())
@ -987,7 +987,7 @@ void CallPerfTest::TestMinAudioVideoBitrate(int test_bitrate_from,
int64_t avg_rtt = 0;
for (int i = 0; i < kBitrateMeasurements; i++) {
Call::Stats call_stats;
SendTask(RTC_FROM_HERE, task_queue_, [this, &call_stats]() {
SendTask(task_queue_, [this, &call_stats]() {
call_stats = sender_call_->GetStats();
});
avg_rtt += call_stats.rtt_ms;

5
call/rampup_tests.cc
View file

@ -362,15 +362,14 @@ void RampUpTester::TriggerTestDone() {
// Stop polling stats.
// 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.
if (!send_stream_)
return;
VideoSendStream::Stats send_stats;
SendTask(RTC_FROM_HERE, task_queue_,
[&] { send_stats = send_stream_->GetStats(); });
SendTask(task_queue_, [&] { send_stats = send_stream_->GetStats(); });
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) {
TaskQueueForTest init_queue("init");
rtc::scoped_refptr<AudioMixer> mixer;
init_queue.SendTask([&mixer]() { mixer = AudioMixerImpl::Create(); },
RTC_FROM_HERE);
init_queue.SendTask([&mixer]() { mixer = AudioMixerImpl::Create(); });
MockMixerAudioSource participant;
EXPECT_CALL(participant, PreferredSampleRate())
@ -400,8 +399,7 @@ TEST(AudioMixer, ConstructFromOtherThread) {
TaskQueueForTest participant_queue("participant");
participant_queue.SendTask(
[&mixer, &participant]() { mixer->AddSource(&participant); },
RTC_FROM_HERE);
[&mixer, &participant]() { mixer->AddSource(&participant); });
EXPECT_CALL(participant, GetAudioFrameWithInfo(kDefaultSampleRateHz, _))
.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(
kPayload, kType, kTimestamp, *encoded_image, video_header,
kDefaultExpectedRetransmissionTimeMs);
},
RTC_FROM_HERE);
});
encoder_queue.WaitForPreviouslyPostedTasks();
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(); });
// 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,
// and then release the codecs.
@ -720,11 +720,9 @@ bool VideoCodecTestFixtureImpl::SetUpAndInitObjects(
cpu_process_time_.reset(new CpuProcessTime(config_));
bool is_codec_created = false;
task_queue->SendTask(
[this, &is_codec_created]() {
is_codec_created = CreateEncoderAndDecoder();
},
RTC_FROM_HERE);
task_queue->SendTask([this, &is_codec_created]() {
is_codec_created = CreateEncoderAndDecoder();
});
if (!is_codec_created) {
return false;
@ -778,20 +776,17 @@ bool VideoCodecTestFixtureImpl::SetUpAndInitObjects(
encoder_.get(), &decoders_, source_frame_reader_.get(), config_,
&stats_, &encoded_frame_writers_,
decoded_frame_writers_.empty() ? nullptr : &decoded_frame_writers_);
},
RTC_FROM_HERE);
});
return true;
}
void VideoCodecTestFixtureImpl::ReleaseAndCloseObjects(
TaskQueueForTest* task_queue) {
task_queue->SendTask(
[this]() {
processor_.reset();
// The VideoProcessor must be destroyed before the codecs.
DestroyEncoderAndDecoder();
},
RTC_FROM_HERE);
task_queue->SendTask([this]() {
processor_.reset();
// The VideoProcessor must be destroyed before the codecs.
DestroyEncoderAndDecoder();
});
source_frame_reader_->Close();
@ -810,15 +805,13 @@ std::string VideoCodecTestFixtureImpl::GetCodecName(
TaskQueueForTest* task_queue,
bool is_encoder) const {
std::string codec_name;
task_queue->SendTask(
[this, is_encoder, &codec_name] {
if (is_encoder) {
codec_name = encoder_->GetEncoderInfo().implementation_name;
} else {
codec_name = decoders_.at(0)->ImplementationName();
}
},
RTC_FROM_HERE);
task_queue->SendTask([this, is_encoder, &codec_name] {
if (is_encoder) {
codec_name = encoder_->GetEncoderInfo().implementation_name;
} else {
codec_name = decoders_.at(0)->ImplementationName();
}
});
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>(
&encoder_mock_, &decoders_, &frame_reader_mock_, config_, &stats_,
&encoded_frame_writers_, /*decoded_frame_writers=*/nullptr);
},
RTC_FROM_HERE);
});
}
~VideoProcessorTest() {
q_.SendTask([this] { video_processor_.reset(); }, RTC_FROM_HERE);
q_.SendTask([this] { video_processor_.reset(); });
}
void ExpectInit() {
@ -106,8 +105,7 @@ TEST_F(VideoProcessorTest, ProcessFrames_FixedFramerate) {
SetRates(Field(&VideoEncoder::RateControlParameters::framerate_fps,
static_cast<double>(kFramerateFps))))
.Times(1);
q_.SendTask([=] { video_processor_->SetRates(kBitrateKbps, kFramerateFps); },
RTC_FROM_HERE);
q_.SendTask([=] { video_processor_->SetRates(kBitrateKbps, kFramerateFps); });
EXPECT_CALL(frame_reader_mock_, ReadFrame())
.WillRepeatedly(Return(I420Buffer::Create(kWidth, kHeight)));
@ -115,13 +113,13 @@ TEST_F(VideoProcessorTest, ProcessFrames_FixedFramerate) {
encoder_mock_,
Encode(Property(&VideoFrame::timestamp, 1 * 90000 / kFramerateFps), _))
.Times(1);
q_.SendTask([this] { video_processor_->ProcessFrame(); }, RTC_FROM_HERE);
q_.SendTask([this] { video_processor_->ProcessFrame(); });
EXPECT_CALL(
encoder_mock_,
Encode(Property(&VideoFrame::timestamp, 2 * 90000 / kFramerateFps), _))
.Times(1);
q_.SendTask([this] { video_processor_->ProcessFrame(); }, RTC_FROM_HERE);
q_.SendTask([this] { video_processor_->ProcessFrame(); });
ExpectRelease();
}
@ -136,15 +134,14 @@ TEST_F(VideoProcessorTest, ProcessFrames_VariableFramerate) {
static_cast<double>(kStartFramerateFps))))
.Times(1);
q_.SendTask(
[=] { video_processor_->SetRates(kBitrateKbps, kStartFramerateFps); },
RTC_FROM_HERE);
[=] { video_processor_->SetRates(kBitrateKbps, kStartFramerateFps); });
EXPECT_CALL(frame_reader_mock_, ReadFrame())
.WillRepeatedly(Return(I420Buffer::Create(kWidth, kHeight)));
EXPECT_CALL(encoder_mock_,
Encode(Property(&VideoFrame::timestamp, kStartTimestamp), _))
.Times(1);
q_.SendTask([this] { video_processor_->ProcessFrame(); }, RTC_FROM_HERE);
q_.SendTask([this] { video_processor_->ProcessFrame(); });
const int kNewFramerateFps = 13;
EXPECT_CALL(
@ -153,15 +150,14 @@ TEST_F(VideoProcessorTest, ProcessFrames_VariableFramerate) {
static_cast<double>(kNewFramerateFps))))
.Times(1);
q_.SendTask(
[=] { video_processor_->SetRates(kBitrateKbps, kNewFramerateFps); },
RTC_FROM_HERE);
[=] { video_processor_->SetRates(kBitrateKbps, kNewFramerateFps); });
EXPECT_CALL(encoder_mock_,
Encode(Property(&VideoFrame::timestamp,
kStartTimestamp + 90000 / kNewFramerateFps),
_))
.Times(1);
q_.SendTask([this] { video_processor_->ProcessFrame(); }, RTC_FROM_HERE);
q_.SendTask([this] { video_processor_->ProcessFrame(); });
ExpectRelease();
}
@ -180,8 +176,7 @@ TEST_F(VideoProcessorTest, SetRates) {
Field(&VideoEncoder::RateControlParameters::framerate_fps,
static_cast<double>(kFramerateFps)))))
.Times(1);
q_.SendTask([=] { video_processor_->SetRates(kBitrateKbps, kFramerateFps); },
RTC_FROM_HERE);
q_.SendTask([=] { video_processor_->SetRates(kBitrateKbps, kFramerateFps); });
const uint32_t kNewBitrateKbps = 456;
const int kNewFramerateFps = 34;
@ -196,8 +191,7 @@ TEST_F(VideoProcessorTest, SetRates) {
static_cast<double>(kNewFramerateFps)))))
.Times(1);
q_.SendTask(
[=] { video_processor_->SetRates(kNewBitrateKbps, kNewFramerateFps); },
RTC_FROM_HERE);
[=] { video_processor_->SetRates(kNewBitrateKbps, kNewFramerateFps); });
ExpectRelease();
}

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

@ -106,13 +106,11 @@ class BandwidthQualityScalerTest
GetDefaultSinglecastBitrateLimitsWhenQpIsUntrusted());
// Only for testing. Set first_timestamp_ in RateStatistics to 0.
bandwidth_quality_scaler_->ReportEncodeInfo(0, 0, 0, 0);
},
RTC_FROM_HERE);
});
}
~BandwidthQualityScalerTest() {
task_queue_.SendTask([this] { bandwidth_quality_scaler_ = nullptr; },
RTC_FROM_HERE);
task_queue_.SendTask([this] { bandwidth_quality_scaler_ = nullptr; });
}
int GetFrameSizeBytes(
@ -180,8 +178,7 @@ class BandwidthQualityScalerTest
config.actual_width, config.actual_height);
}
}
},
RTC_FROM_HERE);
});
}
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] {
qs_ = std::unique_ptr<QualityScaler>(new QualityScalerUnderTest(
handler_.get(), VideoEncoder::QpThresholds(kLowQp, kHighQp)));
},
RTC_FROM_HERE);
});
}
~QualityScalerTest() override {
task_queue_.SendTask([this] { qs_ = nullptr; }, RTC_FROM_HERE);
task_queue_.SendTask([this] { qs_ = nullptr; });
}
void TriggerScale(ScaleDirection scale_direction) {
@ -119,52 +118,46 @@ INSTANTIATE_TEST_SUITE_P(
"WebRTC-Video-QualityScaling/Disabled/"));
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_EQ(1, handler_->adapt_down_events_);
EXPECT_EQ(0, handler_->adapt_up_events_);
}
TEST_P(QualityScalerTest, KeepsScaleAtHighQp) {
task_queue_.SendTask([this] { TriggerScale(kKeepScaleAtHighQp); },
RTC_FROM_HERE);
task_queue_.SendTask([this] { TriggerScale(kKeepScaleAtHighQp); });
EXPECT_FALSE(handler_->event.Wait(kDefaultTimeoutMs));
EXPECT_EQ(0, handler_->adapt_down_events_);
EXPECT_EQ(0, handler_->adapt_up_events_);
}
TEST_P(QualityScalerTest, DownscalesAboveHighQp) {
task_queue_.SendTask([this] { TriggerScale(kScaleDownAboveHighQp); },
RTC_FROM_HERE);
task_queue_.SendTask([this] { TriggerScale(kScaleDownAboveHighQp); });
EXPECT_TRUE(handler_->event.Wait(kDefaultTimeoutMs));
EXPECT_EQ(1, handler_->adapt_down_events_);
EXPECT_EQ(0, handler_->adapt_up_events_);
}
TEST_P(QualityScalerTest, DownscalesAfterTwoThirdsFramedrop) {
task_queue_.SendTask(
[this] {
for (int i = 0; i < kFramerate * 5; ++i) {
qs_->ReportDroppedFrameByMediaOpt();
qs_->ReportDroppedFrameByMediaOpt();
qs_->ReportQp(kHighQp, 0);
}
},
RTC_FROM_HERE);
task_queue_.SendTask([this] {
for (int i = 0; i < kFramerate * 5; ++i) {
qs_->ReportDroppedFrameByMediaOpt();
qs_->ReportDroppedFrameByMediaOpt();
qs_->ReportQp(kHighQp, 0);
}
});
EXPECT_TRUE(handler_->event.Wait(kDefaultTimeoutMs));
EXPECT_EQ(1, handler_->adapt_down_events_);
EXPECT_EQ(0, handler_->adapt_up_events_);
}
TEST_P(QualityScalerTest, DoesNotDownscaleAfterHalfFramedrop) {
task_queue_.SendTask(
[this] {
for (int i = 0; i < kFramerate * 5; ++i) {
qs_->ReportDroppedFrameByMediaOpt();
qs_->ReportQp(kHighQp, 0);
}
},
RTC_FROM_HERE);
task_queue_.SendTask([this] {
for (int i = 0; i < kFramerate * 5; ++i) {
qs_->ReportDroppedFrameByMediaOpt();
qs_->ReportQp(kHighQp, 0);
}
});
EXPECT_FALSE(handler_->event.Wait(kDefaultTimeoutMs));
EXPECT_EQ(0, handler_->adapt_down_events_);
EXPECT_EQ(0, handler_->adapt_up_events_);
@ -173,98 +166,85 @@ TEST_P(QualityScalerTest, DoesNotDownscaleAfterHalfFramedrop) {
TEST_P(QualityScalerTest, DownscalesAfterTwoThirdsIfFieldTrialEnabled) {
const bool kDownScaleExpected =
GetParam().find("Enabled") != std::string::npos;
task_queue_.SendTask(
[this] {
for (int i = 0; i < kFramerate * 5; ++i) {
qs_->ReportDroppedFrameByMediaOpt();
qs_->ReportDroppedFrameByEncoder();
qs_->ReportQp(kHighQp, 0);
}
},
RTC_FROM_HERE);
task_queue_.SendTask([this] {
for (int i = 0; i < kFramerate * 5; ++i) {
qs_->ReportDroppedFrameByMediaOpt();
qs_->ReportDroppedFrameByEncoder();
qs_->ReportQp(kHighQp, 0);
}
});
EXPECT_EQ(kDownScaleExpected, handler_->event.Wait(kDefaultTimeoutMs));
EXPECT_EQ(kDownScaleExpected ? 1 : 0, handler_->adapt_down_events_);
EXPECT_EQ(0, handler_->adapt_up_events_);
}
TEST_P(QualityScalerTest, KeepsScaleOnNormalQp) {
task_queue_.SendTask([this] { TriggerScale(kKeepScaleAboveLowQp); },
RTC_FROM_HERE);
task_queue_.SendTask([this] { TriggerScale(kKeepScaleAboveLowQp); });
EXPECT_FALSE(handler_->event.Wait(kDefaultTimeoutMs));
EXPECT_EQ(0, handler_->adapt_down_events_);
EXPECT_EQ(0, handler_->adapt_up_events_);
}
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_EQ(0, handler_->adapt_down_events_);
EXPECT_EQ(1, handler_->adapt_up_events_);
}
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_EQ(1, handler_->adapt_down_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_EQ(1, handler_->adapt_down_events_);
EXPECT_EQ(1, handler_->adapt_up_events_);
}
TEST_P(QualityScalerTest, DoesNotScaleUntilEnoughFramesObserved) {
task_queue_.SendTask(
[this] {
// Not enough frames to make a decision.
for (int i = 0; i < kMinFramesNeededToScale - 1; ++i) {
qs_->ReportQp(kLowQp, 0);
}
},
RTC_FROM_HERE);
task_queue_.SendTask([this] {
// Not enough frames to make a decision.
for (int i = 0; i < kMinFramesNeededToScale - 1; ++i) {
qs_->ReportQp(kLowQp, 0);
}
});
EXPECT_FALSE(handler_->event.Wait(kDefaultTimeoutMs));
task_queue_.SendTask(
[this] {
// Send 1 more. Enough frames observed, should result in an adapt
// request.
qs_->ReportQp(kLowQp, 0);
},
RTC_FROM_HERE);
task_queue_.SendTask([this] {
// Send 1 more. Enough frames observed, should result in an adapt
// request.
qs_->ReportQp(kLowQp, 0);
});
EXPECT_TRUE(handler_->event.Wait(kDefaultTimeoutMs));
EXPECT_EQ(0, handler_->adapt_down_events_);
EXPECT_EQ(1, handler_->adapt_up_events_);
// Samples should be cleared after an adapt request.
task_queue_.SendTask(
[this] {
// Not enough frames to make a decision.
qs_->ReportQp(kLowQp, 0);
},
RTC_FROM_HERE);
task_queue_.SendTask([this] {
// Not enough frames to make a decision.
qs_->ReportQp(kLowQp, 0);
});
EXPECT_FALSE(handler_->event.Wait(kDefaultTimeoutMs));
EXPECT_EQ(0, handler_->adapt_down_events_);
EXPECT_EQ(1, handler_->adapt_up_events_);
}
TEST_P(QualityScalerTest, ScalesDownAndBackUpWithMinFramesNeeded) {
task_queue_.SendTask(
[this] {
for (int i = 0; i < kMinFramesNeededToScale; ++i) {
qs_->ReportQp(kHighQp + 1, 0);
}
},
RTC_FROM_HERE);
task_queue_.SendTask([this] {
for (int i = 0; i < kMinFramesNeededToScale; ++i) {
qs_->ReportQp(kHighQp + 1, 0);
}
});
EXPECT_TRUE(handler_->event.Wait(kDefaultTimeoutMs));
EXPECT_EQ(1, handler_->adapt_down_events_);
EXPECT_EQ(0, handler_->adapt_up_events_);
// Samples cleared.
task_queue_.SendTask(
[this] {
for (int i = 0; i < kMinFramesNeededToScale; ++i) {
qs_->ReportQp(kLowQp, 0);
}
},
RTC_FROM_HERE);
task_queue_.SendTask([this] {
for (int i = 0; i < kMinFramesNeededToScale; ++i) {
qs_->ReportQp(kLowQp, 0);
}
});
EXPECT_TRUE(handler_->event.Wait(kDefaultTimeoutMs));
EXPECT_EQ(1, handler_->adapt_down_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 = [
":checks",
":location",
":macromagic",
":rtc_event",
":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 "rtc_base/checks.h"
#include "rtc_base/event.h"
#include "rtc_base/location.h"
#include "rtc_base/task_queue.h"
#include "rtc_base/thread_annotations.h"
namespace webrtc {
inline void SendTask(rtc::Location loc,
TaskQueueBase* task_queue,
inline void SendTask(TaskQueueBase* task_queue,
rtc::FunctionView<void()> task) {
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;
absl::Cleanup cleanup = [&event] { event.Set(); };
task_queue->PostTask([task, cleanup = std::move(cleanup)] { task(); });
RTC_CHECK(event.Wait(/*give_up_after_ms=*/rtc::Event::kForever,
/*warn_after_ms=*/10'000))
<< "Waited too long at " << loc.ToString();
/*warn_after_ms=*/10'000));
}
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 task executes on the task queue.
void SendTask(rtc::FunctionView<void()> task, rtc::Location loc) {
::webrtc::SendTask(loc, Get(), task);
void SendTask(rtc::FunctionView<void()> task) {
::webrtc::SendTask(Get(), task);
}
// Wait for the completion of all tasks posted prior to the
@ -58,7 +55,7 @@ class RTC_LOCKABLE TaskQueueForTest : public rtc::TaskQueue {
void WaitForPreviouslyPostedTasks() {
// 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.
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> obj;
webrtc::TaskQueueForTest queue("NewObjectCreatedOnTaskQueue");
queue.SendTask([&] { obj = std::make_unique<T>(); }, RTC_FROM_HERE);
queue.SendTask([&] { obj = std::make_unique<T>(); });
return obj;
}
@ -226,13 +226,11 @@ TEST(WeakPtrTest, WeakPtrInitiateAndUseOnDifferentThreads) {
// Create weak ptr on main thread
WeakPtr<Target> weak_ptr = target->factory.GetWeakPtr();
webrtc::TaskQueueForTest queue("queue");
queue.SendTask(
[&] {
// Dereference and invalide weak_ptr on another thread.
EXPECT_EQ(weak_ptr.get(), target.get());
target.reset();
},
RTC_FROM_HERE);
queue.SendTask([&] {
// Dereference and invalide weak_ptr on another thread.
EXPECT_EQ(weak_ptr.get(), target.get());
target.reset();
});
}
} // namespace rtc

4
test/call_test.cc
View file

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

37
test/network/network_emulation_manager.cc
View file

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

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

@ -355,7 +355,6 @@ if (!build_with_chromium) {
"../../../api/units:timestamp",
"../../../rtc_base:checks",
"../../../rtc_base:criticalsection",
"../../../rtc_base:location",
"../../../rtc_base:logging",
"../../../rtc_base:task_queue_for_test",
"../../../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
// of the call, so we force it after executor, which is among others is doing
// stats collection, was stopped.
task_queue_->SendTask(
[&stats_poller]() {
// Get final end-of-call stats.
stats_poller.PollStatsAndNotifyObservers();
},
RTC_FROM_HERE);
task_queue_->SendTask([&stats_poller]() {
// Get final end-of-call stats.
stats_poller.PollStatsAndNotifyObservers();
});
// We need to detach AEC dumping from peers, because dump uses `task_queue_`
// inside.
alice_->DetachAecDump();

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

@ -15,7 +15,6 @@
#include "absl/memory/memory.h"
#include "rtc_base/checks.h"
#include "rtc_base/location.h"
#include "rtc_base/logging.h"
#include "rtc_base/task_queue_for_test.h"
@ -38,7 +37,7 @@ void TestActivitiesExecutor::Stop() {
// Already stopped or not started.
return;
}
SendTask(RTC_FROM_HERE, task_queue_, [this]() {
SendTask(task_queue_, [this]() {
MutexLock lock(&lock_);
for (auto& handle : repeating_task_handles_) {
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) {
task_queue_.SendTask(std::move(task), RTC_FROM_HERE);
task_queue_.SendTask(std::move(task));
}
int16_t CallClient::Bind(EmulatedEndpoint* endpoint) {

2
test/scenario/video_frame_matcher.cc
View file

@ -29,7 +29,7 @@ VideoFrameMatcher::VideoFrameMatcher(
task_queue_("VideoAnalyzer") {}
VideoFrameMatcher::~VideoFrameMatcher() {
task_queue_.SendTask([this] { Finalize(); }, RTC_FROM_HERE);
task_queue_.SendTask([this] { Finalize(); });
}
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:checks",
"../rtc_base:gunit_helpers",
"../rtc_base:location",
"../rtc_base:logging",
"../rtc_base:macromagic",
"../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) {
TaskQueueForTest queue("OveruseFrameDetectorTestQueue");
queue.SendTask(
[&] {
overuse_detector_->StartCheckForOveruse(queue.Get(), options_,
observer_);
},
RTC_FROM_HERE);
queue.SendTask([&] {
overuse_detector_->StartCheckForOveruse(queue.Get(), options_, observer_);
});
rtc::Event event;
// Expect NormalUsage(). When called, stop the `overuse_detector_` and then
@ -917,12 +914,9 @@ TEST_F(OveruseFrameDetectorTest2, UpdatesExistingSamples) {
TEST_F(OveruseFrameDetectorTest2, RunOnTqNormalUsage) {
TaskQueueForTest queue("OveruseFrameDetectorTestQueue");
queue.SendTask(
[&] {
overuse_detector_->StartCheckForOveruse(queue.Get(), options_,
observer_);
},
RTC_FROM_HERE);
queue.SendTask([&] {
overuse_detector_->StartCheckForOveruse(queue.Get(), options_, observer_);
});
rtc::Event event;
// 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 {
// Block until all already posted tasks run to avoid races when such task
// accesses `this`.
SendTask(RTC_FROM_HERE, task_queue_, [] {});
SendTask(task_queue_, [] {});
}
void ModifyVideoConfigs(
@ -358,7 +358,7 @@ TEST_F(BandwidthEndToEndTest, ReportsSetEncoderRates) {
ASSERT_TRUE(Wait())
<< "Timed out while waiting for encoder SetRates() call.";
SendTask(RTC_FROM_HERE, task_queue_, [this]() {
SendTask(task_queue_, [this]() {
WaitForEncoderTargetBitrateMatchStats();
send_stream_->Stop();
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;
SendTask(
RTC_FROM_HERE, task_queue(),
[this, &renderer, &frame_forwarder, &sender_transport,
&receiver_transport]() {
task_queue(), [this, &renderer, &frame_forwarder, &sender_transport,
&receiver_transport]() {
CreateCalls();
sender_transport = std::make_unique<test::DirectTransport>(
@ -146,14 +145,13 @@ TEST_F(CallOperationEndToEndTest, RendersSingleDelayedFrame) {
EXPECT_TRUE(renderer.Wait())
<< "Timed out while waiting for the frame to render.";
SendTask(RTC_FROM_HERE, task_queue(),
[this, &sender_transport, &receiver_transport]() {
Stop();
DestroyStreams();
sender_transport.reset();
receiver_transport.reset();
DestroyCalls();
});
SendTask(task_queue(), [this, &sender_transport, &receiver_transport]() {
Stop();
DestroyStreams();
sender_transport.reset();
receiver_transport.reset();
DestroyCalls();
});
}
TEST_F(CallOperationEndToEndTest, TransmitsFirstFrame) {
@ -173,9 +171,8 @@ TEST_F(CallOperationEndToEndTest, TransmitsFirstFrame) {
std::unique_ptr<test::DirectTransport> receiver_transport;
SendTask(
RTC_FROM_HERE, task_queue(),
[this, &renderer, &frame_generator, &frame_forwarder, &sender_transport,
&receiver_transport]() {
task_queue(), [this, &renderer, &frame_generator, &frame_forwarder,
&sender_transport, &receiver_transport]() {
CreateCalls();
sender_transport = std::make_unique<test::DirectTransport>(
@ -216,14 +213,13 @@ TEST_F(CallOperationEndToEndTest, TransmitsFirstFrame) {
EXPECT_TRUE(renderer.Wait())
<< "Timed out while waiting for the frame to render.";
SendTask(RTC_FROM_HERE, task_queue(),
[this, &sender_transport, &receiver_transport]() {
Stop();
DestroyStreams();
sender_transport.reset();
receiver_transport.reset();
DestroyCalls();
});
SendTask(task_queue(), [this, &sender_transport, &receiver_transport]() {
Stop();
DestroyStreams();
sender_transport.reset();
receiver_transport.reset();
DestroyCalls();
});
}
} // 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 {
public:
MultiCodecReceiveTest() {
SendTask(RTC_FROM_HERE, task_queue(), [this]() {
SendTask(task_queue(), [this]() {
CreateCalls();
send_transport_.reset(new test::PacketTransport(
@ -151,7 +151,7 @@ class MultiCodecReceiveTest : public test::CallTest {
}
virtual ~MultiCodecReceiveTest() {
SendTask(RTC_FROM_HERE, task_queue(), [this]() {
SendTask(task_queue(), [this]() {
send_transport_.reset();
receive_transport_.reset();
DestroyCalls();
@ -243,7 +243,7 @@ void MultiCodecReceiveTest::RunTestWithCodecs(
return nullptr;
});
// Create and start call.
SendTask(RTC_FROM_HERE, task_queue(),
SendTask(task_queue(),
[this, &configs, &encoder_factory, &decoder_factory]() {
CreateSendConfig(1, 0, 0, send_transport_.get());
ConfigureEncoder(configs[0], &encoder_factory);
@ -261,21 +261,20 @@ void MultiCodecReceiveTest::RunTestWithCodecs(
for (size_t i = 1; i < configs.size(); ++i) {
// Recreate VideoSendStream with new config (codec, temporal layers).
SendTask(
RTC_FROM_HERE, task_queue(), [this, i, &configs, &encoder_factory]() {
DestroyVideoSendStreams();
observer_.Reset(PayloadNameToPayloadType(configs[i].payload_name));
SendTask(task_queue(), [this, i, &configs, &encoder_factory]() {
DestroyVideoSendStreams();
observer_.Reset(PayloadNameToPayloadType(configs[i].payload_name));
ConfigureEncoder(configs[i], &encoder_factory);
CreateVideoSendStreams();
GetVideoSendStream()->Start();
CreateFrameGeneratorCapturer(kFps, kWidth / 2, kHeight / 2);
ConnectVideoSourcesToStreams();
});
ConfigureEncoder(configs[i], &encoder_factory);
CreateVideoSendStreams();
GetVideoSendStream()->Start();
CreateFrameGeneratorCapturer(kFps, kWidth / 2, kHeight / 2);
ConnectVideoSourcesToStreams();
});
EXPECT_TRUE(observer_.Wait()) << "Timed out waiting for frames.";
}
SendTask(RTC_FROM_HERE, task_queue(), [this]() {
SendTask(task_queue(), [this]() {
Stop();
DestroyStreams();
});

4
video/end_to_end_tests/multi_stream_tester.cc
View file

@ -67,7 +67,7 @@ void MultiStreamTester::RunTest() {
CreateBuiltinVideoBitrateAllocatorFactory();
InternalDecoderFactory decoder_factory;
SendTask(RTC_FROM_HERE, task_queue.get(), [&]() {
SendTask(task_queue.get(), [&]() {
sender_call = absl::WrapUnique(Call::Create(config));
receiver_call = absl::WrapUnique(Call::Create(config));
sender_transport = CreateSendTransport(task_queue.get(), sender_call.get());
@ -129,7 +129,7 @@ void MultiStreamTester::RunTest() {
Wait();
SendTask(RTC_FROM_HERE, task_queue.get(), [&]() {
SendTask(task_queue.get(), [&]() {
for (size_t i = 0; i < kNumStreams; ++i) {
frame_generators[i]->Stop();
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/simulated_network.h"
#include "modules/rtp_rtcp/source/rtp_packet.h"
#include "rtc_base/location.h"
#include "rtc_base/synchronization/mutex.h"
#include "rtc_base/task_queue_for_test.h"
#include "system_wrappers/include/sleep.h"
@ -95,7 +94,7 @@ void NetworkStateEndToEndTest::VerifyNewVideoSendStreamsRespectNetworkState(
Transport* transport) {
test::VideoEncoderProxyFactory encoder_factory(encoder);
SendTask(RTC_FROM_HERE, task_queue(),
SendTask(task_queue(),
[this, network_to_bring_up, &encoder_factory, transport]() {
CreateSenderCall(Call::Config(send_event_log_.get()));
sender_call_->SignalChannelNetworkState(network_to_bring_up,
@ -113,7 +112,7 @@ void NetworkStateEndToEndTest::VerifyNewVideoSendStreamsRespectNetworkState(
SleepMs(kSilenceTimeoutMs);
SendTask(RTC_FROM_HERE, task_queue(), [this]() {
SendTask(task_queue(), [this]() {
Stop();
DestroyStreams();
DestroyCalls();
@ -126,7 +125,7 @@ void NetworkStateEndToEndTest::VerifyNewVideoReceiveStreamsRespectNetworkState(
std::unique_ptr<test::DirectTransport> sender_transport;
SendTask(
RTC_FROM_HERE, task_queue(),
task_queue(),
[this, &sender_transport, network_to_bring_up, transport]() {
CreateCalls();
receiver_call_->SignalChannelNetworkState(network_to_bring_up,
@ -148,7 +147,7 @@ void NetworkStateEndToEndTest::VerifyNewVideoReceiveStreamsRespectNetworkState(
SleepMs(kSilenceTimeoutMs);
SendTask(RTC_FROM_HERE, task_queue(), [this, &sender_transport]() {
SendTask(task_queue(), [this, &sender_transport]() {
Stop();
DestroyStreams();
sender_transport.reset();
@ -230,17 +229,16 @@ TEST_F(NetworkStateEndToEndTest, RespectsNetworkState) {
void SignalChannelNetworkState(Call* call,
MediaType media_type,
NetworkState network_state) {
SendTask(RTC_FROM_HERE, e2e_test_task_queue_,
[call, media_type, network_state] {
call->SignalChannelNetworkState(media_type, network_state);
});
SendTask(e2e_test_task_queue_, [call, media_type, network_state] {
call->SignalChannelNetworkState(media_type, network_state);
});
}
void PerformTest() override {
EXPECT_TRUE(encoded_frames_.Wait(kDefaultTimeoutMs))
<< "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.
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;
SendTask(
RTC_FROM_HERE, task_queue(),
[this, &observer, &send_transport, &receive_transport, &one_stream,
use_rtx]() {
task_queue(), [this, &observer, &send_transport, &receive_transport,
&one_stream, use_rtx]() {
CreateCalls();
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
// get set once (this could be due to using std::map::insert for instance).
for (size_t i = 0; i < 3; ++i) {
SendTask(RTC_FROM_HERE, task_queue(), [&]() {
SendTask(task_queue(), [&]() {
DestroyVideoSendStreams();
// 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.";
// Reconfigure back to use all streams.
SendTask(RTC_FROM_HERE, task_queue(), [this]() {
SendTask(task_queue(), [this]() {
GetVideoSendStream()->ReconfigureVideoEncoder(
GetVideoEncoderConfig()->Copy());
});
@ -367,14 +366,14 @@ void RtpRtcpEndToEndTest::TestRtpStatePreservation(
<< "Timed out waiting for all SSRCs to send packets.";
// 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());
});
observer.ResetExpectedSsrcs(1);
EXPECT_TRUE(observer.Wait()) << "Timed out waiting for single RTP packet.";
// Reconfigure back to use all streams.
SendTask(RTC_FROM_HERE, task_queue(), [this]() {
SendTask(task_queue(), [this]() {
GetVideoSendStream()->ReconfigureVideoEncoder(
GetVideoEncoderConfig()->Copy());
});
@ -383,14 +382,13 @@ void RtpRtcpEndToEndTest::TestRtpStatePreservation(
<< "Timed out waiting for all SSRCs to send packets.";
}
SendTask(RTC_FROM_HERE, task_queue(),
[this, &send_transport, &receive_transport]() {
Stop();
DestroyStreams();
send_transport.reset();
receive_transport.reset();
DestroyCalls();
});
SendTask(task_queue(), [this, &send_transport, &receive_transport]() {
Stop();
DestroyStreams();
send_transport.reset();
receive_transport.reset();
DestroyCalls();
});
}
TEST_F(RtpRtcpEndToEndTest, RestartingSendStreamPreservesRtpState) {
@ -484,7 +482,7 @@ TEST_F(RtpRtcpEndToEndTest, DISABLED_TestFlexfecRtpStatePreservation) {
test::FunctionVideoEncoderFactory encoder_factory(
[]() { return VP8Encoder::Create(); });
SendTask(RTC_FROM_HERE, task_queue(), [&]() {
SendTask(task_queue(), [&]() {
CreateCalls();
BuiltInNetworkBehaviorConfig lossy_delayed_link;
@ -563,7 +561,7 @@ TEST_F(RtpRtcpEndToEndTest, DISABLED_TestFlexfecRtpStatePreservation) {
// Initial test.
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.
Stop();
observer.ResetPacketCount();
@ -572,7 +570,7 @@ TEST_F(RtpRtcpEndToEndTest, DISABLED_TestFlexfecRtpStatePreservation) {
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.
DestroyVideoSendStreams();
observer.ResetPacketCount();
@ -584,13 +582,12 @@ TEST_F(RtpRtcpEndToEndTest, DISABLED_TestFlexfecRtpStatePreservation) {
EXPECT_TRUE(observer.Wait()) << "Timed out waiting for packets.";
// Cleanup.
SendTask(RTC_FROM_HERE, task_queue(),
[this, &send_transport, &receive_transport]() {
Stop();
DestroyStreams();
send_transport.reset();
receive_transport.reset();
DestroyCalls();
});
SendTask(task_queue(), [this, &send_transport, &receive_transport]() {
Stop();
DestroyStreams();
send_transport.reset();
receive_transport.reset();
DestroyCalls();
});
}
} // 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;
SendTask(
RTC_FROM_HERE, task_queue(),
task_queue(),
[this, &send_transport, &receive_transport, &input_observer]() {
CreateCalls();
@ -117,14 +117,13 @@ TEST_F(SsrcEndToEndTest, UnknownRtpPacketGivesUnknownSsrcReturnCode) {
// Wait() waits for a received packet.
EXPECT_TRUE(input_observer->Wait());
SendTask(RTC_FROM_HERE, task_queue(),
[this, &send_transport, &receive_transport]() {
Stop();
DestroyStreams();
send_transport.reset();
receive_transport.reset();
DestroyCalls();
});
SendTask(task_queue(), [this, &send_transport, &receive_transport]() {
Stop();
DestroyStreams();
send_transport.reset();
receive_transport.reset();
DestroyCalls();
});
}
void SsrcEndToEndTest::TestSendsSetSsrcs(size_t num_ssrcs,
@ -203,7 +202,7 @@ void SsrcEndToEndTest::TestSendsSetSsrcs(size_t num_ssrcs,
if (send_single_ssrc_first_) {
// Set full simulcast and continue with the rest of the SSRCs.
SendTask(RTC_FROM_HERE, task_queue_, [&]() {
SendTask(task_queue_, [&]() {
send_stream_->ReconfigureVideoEncoder(
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_);
VideoSendStream::Stats stats;
SendTask(RTC_FROM_HERE, task_queue_,
[&]() { stats = send_stream_->GetStats(); });
SendTask(task_queue_, [&]() { stats = send_stream_->GetStats(); });
size_t expected_num_streams =
kNumSimulcastStreams + expected_send_ssrcs_.size();
@ -299,8 +298,7 @@ TEST_F(StatsEndToEndTest, GetStats) {
while (now_ms < stop_time_ms) {
if (!receive_ok && task_queue_) {
SendTask(RTC_FROM_HERE, task_queue_,
[&]() { receive_ok = CheckReceiveStats(); });
SendTask(task_queue_, [&]() { receive_ok = CheckReceiveStats(); });
}
if (!send_ok)
send_ok = CheckSendStats();
@ -375,7 +373,7 @@ TEST_F(StatsEndToEndTest, TimingFramesAreReported) {
void PerformTest() override {
// No frames reported initially.
SendTask(RTC_FROM_HERE, task_queue_, [&]() {
SendTask(task_queue_, [&]() {
for (const auto& receive_stream : receive_streams_) {
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.
SleepMs(kDefaultTimingFramesDelayMs + 100);
// 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_) {
EXPECT_TRUE(receive_stream->GetStats().timing_frame_info);
}
@ -507,9 +505,8 @@ TEST_F(StatsEndToEndTest, MAYBE_ContentTypeSwitches) {
VideoEncoderConfig encoder_config_with_screenshare;
SendTask(
RTC_FROM_HERE, task_queue(),
[this, &test, &send_config, &recv_config,
&encoder_config_with_screenshare]() {
task_queue(), [this, &test, &send_config, &recv_config,
&encoder_config_with_screenshare]() {
CreateSenderCall(send_config);
CreateReceiverCall(recv_config);
@ -547,18 +544,17 @@ TEST_F(StatsEndToEndTest, MAYBE_ContentTypeSwitches) {
test.PerformTest();
// Replace old send stream.
SendTask(RTC_FROM_HERE, task_queue(),
[this, &encoder_config_with_screenshare]() {
DestroyVideoSendStreams();
CreateVideoSendStream(encoder_config_with_screenshare);
SetVideoDegradation(DegradationPreference::BALANCED);
GetVideoSendStream()->Start();
});
SendTask(task_queue(), [this, &encoder_config_with_screenshare]() {
DestroyVideoSendStreams();
CreateVideoSendStream(encoder_config_with_screenshare);
SetVideoDegradation(DegradationPreference::BALANCED);
GetVideoSendStream()->Start();
});
// Continue to run test but now with screenshare.
test.PerformTest();
SendTask(RTC_FROM_HERE, task_queue(), [this]() {
SendTask(task_queue(), [this]() {
Stop();
DestroyStreams();
send_transport_.reset();
@ -700,7 +696,7 @@ TEST_F(StatsEndToEndTest, CallReportsRttForSender) {
std::unique_ptr<test::DirectTransport> sender_transport;
std::unique_ptr<test::DirectTransport> receiver_transport;
SendTask(RTC_FROM_HERE, task_queue(),
SendTask(task_queue(),
[this, &sender_transport, &receiver_transport]() {
BuiltInNetworkBehaviorConfig config;
config.queue_delay_ms = kSendDelayMs;
@ -733,7 +729,7 @@ TEST_F(StatsEndToEndTest, CallReportsRttForSender) {
int64_t start_time_ms = clock_->TimeInMilliseconds();
while (true) {
Call::Stats stats;
SendTask(RTC_FROM_HERE, task_queue(),
SendTask(task_queue(),
[this, &stats]() { stats = sender_call_->GetStats(); });
ASSERT_GE(start_time_ms + kDefaultTimeoutMs, clock_->TimeInMilliseconds())
<< "No RTT stats before timeout!";
@ -747,13 +743,12 @@ TEST_F(StatsEndToEndTest, CallReportsRttForSender) {
SleepMs(10);
}
SendTask(RTC_FROM_HERE, task_queue(),
[this, &sender_transport, &receiver_transport]() {
Stop();
DestroyStreams();
sender_transport.reset();
receiver_transport.reset();
DestroyCalls();
});
SendTask(task_queue(), [this, &sender_transport, &receiver_transport]() {
Stop();
DestroyStreams();
sender_transport.reset();
receiver_transport.reset();
DestroyCalls();
});
}
} // namespace webrtc

16
video/picture_id_tests.cc
View file

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

2
video/video_analyzer.cc
View file

@ -397,7 +397,7 @@ void VideoAnalyzer::Wait() {
if (iteration > 0)
printf("- Farewell, sweet Concorde!\n");
SendTask(RTC_FROM_HERE, task_queue_, [&] { stats_polling_task.Stop(); });
SendTask(task_queue_, [&] { stats_polling_task.Stop(); });
PrintResults();
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') {
// Drive the message loop for the thread running the task_queue
SendTask(RTC_FROM_HERE, task_queue, [&]() {
SendTask(task_queue, [&]() {
MSG msg;
if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
TranslateMessage(&msg);
@ -1237,20 +1237,19 @@ void VideoQualityTest::RunWithAnalyzer(const Params& params) {
recv_event_log_ = std::make_unique<RtcEventLogNull>();
}
SendTask(RTC_FROM_HERE, task_queue(),
[this, &params, &send_transport, &recv_transport]() {
Call::Config send_call_config(send_event_log_.get());
Call::Config recv_call_config(recv_event_log_.get());
send_call_config.bitrate_config = params.call.call_bitrate_config;
recv_call_config.bitrate_config = params.call.call_bitrate_config;
if (params_.audio.enabled)
InitializeAudioDevice(&send_call_config, &recv_call_config,
params_.audio.use_real_adm);
SendTask(task_queue(), [this, &params, &send_transport, &recv_transport]() {
Call::Config send_call_config(send_event_log_.get());
Call::Config recv_call_config(recv_event_log_.get());
send_call_config.bitrate_config = params.call.call_bitrate_config;
recv_call_config.bitrate_config = params.call.call_bitrate_config;
if (params_.audio.enabled)
InitializeAudioDevice(&send_call_config, &recv_call_config,
params_.audio.use_real_adm);
CreateCalls(send_call_config, recv_call_config);
send_transport = CreateSendTransport();
recv_transport = CreateReceiveTransport();
});
CreateCalls(send_call_config, recv_call_config);
send_transport = CreateSendTransport();
recv_transport = CreateReceiveTransport();
});
std::string graph_title = params_.analyzer.graph_title;
if (graph_title.empty())
@ -1273,7 +1272,7 @@ void VideoQualityTest::RunWithAnalyzer(const Params& params) {
is_quick_test_enabled, clock_, params_.logging.rtp_dump_name,
task_queue());
SendTask(RTC_FROM_HERE, task_queue(), [&]() {
SendTask(task_queue(), [&]() {
analyzer_->SetCall(sender_call_.get());
analyzer_->SetReceiver(receiver_call_->Receiver());
send_transport->SetReceiver(analyzer_.get());
@ -1319,7 +1318,7 @@ void VideoQualityTest::RunWithAnalyzer(const Params& params) {
analyzer_->Wait();
SendTask(RTC_FROM_HERE, task_queue(), [&]() {
SendTask(task_queue(), [&]() {
StopThumbnails();
Stop();
@ -1461,7 +1460,7 @@ void VideoQualityTest::RunWithRenderers(const Params& params) {
recv_event_log_ = std::make_unique<RtcEventLogNull>();
}
SendTask(RTC_FROM_HERE, task_queue(), [&]() {
SendTask(task_queue(), [&]() {
params_ = params;
CheckParamsAndInjectionComponents();
@ -1550,7 +1549,7 @@ void VideoQualityTest::RunWithRenderers(const Params& params) {
PressEnterToContinue(task_queue());
SendTask(RTC_FROM_HERE, task_queue(), [&]() {
SendTask(task_queue(), [&]() {
Stop();
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.bitrate_priority, kDefaultBitratePriority);
}));
test_queue_.SendTask(
[&] {
vss_impl->Start();
EXPECT_CALL(bitrate_allocator_, RemoveObserver(vss_impl.get()))
.Times(1);
vss_impl->Stop();
},
RTC_FROM_HERE);
test_queue_.SendTask([&] {
vss_impl->Start();
EXPECT_CALL(bitrate_allocator_, RemoveObserver(vss_impl.get())).Times(1);
vss_impl->Stop();
});
}
TEST_F(VideoSendStreamImplTest, UpdatesObserverOnConfigurationChange) {
@ -267,8 +264,7 @@ TEST_F(VideoSendStreamImplTest, UpdatesObserverOnConfigurationChange) {
VideoEncoderConfig::ContentType::kRealtimeVideo,
min_transmit_bitrate_bps);
vss_impl->Stop();
},
RTC_FROM_HERE);
});
}
TEST_F(VideoSendStreamImplTest, UpdatesObserverOnConfigurationChangeWithAlr) {
@ -335,8 +331,7 @@ TEST_F(VideoSendStreamImplTest, UpdatesObserverOnConfigurationChangeWithAlr) {
VideoEncoderConfig::ContentType::kScreen,
min_transmit_bitrate_bps);
vss_impl->Stop();
},
RTC_FROM_HERE);
});
}
TEST_F(VideoSendStreamImplTest,
@ -398,8 +393,7 @@ TEST_F(VideoSendStreamImplTest,
VideoEncoderConfig::ContentType::kRealtimeVideo,
/*min_transmit_bitrate_bps=*/0);
vss_impl->Stop();
},
RTC_FROM_HERE);
});
}
TEST_F(VideoSendStreamImplTest, SetsScreensharePacingFactorWithFeedback) {
@ -414,12 +408,10 @@ TEST_F(VideoSendStreamImplTest, SetsScreensharePacingFactorWithFeedback) {
auto vss_impl = CreateVideoSendStreamImpl(
kDefaultInitialBitrateBps, kDefaultBitratePriority,
VideoEncoderConfig::ContentType::kScreen);
test_queue_.SendTask(
[&] {
vss_impl->Start();
vss_impl->Stop();
},
RTC_FROM_HERE);
test_queue_.SendTask([&] {
vss_impl->Start();
vss_impl->Stop();
});
}
TEST_F(VideoSendStreamImplTest, DoesNotSetPacingFactorWithoutFeedback) {
@ -427,13 +419,11 @@ TEST_F(VideoSendStreamImplTest, DoesNotSetPacingFactorWithoutFeedback) {
auto vss_impl = CreateVideoSendStreamImpl(
kDefaultInitialBitrateBps, kDefaultBitratePriority,
VideoEncoderConfig::ContentType::kScreen);
test_queue_.SendTask(
[&] {
EXPECT_CALL(transport_controller_, SetPacingFactor(_)).Times(0);
vss_impl->Start();
vss_impl->Stop();
},
RTC_FROM_HERE);
test_queue_.SendTask([&] {
EXPECT_CALL(transport_controller_, SetPacingFactor(_)).Times(0);
vss_impl->Start();
vss_impl->Stop();
});
}
TEST_F(VideoSendStreamImplTest, ForwardsVideoBitrateAllocationWhenEnabled) {
@ -482,8 +472,7 @@ TEST_F(VideoSendStreamImplTest, ForwardsVideoBitrateAllocationWhenEnabled) {
sink->OnBitrateAllocationUpdated(alloc);
vss_impl->Stop();
},
RTC_FROM_HERE);
});
}
TEST_F(VideoSendStreamImplTest, ThrottlesVideoBitrateAllocationWhenTooSimilar) {
@ -542,8 +531,7 @@ TEST_F(VideoSendStreamImplTest, ThrottlesVideoBitrateAllocationWhenTooSimilar) {
sink->OnBitrateAllocationUpdated(updated_alloc);
vss_impl->Stop();
},
RTC_FROM_HERE);
});
}
TEST_F(VideoSendStreamImplTest, ForwardsVideoBitrateAllocationOnLayerChange) {
@ -588,8 +576,7 @@ TEST_F(VideoSendStreamImplTest, ForwardsVideoBitrateAllocationOnLayerChange) {
sink->OnBitrateAllocationUpdated(updated_alloc);
vss_impl->Stop();
},
RTC_FROM_HERE);
});
}
TEST_F(VideoSendStreamImplTest, ForwardsVideoBitrateAllocationAfterTimeout) {
@ -686,8 +673,7 @@ TEST_F(VideoSendStreamImplTest, ForwardsVideoBitrateAllocationAfterTimeout) {
}
vss_impl->Stop();
},
RTC_FROM_HERE);
});
}
TEST_F(VideoSendStreamImplTest, CallsVideoStreamEncoderOnBitrateUpdate) {
@ -790,8 +776,7 @@ TEST_F(VideoSendStreamImplTest, CallsVideoStreamEncoderOnBitrateUpdate) {
OnBitrateUpdated(DataRate::Zero(), DataRate::Zero(),
DataRate::Zero(), 0, 0, 0));
vss_impl->Stop();
},
RTC_FROM_HERE);
});
}
TEST_F(VideoSendStreamImplTest, DisablesPaddingOnPausedEncoder) {
@ -863,8 +848,7 @@ TEST_F(VideoSendStreamImplTest, DisablesPaddingOnPausedEncoder) {
->OnEncodedImage(encoded_image, &codec_specific);
// Only after actual frame is encoded are we enabling the padding.
EXPECT_GT(padding_bitrate, 0);
},
RTC_FROM_HERE);
});
rtc::Event done;
test_queue_.Get()->PostDelayedTask(
@ -901,8 +885,7 @@ TEST_F(VideoSendStreamImplTest, KeepAliveOnDroppedFrame) {
EncodedImageCallback::DropReason::kDroppedByEncoder);
EXPECT_CALL(bitrate_allocator_, RemoveObserver(vss_impl.get()))
.Times(0);
},
RTC_FROM_HERE);
});
rtc::Event done;
test_queue_.Get()->PostDelayedTask(
@ -1025,8 +1008,7 @@ TEST_F(VideoSendStreamImplTest, ConfiguresBitratesForSvc) {
::testing::Mock::VerifyAndClearExpectations(&bitrate_allocator_);
vss_impl->Stop();
},
RTC_FROM_HERE);
});
}
}
} // namespace internal

45
video/video_send_stream_tests.cc
View file

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