Reland "Remove Invoke from VideoChannel::FillBitrateInfo."
This reverts commit 48a4d33719390b7bcaf8445a1581a00825f67bfb.
Reason for reland:
Relanding the original change but without the modification for
VideoSendStream::GetStats. Essentially there's a TODO there to fix
the downstream issue, which seems to be benign.
Original change's description:
> Revert "Remove Invoke from VideoChannel::FillBitrateInfo."
>
> This reverts commit 1a1795768e1bdb65054ebe15aa238c6edc78dd14.
>
> Reason for revert: Speculative revert (breaks downstream project).
>
> Original change's description:
> > Remove Invoke from VideoChannel::FillBitrateInfo.
> >
> > The method is relied upon by StatsCollector where it was called from the
> > signaling thread in a loop. Now there's at most one invoke (not N).
> >
> > Uncommenting thread checks and removing TODOs in SendStatisticsProxy,
> > VideoSendStream. Updating all related tests that fetched stats from
> > the wrong context.
> >
> > Bug: webrtc:12726
> > Change-Id: Ia7db1afd7e103ec4f9816f5647203c4e2495586e
> > Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/216688
> > Commit-Queue: Tommi <tommi@webrtc.org>
> > Reviewed-by: Niels Moller <nisse@webrtc.org>
> > Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org>
> > Cr-Commit-Position: refs/heads/master@{#33894}
>
> TBR=ilnik@webrtc.org,nisse@webrtc.org,tommi@webrtc.org,webrtc-scoped@luci-project-accounts.iam.gserviceaccount.com
>
> Change-Id: I2520957cdb33492d187f04320c7416788fd0f820
> No-Presubmit: true
> No-Tree-Checks: true
> No-Try: true
> Bug: webrtc:12726
> Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/217240
> Reviewed-by: Mirko Bonadei <mbonadei@webrtc.org>
> Commit-Queue: Mirko Bonadei <mbonadei@webrtc.org>
> Cr-Commit-Position: refs/heads/master@{#33898}
# Not skipping CQ checks because this is a reland.
Bug: webrtc:12726
Change-Id: I41cce3b11a29905cde982c22e82b9b1f5a98e654
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/217222
Reviewed-by: Tommi <tommi@webrtc.org>
Reviewed-by: Niels Moller <nisse@webrtc.org>
Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org>
Commit-Queue: Tommi <tommi@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#33902}
diff --git a/call/call_perf_tests.cc b/call/call_perf_tests.cc
index 47d6e90..c163ab2 100644
--- a/call/call_perf_tests.cc
+++ b/call/call_perf_tests.cc
@@ -654,7 +654,8 @@
static const int kAcceptableBitrateErrorMargin = 15; // +- 7
class BitrateObserver : public test::EndToEndTest {
public:
- explicit BitrateObserver(bool using_min_transmit_bitrate)
+ explicit BitrateObserver(bool using_min_transmit_bitrate,
+ TaskQueueBase* task_queue)
: EndToEndTest(kLongTimeoutMs),
send_stream_(nullptr),
converged_(false),
@@ -667,27 +668,31 @@
? kMaxAcceptableTransmitBitrate
: (kMaxEncodeBitrateKbps +
kAcceptableBitrateErrorMargin / 2)),
- num_bitrate_observations_in_range_(0) {}
+ num_bitrate_observations_in_range_(0),
+ task_queue_(task_queue) {}
private:
// TODO(holmer): Run this with a timer instead of once per packet.
Action OnSendRtp(const uint8_t* packet, size_t length) override {
- VideoSendStream::Stats stats = send_stream_->GetStats();
- if (!stats.substreams.empty()) {
- RTC_DCHECK_EQ(1, stats.substreams.size());
- int bitrate_kbps =
- stats.substreams.begin()->second.total_bitrate_bps / 1000;
- if (bitrate_kbps > min_acceptable_bitrate_ &&
- bitrate_kbps < max_acceptable_bitrate_) {
- converged_ = true;
- ++num_bitrate_observations_in_range_;
- if (num_bitrate_observations_in_range_ ==
- kNumBitrateObservationsInRange)
- observation_complete_.Set();
+ task_queue_->PostTask(ToQueuedTask([this]() {
+ VideoSendStream::Stats stats = send_stream_->GetStats();
+
+ if (!stats.substreams.empty()) {
+ RTC_DCHECK_EQ(1, stats.substreams.size());
+ int bitrate_kbps =
+ stats.substreams.begin()->second.total_bitrate_bps / 1000;
+ if (bitrate_kbps > min_acceptable_bitrate_ &&
+ bitrate_kbps < max_acceptable_bitrate_) {
+ converged_ = true;
+ ++num_bitrate_observations_in_range_;
+ if (num_bitrate_observations_in_range_ ==
+ kNumBitrateObservationsInRange)
+ observation_complete_.Set();
+ }
+ if (converged_)
+ bitrate_kbps_list_.push_back(bitrate_kbps);
}
- if (converged_)
- bitrate_kbps_list_.push_back(bitrate_kbps);
- }
+ }));
return SEND_PACKET;
}
@@ -724,7 +729,8 @@
const int max_acceptable_bitrate_;
int num_bitrate_observations_in_range_;
std::vector<double> bitrate_kbps_list_;
- } test(pad_to_min_bitrate);
+ TaskQueueBase* task_queue_;
+ } test(pad_to_min_bitrate, task_queue());
fake_encoder_max_bitrate_ = kMaxEncodeBitrateKbps;
RunBaseTest(&test);
@@ -775,7 +781,7 @@
class BitrateObserver : public test::EndToEndTest, public test::FakeEncoder {
public:
- BitrateObserver()
+ explicit BitrateObserver(TaskQueueBase* task_queue)
: EndToEndTest(kDefaultTimeoutMs),
FakeEncoder(Clock::GetRealTimeClock()),
encoder_inits_(0),
@@ -784,7 +790,8 @@
frame_generator_(nullptr),
encoder_factory_(this),
bitrate_allocator_factory_(
- CreateBuiltinVideoBitrateAllocatorFactory()) {}
+ CreateBuiltinVideoBitrateAllocatorFactory()),
+ task_queue_(task_queue) {}
int32_t InitEncode(const VideoCodec* config,
const VideoEncoder::Settings& settings) override {
@@ -854,7 +861,9 @@
ASSERT_TRUE(time_to_reconfigure_.Wait(kDefaultTimeoutMs))
<< "Timed out before receiving an initial high bitrate.";
frame_generator_->ChangeResolution(kDefaultWidth * 2, kDefaultHeight * 2);
- send_stream_->ReconfigureVideoEncoder(encoder_config_.Copy());
+ SendTask(RTC_FROM_HERE, task_queue_, [&]() {
+ send_stream_->ReconfigureVideoEncoder(encoder_config_.Copy());
+ });
EXPECT_TRUE(Wait())
<< "Timed out while waiting for a couple of high bitrate estimates "
"after reconfiguring the send stream.";
@@ -869,7 +878,8 @@
test::VideoEncoderProxyFactory encoder_factory_;
std::unique_ptr<VideoBitrateAllocatorFactory> bitrate_allocator_factory_;
VideoEncoderConfig encoder_config_;
- } test;
+ TaskQueueBase* task_queue_;
+ } test(task_queue());
RunBaseTest(&test);
}
diff --git a/call/rampup_tests.cc b/call/rampup_tests.cc
index e2ea55b..37e3e6c 100644
--- a/call/rampup_tests.cc
+++ b/call/rampup_tests.cc
@@ -370,7 +370,10 @@
if (!send_stream_)
return;
- VideoSendStream::Stats send_stats = send_stream_->GetStats();
+ VideoSendStream::Stats send_stats;
+ SendTask(RTC_FROM_HERE, task_queue_,
+ [&] { send_stats = send_stream_->GetStats(); });
+
send_stream_ = nullptr; // To avoid dereferencing a bad pointer.
size_t total_packets_sent = 0;
diff --git a/common_video/h264/h264_bitstream_parser.cc b/common_video/h264/h264_bitstream_parser.cc
index b0ada92..f0bc8bb 100644
--- a/common_video/h264/h264_bitstream_parser.cc
+++ b/common_video/h264/h264_bitstream_parser.cc
@@ -275,14 +275,14 @@
sps_ = SpsParser::ParseSps(slice + H264::kNaluTypeSize,
length - H264::kNaluTypeSize);
if (!sps_)
- RTC_LOG(LS_WARNING) << "Unable to parse SPS from H264 bitstream.";
+ RTC_DLOG(LS_WARNING) << "Unable to parse SPS from H264 bitstream.";
break;
}
case H264::NaluType::kPps: {
pps_ = PpsParser::ParsePps(slice + H264::kNaluTypeSize,
length - H264::kNaluTypeSize);
if (!pps_)
- RTC_LOG(LS_WARNING) << "Unable to parse PPS from H264 bitstream.";
+ RTC_DLOG(LS_WARNING) << "Unable to parse PPS from H264 bitstream.";
break;
}
case H264::NaluType::kAud:
@@ -291,7 +291,7 @@
default:
Result res = ParseNonParameterSetNalu(slice, length, nalu_type);
if (res != kOk)
- RTC_LOG(LS_INFO) << "Failed to parse bitstream. Error: " << res;
+ RTC_DLOG(LS_INFO) << "Failed to parse bitstream. Error: " << res;
break;
}
}
diff --git a/pc/channel.cc b/pc/channel.cc
index 883e82b..f66083f 100644
--- a/pc/channel.cc
+++ b/pc/channel.cc
@@ -1065,9 +1065,9 @@
}
void VideoChannel::FillBitrateInfo(BandwidthEstimationInfo* bwe_info) {
+ RTC_DCHECK_RUN_ON(worker_thread());
VideoMediaChannel* mc = media_channel();
- InvokeOnWorker<void>(RTC_FROM_HERE,
- [mc, bwe_info] { mc->FillBitrateInfo(bwe_info); });
+ mc->FillBitrateInfo(bwe_info);
}
bool VideoChannel::SetLocalContent_w(const MediaContentDescription* content,
diff --git a/pc/stats_collector.cc b/pc/stats_collector.cc
index 8955729..8648764 100644
--- a/pc/stats_collector.cc
+++ b/pc/stats_collector.cc
@@ -1026,16 +1026,25 @@
// Fill in target encoder bitrate, actual encoder bitrate, rtx bitrate, etc.
// TODO(holmer): Also fill this in for audio.
- for (const auto& transceiver : pc_->GetTransceiversInternal()) {
+ auto transceivers = pc_->GetTransceiversInternal();
+ std::vector<cricket::VideoChannel*> video_channels;
+ for (const auto& transceiver : transceivers) {
if (transceiver->media_type() != cricket::MEDIA_TYPE_VIDEO) {
continue;
}
auto* video_channel =
static_cast<cricket::VideoChannel*>(transceiver->internal()->channel());
- if (!video_channel) {
- continue;
+ if (video_channel) {
+ video_channels.push_back(video_channel);
}
- video_channel->FillBitrateInfo(&bwe_info);
+ }
+
+ if (!video_channels.empty()) {
+ pc_->worker_thread()->Invoke<void>(RTC_FROM_HERE, [&] {
+ for (const auto& channel : video_channels) {
+ channel->FillBitrateInfo(&bwe_info);
+ }
+ });
}
StatsReport::Id report_id(StatsReport::NewBandwidthEstimationId());
diff --git a/test/scenario/scenario_unittest.cc b/test/scenario/scenario_unittest.cc
index fc370fb..6861151 100644
--- a/test/scenario/scenario_unittest.cc
+++ b/test/scenario/scenario_unittest.cc
@@ -182,7 +182,11 @@
s.RunFor(TimeDelta::Seconds(10));
// Make sure retransmissions have happened.
int retransmit_packets = 0;
- for (const auto& substream : video->send()->GetStats().substreams) {
+
+ VideoSendStream::Stats stats;
+ alice->SendTask([&]() { stats = video->send()->GetStats(); });
+
+ for (const auto& substream : stats.substreams) {
retransmit_packets += substream.second.rtp_stats.retransmitted.packets;
}
EXPECT_GT(retransmit_packets, 0);
diff --git a/test/scenario/stats_collection_unittest.cc b/test/scenario/stats_collection_unittest.cc
index 593cecd..96b2830 100644
--- a/test/scenario/stats_collection_unittest.cc
+++ b/test/scenario/stats_collection_unittest.cc
@@ -33,8 +33,14 @@
auto* audio = s->CreateAudioStream(route->forward(), AudioStreamConfig());
s->Every(TimeDelta::Seconds(1), [=] {
collectors->call.AddStats(caller->GetStats());
- collectors->video_send.AddStats(video->send()->GetStats(), s->Now());
- collectors->audio_receive.AddStats(audio->receive()->GetStats());
+
+ VideoSendStream::Stats send_stats;
+ caller->SendTask([&]() { send_stats = video->send()->GetStats(); });
+ collectors->video_send.AddStats(send_stats, s->Now());
+
+ AudioReceiveStream::Stats receive_stats;
+ caller->SendTask([&]() { receive_stats = audio->receive()->GetStats(); });
+ collectors->audio_receive.AddStats(receive_stats);
// Querying the video stats from within the expected runtime environment
// (i.e. the TQ that belongs to the CallClient, not the Scenario TQ that
diff --git a/test/scenario/video_stream_unittest.cc b/test/scenario/video_stream_unittest.cc
index 95936c7..c1649a3 100644
--- a/test/scenario/video_stream_unittest.cc
+++ b/test/scenario/video_stream_unittest.cc
@@ -130,7 +130,9 @@
auto video = s.CreateVideoStream(route->forward(), VideoStreamConfig());
s.RunFor(TimeDelta::Seconds(1));
int retransmit_packets = 0;
- for (const auto& substream : video->send()->GetStats().substreams) {
+ VideoSendStream::Stats stats;
+ route->first()->SendTask([&]() { stats = video->send()->GetStats(); });
+ for (const auto& substream : stats.substreams) {
retransmit_packets += substream.second.rtp_stats.retransmitted.packets;
}
EXPECT_GT(retransmit_packets, 0);
@@ -152,7 +154,8 @@
c->stream.use_ulpfec = true;
});
s.RunFor(TimeDelta::Seconds(5));
- VideoSendStream::Stats video_stats = video->send()->GetStats();
+ VideoSendStream::Stats video_stats;
+ route->first()->SendTask([&]() { video_stats = video->send()->GetStats(); });
EXPECT_GT(video_stats.substreams.begin()->second.rtp_stats.fec.packets, 0u);
}
TEST(VideoStreamTest, SendsFecWithFlexFec) {
@@ -169,7 +172,8 @@
c->stream.use_flexfec = true;
});
s.RunFor(TimeDelta::Seconds(5));
- VideoSendStream::Stats video_stats = video->send()->GetStats();
+ VideoSendStream::Stats video_stats;
+ route->first()->SendTask([&]() { video_stats = video->send()->GetStats(); });
EXPECT_GT(video_stats.substreams.begin()->second.rtp_stats.fec.packets, 0u);
}
diff --git a/video/end_to_end_tests/ssrc_tests.cc b/video/end_to_end_tests/ssrc_tests.cc
index cedae39..0c26311 100644
--- a/video/end_to_end_tests/ssrc_tests.cc
+++ b/video/end_to_end_tests/ssrc_tests.cc
@@ -132,13 +132,15 @@
public:
SendsSetSsrcs(const uint32_t* ssrcs,
size_t num_ssrcs,
- bool send_single_ssrc_first)
+ bool send_single_ssrc_first,
+ TaskQueueBase* task_queue)
: EndToEndTest(kDefaultTimeoutMs),
num_ssrcs_(num_ssrcs),
send_single_ssrc_first_(send_single_ssrc_first),
ssrcs_to_observe_(num_ssrcs),
expect_single_ssrc_(send_single_ssrc_first),
- send_stream_(nullptr) {
+ send_stream_(nullptr),
+ task_queue_(task_queue) {
for (size_t i = 0; i < num_ssrcs; ++i)
valid_ssrcs_[ssrcs[i]] = true;
}
@@ -200,8 +202,10 @@
if (send_single_ssrc_first_) {
// Set full simulcast and continue with the rest of the SSRCs.
- send_stream_->ReconfigureVideoEncoder(
- std::move(video_encoder_config_all_streams_));
+ SendTask(RTC_FROM_HERE, task_queue_, [&]() {
+ send_stream_->ReconfigureVideoEncoder(
+ std::move(video_encoder_config_all_streams_));
+ });
EXPECT_TRUE(Wait()) << "Timed out while waiting on additional SSRCs.";
}
}
@@ -218,7 +222,8 @@
VideoSendStream* send_stream_;
VideoEncoderConfig video_encoder_config_all_streams_;
- } test(kVideoSendSsrcs, num_ssrcs, send_single_ssrc_first);
+ TaskQueueBase* task_queue_;
+ } test(kVideoSendSsrcs, num_ssrcs, send_single_ssrc_first, task_queue());
RunBaseTest(&test);
}
diff --git a/video/end_to_end_tests/stats_tests.cc b/video/end_to_end_tests/stats_tests.cc
index ae0532b..349f551 100644
--- a/video/end_to_end_tests/stats_tests.cc
+++ b/video/end_to_end_tests/stats_tests.cc
@@ -154,7 +154,10 @@
bool CheckSendStats() {
RTC_DCHECK(send_stream_);
- VideoSendStream::Stats stats = send_stream_->GetStats();
+
+ VideoSendStream::Stats stats;
+ SendTask(RTC_FROM_HERE, task_queue_,
+ [&]() { stats = send_stream_->GetStats(); });
size_t expected_num_streams =
kNumSimulcastStreams + expected_send_ssrcs_.size();
diff --git a/video/send_statistics_proxy.cc b/video/send_statistics_proxy.cc
index 686b756..6752abe 100644
--- a/video/send_statistics_proxy.cc
+++ b/video/send_statistics_proxy.cc
@@ -670,6 +670,7 @@
void SendStatisticsProxy::OnEncoderReconfigured(
const VideoEncoderConfig& config,
const std::vector<VideoStream>& streams) {
+ // Called on VideoStreamEncoder's encoder_queue_.
MutexLock lock(&mutex_);
if (content_type_ != config.content_type) {
diff --git a/video/video_send_stream.cc b/video/video_send_stream.cc
index 91c246c..295e56b 100644
--- a/video/video_send_stream.cc
+++ b/video/video_send_stream.cc
@@ -169,7 +169,7 @@
void VideoSendStream::Start() {
RTC_DCHECK_RUN_ON(&thread_checker_);
- RTC_LOG(LS_INFO) << "VideoSendStream::Start";
+ RTC_DLOG(LS_INFO) << "VideoSendStream::Start";
VideoSendStreamImpl* send_stream = send_stream_.get();
worker_queue_->PostTask([this, send_stream] {
send_stream->Start();
@@ -184,7 +184,7 @@
void VideoSendStream::Stop() {
RTC_DCHECK_RUN_ON(&thread_checker_);
- RTC_LOG(LS_INFO) << "VideoSendStream::Stop";
+ RTC_DLOG(LS_INFO) << "VideoSendStream::Stop";
VideoSendStreamImpl* send_stream = send_stream_.get();
worker_queue_->PostTask([send_stream] { send_stream->Stop(); });
}
@@ -209,10 +209,8 @@
}
void VideoSendStream::ReconfigureVideoEncoder(VideoEncoderConfig config) {
- // TODO(perkj): Some test cases in VideoSendStreamTest call
- // ReconfigureVideoEncoder from the network thread.
- // RTC_DCHECK_RUN_ON(&thread_checker_);
- RTC_DCHECK(content_type_ == config.content_type);
+ RTC_DCHECK_RUN_ON(&thread_checker_);
+ RTC_DCHECK_EQ(content_type_, config.content_type);
video_stream_encoder_->ConfigureEncoder(
std::move(config),
config_.rtp.max_packet_size - CalculateMaxHeaderSize(config_.rtp));
diff --git a/video/video_send_stream_tests.cc b/video/video_send_stream_tests.cc
index ba24441..78265cc 100644
--- a/video/video_send_stream_tests.cc
+++ b/video/video_send_stream_tests.cc
@@ -1474,7 +1474,9 @@
if (!rtp_packet.Parse(packet, length))
return DROP_PACKET;
RTC_DCHECK(stream_);
- VideoSendStream::Stats stats = stream_->GetStats();
+ VideoSendStream::Stats stats;
+ SendTask(RTC_FROM_HERE, task_queue_,
+ [&]() { stats = stream_->GetStats(); });
if (!stats.substreams.empty()) {
EXPECT_EQ(1u, stats.substreams.size());
int total_bitrate_bps =
@@ -2422,14 +2424,16 @@
public test::FakeEncoder {
public:
VideoCodecConfigObserver(VideoCodecType video_codec_type,
- const char* codec_name)
+ const char* codec_name,
+ TaskQueueBase* task_queue)
: SendTest(VideoSendStreamTest::kDefaultTimeoutMs),
FakeEncoder(Clock::GetRealTimeClock()),
video_codec_type_(video_codec_type),
codec_name_(codec_name),
num_initializations_(0),
stream_(nullptr),
- encoder_factory_(this) {
+ encoder_factory_(this),
+ task_queue_(task_queue) {
InitCodecSpecifics();
}
@@ -2477,7 +2481,9 @@
// Change encoder settings to actually trigger reconfiguration.
encoder_settings_.frameDroppingOn = !encoder_settings_.frameDroppingOn;
encoder_config_.encoder_specific_settings = GetEncoderSpecificSettings();
- stream_->ReconfigureVideoEncoder(std::move(encoder_config_));
+ SendTask(RTC_FROM_HERE, task_queue_, [&]() {
+ stream_->ReconfigureVideoEncoder(std::move(encoder_config_));
+ });
ASSERT_TRUE(
init_encode_event_.Wait(VideoSendStreamTest::kDefaultTimeoutMs));
EXPECT_EQ(2u, num_initializations_)
@@ -2499,6 +2505,7 @@
VideoSendStream* stream_;
test::VideoEncoderProxyFactory encoder_factory_;
VideoEncoderConfig encoder_config_;
+ TaskQueueBase* task_queue_;
};
template <>
@@ -2604,12 +2611,14 @@
}
TEST_F(VideoSendStreamTest, EncoderSetupPropagatesVp8Config) {
- VideoCodecConfigObserver<VideoCodecVP8> test(kVideoCodecVP8, "VP8");
+ VideoCodecConfigObserver<VideoCodecVP8> test(kVideoCodecVP8, "VP8",
+ task_queue());
RunBaseTest(&test);
}
TEST_F(VideoSendStreamTest, EncoderSetupPropagatesVp9Config) {
- VideoCodecConfigObserver<VideoCodecVP9> test(kVideoCodecVP9, "VP9");
+ VideoCodecConfigObserver<VideoCodecVP9> test(kVideoCodecVP9, "VP9",
+ task_queue());
RunBaseTest(&test);
}
@@ -2621,7 +2630,8 @@
#define MAYBE_EncoderSetupPropagatesH264Config EncoderSetupPropagatesH264Config
#endif
TEST_F(VideoSendStreamTest, MAYBE_EncoderSetupPropagatesH264Config) {
- VideoCodecConfigObserver<VideoCodecH264> test(kVideoCodecH264, "H264");
+ VideoCodecConfigObserver<VideoCodecH264> test(kVideoCodecH264, "H264",
+ task_queue());
RunBaseTest(&test);
}
@@ -2904,7 +2914,9 @@
// Encoder rate is capped by EncoderConfig max_bitrate_bps.
WaitForSetRates(kMaxBitrateKbps);
encoder_config_.max_bitrate_bps = kLowerMaxBitrateKbps * 1000;
- send_stream_->ReconfigureVideoEncoder(encoder_config_.Copy());
+ SendTask(RTC_FROM_HERE, task_queue_, [&]() {
+ send_stream_->ReconfigureVideoEncoder(encoder_config_.Copy());
+ });
ASSERT_TRUE(create_rate_allocator_event_.Wait(
VideoSendStreamTest::kDefaultTimeoutMs));
EXPECT_EQ(2, num_rate_allocator_creations_)
@@ -2914,7 +2926,9 @@
EXPECT_EQ(1, num_encoder_initializations_);
encoder_config_.max_bitrate_bps = kIncreasedMaxBitrateKbps * 1000;
- send_stream_->ReconfigureVideoEncoder(encoder_config_.Copy());
+ SendTask(RTC_FROM_HERE, task_queue_, [&]() {
+ send_stream_->ReconfigureVideoEncoder(encoder_config_.Copy());
+ });
ASSERT_TRUE(create_rate_allocator_event_.Wait(
VideoSendStreamTest::kDefaultTimeoutMs));
EXPECT_EQ(3, num_rate_allocator_creations_)
@@ -2955,11 +2969,12 @@
class ScreencastTargetBitrateTest : public test::SendTest,
public test::FakeEncoder {
public:
- ScreencastTargetBitrateTest()
+ explicit ScreencastTargetBitrateTest(TaskQueueBase* task_queue)
: SendTest(kDefaultTimeoutMs),
test::FakeEncoder(Clock::GetRealTimeClock()),
send_stream_(nullptr),
- encoder_factory_(this) {}
+ encoder_factory_(this),
+ task_queue_(task_queue) {}
private:
int32_t Encode(const VideoFrame& input_image,
@@ -3007,7 +3022,9 @@
void PerformTest() override {
EXPECT_TRUE(Wait())
<< "Timed out while waiting for the encoder to send one frame.";
- VideoSendStream::Stats stats = send_stream_->GetStats();
+ VideoSendStream::Stats stats;
+ SendTask(RTC_FROM_HERE, task_queue_,
+ [&]() { stats = send_stream_->GetStats(); });
for (size_t i = 0; i < kNumStreams; ++i) {
ASSERT_TRUE(stats.substreams.find(kVideoSendSsrcs[i]) !=
@@ -3029,7 +3046,8 @@
VideoSendStream* send_stream_;
test::VideoEncoderProxyFactory encoder_factory_;
- } test;
+ TaskQueueBase* const task_queue_;
+ } test(task_queue());
RunBaseTest(&test);
}
@@ -3800,14 +3818,15 @@
};
static const uint32_t kMinPacketsToSend = 50;
- explicit ContentSwitchTest(T* stream_reset_fun)
+ explicit ContentSwitchTest(T* stream_reset_fun, TaskQueueBase* task_queue)
: SendTest(test::CallTest::kDefaultTimeoutMs),
call_(nullptr),
state_(StreamState::kBeforeSwitch),
send_stream_(nullptr),
send_stream_config_(nullptr),
packets_sent_(0),
- stream_resetter_(stream_reset_fun) {
+ stream_resetter_(stream_reset_fun),
+ task_queue_(task_queue) {
RTC_DCHECK(stream_resetter_);
}
@@ -3841,8 +3860,10 @@
float pacing_factor =
internal_send_peer.GetPacingFactorOverride().value_or(0.0f);
float expected_pacing_factor = 1.1; // Strict pacing factor.
- if (send_stream_->GetStats().content_type ==
- webrtc::VideoContentType::SCREENSHARE) {
+ VideoSendStream::Stats stats;
+ SendTask(RTC_FROM_HERE, task_queue_,
+ [&stats, stream = send_stream_]() { stats = stream->GetStats(); });
+ if (stats.content_type == webrtc::VideoContentType::SCREENSHARE) {
expected_pacing_factor = 1.0f; // Currently used pacing factor in ALR.
}
@@ -3910,6 +3931,7 @@
VideoEncoderConfig encoder_config_;
uint32_t packets_sent_ RTC_GUARDED_BY(mutex_);
T* stream_resetter_;
+ TaskQueueBase* task_queue_;
};
TEST_F(VideoSendStreamTest, SwitchesToScreenshareAndBack) {
@@ -3929,7 +3951,7 @@
Start();
});
};
- ContentSwitchTest<decltype(reset_fun)> test(&reset_fun);
+ ContentSwitchTest<decltype(reset_fun)> test(&reset_fun, task_queue());
RunBaseTest(&test);
}
