Allow recursive check for RTC_DCHECK_RUN_ON macro
instead of using Lock/Unlock attributes, use Assert attribute to annotate code is running on certain task queue or thread.
Such check better matches what is checked, in particular allows to
recheck (and thus better document) currently used task queue
Bug: None
Change-Id: I5bc1c397efbc8342cf7915093b578bb015c85651
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/269381
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Reviewed-by: Tomas Gunnarsson <tommi@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#37619}
diff --git a/api/sequence_checker.h b/api/sequence_checker.h
index 5db7b9e..b9f466b 100644
--- a/api/sequence_checker.h
+++ b/api/sequence_checker.h
@@ -107,10 +107,9 @@
#define RTC_RUN_ON(x) \
RTC_THREAD_ANNOTATION_ATTRIBUTE__(exclusive_locks_required(x))
-#define RTC_DCHECK_RUN_ON(x) \
- webrtc::webrtc_sequence_checker_internal::SequenceCheckerScope \
- seq_check_scope(x); \
- RTC_DCHECK((x)->IsCurrent()) \
- << webrtc::webrtc_sequence_checker_internal::ExpectationToString(x)
+#define RTC_DCHECK_RUN_ON(x) \
+ RTC_DCHECK((x)->IsCurrent()) \
+ << webrtc::webrtc_sequence_checker_internal::ExpectationToString(x); \
+ webrtc::webrtc_sequence_checker_internal::AssertHeld(x)
#endif // API_SEQUENCE_CHECKER_H_
diff --git a/audio/channel_receive.cc b/audio/channel_receive.cc
index c1225b1..c661f0b 100644
--- a/audio/channel_receive.cc
+++ b/audio/channel_receive.cc
@@ -1036,8 +1036,8 @@
return info;
}
-// RTC_RUN_ON(worker_thread_checker_)
void ChannelReceive::UpdatePlayoutTimestamp(bool rtcp, int64_t now_ms) {
+ RTC_DCHECK_RUN_ON(&worker_thread_checker_);
// TODO(bugs.webrtc.org/11993): Expect to be called exclusively on the
// network thread. Once that's done, we won't need video_sync_lock_.
diff --git a/call/call.cc b/call/call.cc
index 9be0953..09bc902 100644
--- a/call/call.cc
+++ b/call/call.cc
@@ -1350,9 +1350,9 @@
std::memory_order_relaxed);
}
-// RTC_RUN_ON(worker_thread_)
AudioReceiveStreamImpl* Call::FindAudioStreamForSyncGroup(
absl::string_view sync_group) {
+ RTC_DCHECK_RUN_ON(worker_thread_);
RTC_DCHECK_RUN_ON(&receive_11993_checker_);
if (!sync_group.empty()) {
for (AudioReceiveStreamImpl* stream : audio_receive_streams_) {
@@ -1364,9 +1364,9 @@
return nullptr;
}
-// TODO(bugs.webrtc.org/11993): Expect to be called on the network thread.
-// RTC_RUN_ON(worker_thread_)
void Call::ConfigureSync(absl::string_view sync_group) {
+ // TODO(bugs.webrtc.org/11993): Expect to be called on the network thread.
+ RTC_DCHECK_RUN_ON(worker_thread_);
// `audio_stream` may be nullptr when clearing the audio stream for a group.
AudioReceiveStreamImpl* audio_stream =
FindAudioStreamForSyncGroup(sync_group);
@@ -1389,8 +1389,8 @@
}
}
-// RTC_RUN_ON(network_thread_)
void Call::DeliverRtcp(MediaType media_type, rtc::CopyOnWriteBuffer packet) {
+ RTC_DCHECK_RUN_ON(network_thread_);
TRACE_EVENT0("webrtc", "Call::DeliverRtcp");
// TODO(bugs.webrtc.org/11993): This DCHECK is here just to maintain the
@@ -1533,10 +1533,10 @@
video_receiver_controller_.OnRtpPacket(parsed_packet);
}
-// RTC_RUN_ON(worker_thread_)
void Call::NotifyBweOfReceivedPacket(const RtpPacketReceived& packet,
MediaType media_type,
bool use_send_side_bwe) {
+ RTC_DCHECK_RUN_ON(worker_thread_);
RTPHeader header;
packet.GetHeader(&header);
diff --git a/media/engine/webrtc_video_engine.cc b/media/engine/webrtc_video_engine.cc
index 6b9730f..366a42c 100644
--- a/media/engine/webrtc_video_engine.cc
+++ b/media/engine/webrtc_video_engine.cc
@@ -1274,8 +1274,8 @@
return out.Release();
}
-// RTC_RUN_ON(&thread_checker_)
void WebRtcVideoChannel::SetReceiverReportSsrc(uint32_t ssrc) {
+ RTC_DCHECK_RUN_ON(&thread_checker_);
if (ssrc == rtcp_receiver_report_ssrc_)
return;
diff --git a/modules/rtp_rtcp/source/rtp_rtcp_impl2.cc b/modules/rtp_rtcp/source/rtp_rtcp_impl2.cc
index 354eccb..9eb40ab 100644
--- a/modules/rtp_rtcp/source/rtp_rtcp_impl2.cc
+++ b/modules/rtp_rtcp/source/rtp_rtcp_impl2.cc
@@ -757,17 +757,17 @@
}
}
-// RTC_RUN_ON(worker_queue_);
void ModuleRtpRtcpImpl2::MaybeSendRtcp() {
+ RTC_DCHECK_RUN_ON(worker_queue_);
if (rtcp_sender_.TimeToSendRTCPReport())
rtcp_sender_.SendRTCP(GetFeedbackState(), kRtcpReport);
}
// TODO(bugs.webrtc.org/12889): Consider removing this function when the issue
// is resolved.
-// RTC_RUN_ON(worker_queue_);
void ModuleRtpRtcpImpl2::MaybeSendRtcpAtOrAfterTimestamp(
Timestamp execution_time) {
+ RTC_DCHECK_RUN_ON(worker_queue_);
Timestamp now = clock_->CurrentTime();
if (now >= execution_time) {
MaybeSendRtcp();
diff --git a/modules/video_coding/nack_requester.cc b/modules/video_coding/nack_requester.cc
index 80dfe86..4e74032 100644
--- a/modules/video_coding/nack_requester.cc
+++ b/modules/video_coding/nack_requester.cc
@@ -71,8 +71,8 @@
repeating_task_.Stop();
}
-// RTC_RUN_ON(sequence_)
void NackPeriodicProcessor::ProcessNackModules() {
+ RTC_DCHECK_RUN_ON(&sequence_);
for (NackRequesterBase* module : modules_)
module->ProcessNacks();
}
diff --git a/p2p/base/connection.cc b/p2p/base/connection.cc
index 9aefdf6..e59de3d 100644
--- a/p2p/base/connection.cc
+++ b/p2p/base/connection.cc
@@ -1289,18 +1289,18 @@
ice_event_log_ = ice_event_log;
}
-// RTC_RUN_ON(network_thread_)
void Connection::LogCandidatePairConfig(
webrtc::IceCandidatePairConfigType type) {
+ RTC_DCHECK_RUN_ON(network_thread_);
if (ice_event_log_ == nullptr) {
return;
}
ice_event_log_->LogCandidatePairConfig(type, id(), ToLogDescription());
}
-// RTC_RUN_ON(network_thread_)
void Connection::LogCandidatePairEvent(webrtc::IceCandidatePairEventType type,
uint32_t transaction_id) {
+ RTC_DCHECK_RUN_ON(network_thread_);
if (ice_event_log_ == nullptr) {
return;
}
@@ -1403,8 +1403,8 @@
<< request->Elapsed() << " ms";
}
-// RTC_RUN_ON(network_thread_).
void Connection::OnConnectionRequestSent(ConnectionRequest* request) {
+ RTC_DCHECK_RUN_ON(network_thread_);
// Log at LS_INFO if we send a ping on an unwritable connection.
rtc::LoggingSeverity sev = !writable() ? rtc::LS_INFO : rtc::LS_VERBOSE;
RTC_LOG_V(sev) << ToString() << ": Sent "
@@ -1620,8 +1620,8 @@
SignalStateChange(this);
}
-// RTC_RUN_ON(network_thread_).
bool Connection::ShouldSendGoogPing(const StunMessage* message) {
+ RTC_DCHECK_RUN_ON(network_thread_);
if (remote_support_goog_ping_ == true && cached_stun_binding_ &&
cached_stun_binding_->EqualAttributes(message, [](int type) {
// Ignore these attributes.
diff --git a/p2p/base/p2p_transport_channel.cc b/p2p/base/p2p_transport_channel.cc
index 87338bf..213cfbd 100644
--- a/p2p/base/p2p_transport_channel.cc
+++ b/p2p/base/p2p_transport_channel.cc
@@ -2026,8 +2026,8 @@
}
}
-// RTC_RUN_ON(network_thread_)
void P2PTransportChannel::OnSelectedConnectionDestroyed() {
+ RTC_DCHECK_RUN_ON(network_thread_);
RTC_LOG(LS_INFO) << "Selected connection destroyed. Will choose a new one.";
IceSwitchReason reason = IceSwitchReason::SELECTED_CONNECTION_DESTROYED;
SwitchSelectedConnection(nullptr, reason);
diff --git a/pc/audio_rtp_receiver.cc b/pc/audio_rtp_receiver.cc
index 6ed163a..e58b74e 100644
--- a/pc/audio_rtp_receiver.cc
+++ b/pc/audio_rtp_receiver.cc
@@ -83,8 +83,8 @@
}));
}
-// RTC_RUN_ON(worker_thread_)
void AudioRtpReceiver::SetOutputVolume_w(double volume) {
+ RTC_DCHECK_RUN_ON(worker_thread_);
RTC_DCHECK_GE(volume, 0.0);
RTC_DCHECK_LE(volume, 10.0);
@@ -164,8 +164,8 @@
track_->internal()->set_ended();
}
-// RTC_RUN_ON(&signaling_thread_checker_)
void AudioRtpReceiver::RestartMediaChannel(absl::optional<uint32_t> ssrc) {
+ RTC_DCHECK_RUN_ON(&signaling_thread_checker_);
bool enabled = track_->internal()->enabled();
MediaSourceInterface::SourceState state = source_->state();
worker_thread_->Invoke<void>(RTC_FROM_HERE, [&]() {
@@ -175,11 +175,11 @@
source_->SetState(MediaSourceInterface::kLive);
}
-// RTC_RUN_ON(worker_thread_)
void AudioRtpReceiver::RestartMediaChannel_w(
absl::optional<uint32_t> ssrc,
bool track_enabled,
MediaSourceInterface::SourceState state) {
+ RTC_DCHECK_RUN_ON(worker_thread_);
if (!media_channel_)
return; // Can't restart.
@@ -281,8 +281,8 @@
frame_transformer_ = std::move(frame_transformer);
}
-// RTC_RUN_ON(worker_thread_)
void AudioRtpReceiver::Reconfigure(bool track_enabled) {
+ RTC_DCHECK_RUN_ON(worker_thread_);
RTC_DCHECK(media_channel_);
SetOutputVolume_w(track_enabled ? cached_volume_ : 0);
diff --git a/pc/video_rtp_receiver.cc b/pc/video_rtp_receiver.cc
index c872fe4..d6272e7 100644
--- a/pc/video_rtp_receiver.cc
+++ b/pc/video_rtp_receiver.cc
@@ -113,8 +113,8 @@
track_->internal()->set_ended();
}
-// RTC_RUN_ON(&signaling_thread_checker_)
void VideoRtpReceiver::RestartMediaChannel(absl::optional<uint32_t> ssrc) {
+ RTC_DCHECK_RUN_ON(&signaling_thread_checker_);
MediaSourceInterface::SourceState state = source_->state();
// TODO(tommi): Can we restart the media channel without blocking?
worker_thread_->Invoke<void>(RTC_FROM_HERE, [&] {
@@ -124,10 +124,10 @@
source_->SetState(MediaSourceInterface::kLive);
}
-// RTC_RUN_ON(worker_thread_)
void VideoRtpReceiver::RestartMediaChannel_w(
absl::optional<uint32_t> ssrc,
MediaSourceInterface::SourceState state) {
+ RTC_DCHECK_RUN_ON(worker_thread_);
if (!media_channel_) {
return; // Can't restart.
}
@@ -166,8 +166,8 @@
}
}
-// RTC_RUN_ON(worker_thread_)
void VideoRtpReceiver::SetSink(rtc::VideoSinkInterface<VideoFrame>* sink) {
+ RTC_DCHECK_RUN_ON(worker_thread_);
if (ssrc_) {
media_channel_->SetSink(*ssrc_, sink);
} else {
@@ -260,8 +260,8 @@
SetMediaChannel_w(media_channel);
}
-// RTC_RUN_ON(worker_thread_)
void VideoRtpReceiver::SetMediaChannel_w(cricket::MediaChannel* media_channel) {
+ RTC_DCHECK_RUN_ON(worker_thread_);
if (media_channel == media_channel_)
return;
@@ -347,8 +347,8 @@
saved_encoded_sink_enabled_ = enable;
}
-// RTC_RUN_ON(worker_thread_)
void VideoRtpReceiver::SetEncodedSinkEnabled(bool enable) {
+ RTC_DCHECK_RUN_ON(worker_thread_);
if (!media_channel_)
return;
diff --git a/rtc_base/synchronization/sequence_checker_internal.h b/rtc_base/synchronization/sequence_checker_internal.h
index f7ac6de..3457765 100644
--- a/rtc_base/synchronization/sequence_checker_internal.h
+++ b/rtc_base/synchronization/sequence_checker_internal.h
@@ -19,9 +19,21 @@
#include "rtc_base/system/rtc_export.h"
#include "rtc_base/thread_annotations.h"
+namespace rtc {
+class TaskQueue;
+} // namespace rtc
+
namespace webrtc {
+class SequenceChecker;
namespace webrtc_sequence_checker_internal {
+inline void AssertHeld(const SequenceChecker* checker)
+ RTC_ASSERT_EXCLUSIVE_LOCK(checker) {}
+inline void AssertHeld(const TaskQueueBase* task_queue)
+ RTC_ASSERT_EXCLUSIVE_LOCK(task_queue) {}
+inline void AssertHeld(const rtc::TaskQueue* task_queue)
+ RTC_ASSERT_EXCLUSIVE_LOCK(task_queue) {}
+
// Real implementation of SequenceChecker, for use in debug mode, or
// for temporary use in release mode (e.g. to RTC_CHECK on a threading issue
// seen only in the wild).
@@ -63,22 +75,6 @@
void Detach() {}
};
-// Helper class used by RTC_DCHECK_RUN_ON (see example usage below).
-class RTC_SCOPED_LOCKABLE SequenceCheckerScope {
- public:
- template <typename ThreadLikeObject>
- explicit SequenceCheckerScope(const ThreadLikeObject* thread_like_object)
- RTC_EXCLUSIVE_LOCK_FUNCTION(thread_like_object) {}
- SequenceCheckerScope(const SequenceCheckerScope&) = delete;
- SequenceCheckerScope& operator=(const SequenceCheckerScope&) = delete;
- ~SequenceCheckerScope() RTC_UNLOCK_FUNCTION() {}
-
- template <typename ThreadLikeObject>
- static bool IsCurrent(const ThreadLikeObject* thread_like_object) {
- return thread_like_object->IsCurrent();
- }
-};
-
std::string ExpectationToString(const SequenceCheckerImpl* checker);
// Catch-all implementation for types other than explicitly supported above.
diff --git a/video/frame_cadence_adapter.cc b/video/frame_cadence_adapter.cc
index 0ff1680..c24a82c 100644
--- a/video/frame_cadence_adapter.cc
+++ b/video/frame_cadence_adapter.cc
@@ -442,8 +442,8 @@
return;
}
-// RTC_RUN_ON(&sequence_checker_)
bool ZeroHertzAdapterMode::HasQualityConverged() const {
+ RTC_DCHECK_RUN_ON(&sequence_checker_);
// 1. Define ourselves as unconverged with no spatial layers configured. This
// is to keep short repeating until the layer configuration comes.
// 2. Unset layers implicitly imply that they're converged to support
@@ -456,8 +456,8 @@
return quality_converged;
}
-// RTC_RUN_ON(&sequence_checker_)
void ZeroHertzAdapterMode::ResetQualityConvergenceInfo() {
+ RTC_DCHECK_RUN_ON(&sequence_checker_);
RTC_DLOG(LS_INFO) << __func__ << " this " << this;
for (auto& layer_tracker : layer_trackers_) {
if (layer_tracker.quality_converged.has_value())
@@ -465,8 +465,8 @@
}
}
-// RTC_RUN_ON(&sequence_checker_)
void ZeroHertzAdapterMode::ProcessOnDelayedCadence() {
+ RTC_DCHECK_RUN_ON(&sequence_checker_);
RTC_DCHECK(!queued_frames_.empty());
RTC_DLOG(LS_VERBOSE) << __func__ << " this " << this;
@@ -485,8 +485,8 @@
ScheduleRepeat(current_frame_id_, HasQualityConverged());
}
-// RTC_RUN_ON(&sequence_checker_)
void ZeroHertzAdapterMode::ScheduleRepeat(int frame_id, bool idle_repeat) {
+ RTC_DCHECK_RUN_ON(&sequence_checker_);
RTC_DLOG(LS_VERBOSE) << __func__ << " this " << this << " frame_id "
<< frame_id;
Timestamp now = clock_->CurrentTime();
@@ -507,8 +507,8 @@
repeat_delay);
}
-// RTC_RUN_ON(&sequence_checker_)
void ZeroHertzAdapterMode::ProcessRepeatedFrameOnDelayedCadence(int frame_id) {
+ RTC_DCHECK_RUN_ON(&sequence_checker_);
RTC_DLOG(LS_VERBOSE) << __func__ << " this " << this << " frame_id "
<< frame_id;
RTC_DCHECK(!queued_frames_.empty());
@@ -545,8 +545,8 @@
ScheduleRepeat(frame_id, HasQualityConverged());
}
-// RTC_RUN_ON(&sequence_checker_)
void ZeroHertzAdapterMode::SendFrameNow(const VideoFrame& frame) const {
+ RTC_DCHECK_RUN_ON(&sequence_checker_);
RTC_DLOG(LS_VERBOSE) << __func__ << " this " << this << " timestamp "
<< frame.timestamp() << " timestamp_us "
<< frame.timestamp_us() << " ntp_time_ms "
@@ -557,15 +557,15 @@
/*frames_scheduled_for_processing=*/1, frame);
}
-// RTC_RUN_ON(&sequence_checker_)
TimeDelta ZeroHertzAdapterMode::RepeatDuration(bool idle_repeat) const {
+ RTC_DCHECK_RUN_ON(&sequence_checker_);
return idle_repeat
? FrameCadenceAdapterInterface::kZeroHertzIdleRepeatRatePeriod
: frame_delay_;
}
-// RTC_RUN_ON(&sequence_checker_)
void ZeroHertzAdapterMode::MaybeStartRefreshFrameRequester() {
+ RTC_DCHECK_RUN_ON(&sequence_checker_);
RTC_DLOG(LS_VERBOSE) << __func__;
if (!refresh_frame_requester_.Running()) {
refresh_frame_requester_ = RepeatingTaskHandle::DelayedStart(
@@ -696,26 +696,26 @@
}));
}
-// RTC_RUN_ON(queue_)
void FrameCadenceAdapterImpl::OnFrameOnMainQueue(
Timestamp post_time,
int frames_scheduled_for_processing,
const VideoFrame& frame) {
+ RTC_DCHECK_RUN_ON(queue_);
current_adapter_mode_->OnFrame(post_time, frames_scheduled_for_processing,
frame);
}
-// RTC_RUN_ON(queue_)
bool FrameCadenceAdapterImpl::IsZeroHertzScreenshareEnabled() const {
+ RTC_DCHECK_RUN_ON(queue_);
return zero_hertz_screenshare_enabled_ && source_constraints_.has_value() &&
source_constraints_->max_fps.value_or(-1) > 0 &&
source_constraints_->min_fps.value_or(-1) == 0 &&
zero_hertz_params_.has_value();
}
-// RTC_RUN_ON(queue_)
void FrameCadenceAdapterImpl::MaybeReconfigureAdapters(
bool was_zero_hertz_enabled) {
+ RTC_DCHECK_RUN_ON(queue_);
bool is_zero_hertz_enabled = IsZeroHertzScreenshareEnabled();
if (is_zero_hertz_enabled) {
if (!was_zero_hertz_enabled) {
@@ -733,8 +733,8 @@
}
}
-// RTC_RUN_ON(queue_)
void FrameCadenceAdapterImpl::MaybeReportFrameRateConstraintUmas() {
+ RTC_DCHECK_RUN_ON(queue_);
if (has_reported_screenshare_frame_rate_umas_)
return;
has_reported_screenshare_frame_rate_umas_ = true;
diff --git a/video/rtp_video_stream_receiver2.cc b/video/rtp_video_stream_receiver2.cc
index 84aeae8..b516b67 100644
--- a/video/rtp_video_stream_receiver2.cc
+++ b/video/rtp_video_stream_receiver2.cc
@@ -351,11 +351,11 @@
return info;
}
-// RTC_RUN_ON(packet_sequence_checker_)
RtpVideoStreamReceiver2::ParseGenericDependenciesResult
RtpVideoStreamReceiver2::ParseGenericDependenciesExtension(
const RtpPacketReceived& rtp_packet,
RTPVideoHeader* video_header) {
+ RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
if (rtp_packet.HasExtension<RtpDependencyDescriptorExtension>()) {
webrtc::DependencyDescriptor dependency_descriptor;
if (!rtp_packet.GetExtension<RtpDependencyDescriptorExtension>(
@@ -707,9 +707,9 @@
return frames_decryptable_;
}
-// RTC_RUN_ON(packet_sequence_checker_)
void RtpVideoStreamReceiver2::OnInsertedPacket(
video_coding::PacketBuffer::InsertResult result) {
+ RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
RTC_DCHECK_RUN_ON(&worker_task_checker_);
video_coding::PacketBuffer::Packet* first_packet = nullptr;
int max_nack_count;
@@ -785,9 +785,9 @@
}
}
-// RTC_RUN_ON(packet_sequence_checker_)
void RtpVideoStreamReceiver2::OnAssembledFrame(
std::unique_ptr<RtpFrameObject> frame) {
+ RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
RTC_DCHECK(frame);
const absl::optional<RTPVideoHeader::GenericDescriptorInfo>& descriptor =
@@ -852,9 +852,9 @@
}
}
-// RTC_RUN_ON(packet_sequence_checker_)
void RtpVideoStreamReceiver2::OnCompleteFrames(
RtpFrameReferenceFinder::ReturnVector frames) {
+ RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
for (auto& frame : frames) {
last_seq_num_for_pic_id_[frame->Id()] = frame->last_seq_num();
@@ -952,8 +952,8 @@
OnCompleteFrames(reference_finder_->ManageFrame(std::move(frame)));
}
-// RTC_RUN_ON(packet_sequence_checker_)
void RtpVideoStreamReceiver2::ReceivePacket(const RtpPacketReceived& packet) {
+ RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
RTC_DCHECK_RUN_ON(&worker_task_checker_);
if (packet.payload_size() == 0) {
// Padding or keep-alive packet.
@@ -982,9 +982,9 @@
parsed_payload->video_header);
}
-// RTC_RUN_ON(packet_sequence_checker_)
void RtpVideoStreamReceiver2::ParseAndHandleEncapsulatingHeader(
const RtpPacketReceived& packet) {
+ RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
if (packet.PayloadType() == config_.rtp.red_payload_type &&
packet.payload_size() > 0) {
if (packet.payload()[0] == config_.rtp.ulpfec_payload_type) {
@@ -1003,8 +1003,8 @@
// In the case of a video stream without picture ids and no rtx the
// RtpFrameReferenceFinder will need to know about padding to
// correctly calculate frame references.
-// RTC_RUN_ON(packet_sequence_checker_)
void RtpVideoStreamReceiver2::NotifyReceiverOfEmptyPacket(uint16_t seq_num) {
+ RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
RTC_DCHECK_RUN_ON(&worker_task_checker_);
OnCompleteFrames(reference_finder_->PaddingReceived(seq_num));
@@ -1140,8 +1140,8 @@
}
}
-// RTC_RUN_ON(packet_sequence_checker_)
void RtpVideoStreamReceiver2::InsertSpsPpsIntoTracker(uint8_t payload_type) {
+ RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
RTC_DCHECK_RUN_ON(&worker_task_checker_);
auto codec_params_it = pt_codec_params_.find(payload_type);
diff --git a/video/video_receive_stream2.cc b/video/video_receive_stream2.cc
index 30101cd..7a53f34 100644
--- a/video/video_receive_stream2.cc
+++ b/video/video_receive_stream2.cc
@@ -659,7 +659,7 @@
}
void VideoReceiveStream2::RequestKeyFrame(Timestamp now) {
- // Running on worker_sequence_checker_.
+ RTC_DCHECK_RUN_ON(&worker_sequence_checker_);
// Called from RtpVideoStreamReceiver (rtp_video_stream_receiver_ is
// ultimately responsible).
rtp_video_stream_receiver_.RequestKeyFrame();
@@ -775,9 +775,9 @@
}));
}
-// RTC_RUN_ON(decode_queue_)
void VideoReceiveStream2::HandleEncodedFrame(
std::unique_ptr<EncodedFrame> frame) {
+ RTC_DCHECK_RUN_ON(&decode_queue_);
Timestamp now = clock_->CurrentTime();
// Current OnPreDecode only cares about QP for VP8.
@@ -847,7 +847,7 @@
int VideoReceiveStream2::DecodeAndMaybeDispatchEncodedFrame(
std::unique_ptr<EncodedFrame> frame) {
- // Running on decode_queue_.
+ RTC_DCHECK_RUN_ON(&decode_queue_);
// If `buffered_encoded_frames_` grows out of control (=60 queued frames),
// maybe due to a stuck decoder, we just halt the process here and log the
@@ -905,12 +905,12 @@
return decode_result;
}
-// RTC_RUN_ON(packet_sequence_checker_)
void VideoReceiveStream2::HandleKeyFrameGeneration(
bool received_frame_is_keyframe,
Timestamp now,
bool always_request_key_frame,
bool keyframe_request_is_due) {
+ RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
bool request_key_frame = always_request_key_frame;
// Repeat sending keyframe requests if we've requested a keyframe.
@@ -934,9 +934,9 @@
}
}
-// RTC_RUN_ON(packet_sequence_checker_)
void VideoReceiveStream2::HandleFrameBufferTimeout(Timestamp now,
TimeDelta wait) {
+ RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
absl::optional<int64_t> last_packet_ms =
rtp_video_stream_receiver_.LastReceivedPacketMs();
@@ -958,8 +958,8 @@
}
}
-// RTC_RUN_ON(packet_sequence_checker_)
bool VideoReceiveStream2::IsReceivingKeyFrame(Timestamp now) const {
+ RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
absl::optional<int64_t> last_keyframe_packet_ms =
rtp_video_stream_receiver_.LastReceivedKeyframePacketMs();
@@ -972,7 +972,7 @@
}
void VideoReceiveStream2::UpdatePlayoutDelays() const {
- // Running on worker_sequence_checker_.
+ RTC_DCHECK_RUN_ON(&worker_sequence_checker_);
const std::initializer_list<absl::optional<TimeDelta>> min_delays = {
frame_minimum_playout_delay_, base_minimum_playout_delay_,
syncable_minimum_playout_delay_};
diff --git a/video/video_send_stream_impl.cc b/video/video_send_stream_impl.cc
index 2032c4c..3954ef0 100644
--- a/video/video_send_stream_impl.cc
+++ b/video/video_send_stream_impl.cc
@@ -373,8 +373,8 @@
StopVideoSendStream();
}
-// RTC_RUN_ON(rtp_transport_queue_)
void VideoSendStreamImpl::StopVideoSendStream() {
+ RTC_DCHECK_RUN_ON(rtp_transport_queue_);
bitrate_allocator_->RemoveObserver(this);
check_encoder_activity_task_.Stop();
video_stream_encoder_->OnBitrateUpdated(DataRate::Zero(), DataRate::Zero(),
