zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Replacing SequencedTaskChecker with SequenceChecker.

Browse Source 
Bug: webrtc:9883
Change-Id: I5e3189da2a46e6f4ed1a3c5a5dfd2f7d75a16b5d
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/130961
Commit-Queue: Sebastian Jansson <srte@webrtc.org>
Reviewed-by: Karl Wiberg <kwiberg@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#27518}
This commit is contained in:
Sebastian Jansson
2019-04-09 13:44:04 +02:00
committed by Commit Bot
parent 412dc5f27e
commit b55015e4e1
59 changed files with 379 additions and 424 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
BUILD.gn
View File

@ -489,10 +489,10 @@ if (rtc_include_tests) {
"rtc_base:rtc_json_unittests",
"rtc_base:rtc_numerics_unittests",
"rtc_base:rtc_task_queue_unittests",
"rtc_base:sequenced_task_checker_unittests",
"rtc_base:sigslot_unittest",
"rtc_base:weak_ptr_unittests",
"rtc_base/experiments:experiments_unittests",
"rtc_base/synchronization:sequence_checker_unittests",
"rtc_base/task_utils:to_queued_task_unittests",
"sdk:sdk_tests",
"test/scenario/network:network_emulation_unittests",

8
call/BUILD.gn
View File

@ -185,7 +185,7 @@ rtc_source_set("bitrate_allocator") {
"../modules/bitrate_controller",
"../rtc_base:checks",
"../rtc_base:rtc_base_approved",
"../rtc_base:sequenced_task_checker",
"../rtc_base/synchronization:sequence_checker",
"../system_wrappers",
"../system_wrappers:field_trial",
"../system_wrappers:metrics",
@ -244,10 +244,10 @@ rtc_static_library("call") {
"../rtc_base:rtc_base_approved",
"../rtc_base:rtc_task_queue",
"../rtc_base:safe_minmax",
"../rtc_base:sequenced_task_checker",
"../rtc_base/experiments:field_trial_parser",
"../rtc_base/network:sent_packet",
"../rtc_base/synchronization:rw_lock_wrapper",
"../rtc_base/synchronization:sequence_checker",
"../system_wrappers",
"../system_wrappers:field_trial",
"../system_wrappers:metrics",
@ -293,7 +293,7 @@ rtc_source_set("simulated_network") {
"../api/units:timestamp",
"../rtc_base:checks",
"../rtc_base:rtc_base_approved",
"../rtc_base:sequenced_task_checker",
"../rtc_base/synchronization:sequence_checker",
"//third_party/abseil-cpp/absl/memory",
"//third_party/abseil-cpp/absl/types:optional",
]
@ -324,7 +324,7 @@ rtc_source_set("fake_network") {
"../modules/utility",
"../rtc_base:checks",
"../rtc_base:rtc_base_approved",
"../rtc_base:sequenced_task_checker",
"../rtc_base/synchronization:sequence_checker",
"../system_wrappers",
"//third_party/abseil-cpp/absl/memory",
]

12
call/bitrate_allocator.cc
View File

@ -77,7 +77,7 @@ BitrateAllocator::~BitrateAllocator() {
}
void BitrateAllocator::UpdateStartRate(uint32_t start_rate_bps) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&sequenced_checker_);
RTC_DCHECK_RUN_ON(&sequenced_checker_);
last_non_zero_bitrate_bps_ = start_rate_bps;
}
@ -100,7 +100,7 @@ void BitrateAllocator::OnNetworkChanged(uint32_t target_bitrate_bps,
uint8_t fraction_loss,
int64_t rtt,
int64_t bwe_period_ms) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&sequenced_checker_);
RTC_DCHECK_RUN_ON(&sequenced_checker_);
last_target_bps_ = target_bitrate_bps;
last_link_capacity_bps_ = link_capacity_bps;
last_non_zero_bitrate_bps_ =
@ -161,7 +161,7 @@ void BitrateAllocator::OnNetworkChanged(uint32_t target_bitrate_bps,
void BitrateAllocator::AddObserver(BitrateAllocatorObserver* observer,
MediaStreamAllocationConfig config) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&sequenced_checker_);
RTC_DCHECK_RUN_ON(&sequenced_checker_);
RTC_DCHECK_GT(config.bitrate_priority, 0);
RTC_DCHECK(std::isnormal(config.bitrate_priority));
auto it = FindObserverConfig(observer);
@ -254,7 +254,7 @@ void BitrateAllocator::UpdateAllocationLimits() {
}
void BitrateAllocator::RemoveObserver(BitrateAllocatorObserver* observer) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&sequenced_checker_);
RTC_DCHECK_RUN_ON(&sequenced_checker_);
auto it = FindObserverConfig(observer);
if (it != bitrate_observer_configs_.end()) {
@ -266,7 +266,7 @@ void BitrateAllocator::RemoveObserver(BitrateAllocatorObserver* observer) {
int BitrateAllocator::GetStartBitrate(
BitrateAllocatorObserver* observer) const {
RTC_DCHECK_CALLED_SEQUENTIALLY(&sequenced_checker_);
RTC_DCHECK_RUN_ON(&sequenced_checker_);
const auto& it = FindObserverConfig(observer);
if (it == bitrate_observer_configs_.end()) {
// This observer hasn't been added yet, just give it its fair share.
@ -285,7 +285,7 @@ int BitrateAllocator::GetStartBitrate(
void BitrateAllocator::SetBitrateAllocationStrategy(
std::unique_ptr<rtc::BitrateAllocationStrategy>
bitrate_allocation_strategy) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&sequenced_checker_);
RTC_DCHECK_RUN_ON(&sequenced_checker_);
bitrate_allocation_strategy_ = std::move(bitrate_allocation_strategy);
}

4
call/bitrate_allocator.h
View File

@ -21,7 +21,7 @@
#include "api/call/bitrate_allocation.h"
#include "rtc_base/bitrate_allocation_strategy.h"
#include "rtc_base/sequenced_task_checker.h"
#include "rtc_base/synchronization/sequence_checker.h"
namespace webrtc {
@ -226,7 +226,7 @@ class BitrateAllocator : public BitrateAllocatorInterface {
// AudioPriorityBitrateAllocationStrategy.
static uint8_t GetTransmissionMaxBitrateMultiplier();
rtc::SequencedTaskChecker sequenced_checker_;
SequenceChecker sequenced_checker_;
LimitObserver* const limit_observer_ RTC_GUARDED_BY(&sequenced_checker_);
// Stored in a list to keep track of the insertion order.
ObserverConfigs bitrate_observer_configs_ RTC_GUARDED_BY(&sequenced_checker_);

36
call/call.cc
View File

@ -50,9 +50,9 @@
#include "rtc_base/location.h"
#include "rtc_base/logging.h"
#include "rtc_base/numerics/safe_minmax.h"
#include "rtc_base/sequenced_task_checker.h"
#include "rtc_base/strings/string_builder.h"
#include "rtc_base/synchronization/rw_lock_wrapper.h"
#include "rtc_base/synchronization/sequence_checker.h"
#include "rtc_base/thread_annotations.h"
#include "rtc_base/time_utils.h"
#include "rtc_base/trace_event.h"
@ -285,7 +285,7 @@ class Call final : public webrtc::Call,
const std::unique_ptr<CallStats> call_stats_;
const std::unique_ptr<BitrateAllocator> bitrate_allocator_;
Call::Config config_;
rtc::SequencedTaskChecker configuration_sequence_checker_;
SequenceChecker configuration_sequence_checker_;
NetworkState audio_network_state_;
NetworkState video_network_state_;
@ -493,7 +493,7 @@ Call::Call(Clock* clock,
}
Call::~Call() {
RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_);
RTC_DCHECK_RUN_ON(&configuration_sequence_checker_);
RTC_CHECK(audio_send_ssrcs_.empty());
RTC_CHECK(video_send_ssrcs_.empty());
@ -698,14 +698,14 @@ void Call::UpdateReceiveHistograms() {
}
PacketReceiver* Call::Receiver() {
RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_);
RTC_DCHECK_RUN_ON(&configuration_sequence_checker_);
return this;
}
webrtc::AudioSendStream* Call::CreateAudioSendStream(
const webrtc::AudioSendStream::Config& config) {
TRACE_EVENT0("webrtc", "Call::CreateAudioSendStream");
RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_);
RTC_DCHECK_RUN_ON(&configuration_sequence_checker_);
RTC_DCHECK(media_transport() == config.media_transport);
@ -747,7 +747,7 @@ webrtc::AudioSendStream* Call::CreateAudioSendStream(
void Call::DestroyAudioSendStream(webrtc::AudioSendStream* send_stream) {
TRACE_EVENT0("webrtc", "Call::DestroyAudioSendStream");
RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_);
RTC_DCHECK_RUN_ON(&configuration_sequence_checker_);
RTC_DCHECK(send_stream != nullptr);
send_stream->Stop();
@ -776,7 +776,7 @@ void Call::DestroyAudioSendStream(webrtc::AudioSendStream* send_stream) {
webrtc::AudioReceiveStream* Call::CreateAudioReceiveStream(
const webrtc::AudioReceiveStream::Config& config) {
TRACE_EVENT0("webrtc", "Call::CreateAudioReceiveStream");
RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_);
RTC_DCHECK_RUN_ON(&configuration_sequence_checker_);
RegisterRateObserver();
event_log_->Log(absl::make_unique<RtcEventAudioReceiveStreamConfig>(
CreateRtcLogStreamConfig(config)));
@ -806,7 +806,7 @@ webrtc::AudioReceiveStream* Call::CreateAudioReceiveStream(
void Call::DestroyAudioReceiveStream(
webrtc::AudioReceiveStream* receive_stream) {
TRACE_EVENT0("webrtc", "Call::DestroyAudioReceiveStream");
RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_);
RTC_DCHECK_RUN_ON(&configuration_sequence_checker_);
RTC_DCHECK(receive_stream != nullptr);
webrtc::internal::AudioReceiveStream* audio_receive_stream =
static_cast<webrtc::internal::AudioReceiveStream*>(receive_stream);
@ -836,7 +836,7 @@ webrtc::VideoSendStream* Call::CreateVideoSendStream(
VideoEncoderConfig encoder_config,
std::unique_ptr<FecController> fec_controller) {
TRACE_EVENT0("webrtc", "Call::CreateVideoSendStream");
RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_);
RTC_DCHECK_RUN_ON(&configuration_sequence_checker_);
RTC_DCHECK(media_transport() == config.media_transport);
@ -891,7 +891,7 @@ webrtc::VideoSendStream* Call::CreateVideoSendStream(
void Call::DestroyVideoSendStream(webrtc::VideoSendStream* send_stream) {
TRACE_EVENT0("webrtc", "Call::DestroyVideoSendStream");
RTC_DCHECK(send_stream != nullptr);
RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_);
RTC_DCHECK_RUN_ON(&configuration_sequence_checker_);
send_stream->Stop();
@ -929,7 +929,7 @@ void Call::DestroyVideoSendStream(webrtc::VideoSendStream* send_stream) {
webrtc::VideoReceiveStream* Call::CreateVideoReceiveStream(
webrtc::VideoReceiveStream::Config configuration) {
TRACE_EVENT0("webrtc", "Call::CreateVideoReceiveStream");
RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_);
RTC_DCHECK_RUN_ON(&configuration_sequence_checker_);
receive_side_cc_.SetSendPeriodicFeedback(
SendPeriodicFeedback(configuration.rtp.extensions));
@ -967,7 +967,7 @@ webrtc::VideoReceiveStream* Call::CreateVideoReceiveStream(
void Call::DestroyVideoReceiveStream(
webrtc::VideoReceiveStream* receive_stream) {
TRACE_EVENT0("webrtc", "Call::DestroyVideoReceiveStream");
RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_);
RTC_DCHECK_RUN_ON(&configuration_sequence_checker_);
RTC_DCHECK(receive_stream != nullptr);
VideoReceiveStream* receive_stream_impl =
static_cast<VideoReceiveStream*>(receive_stream);
@ -994,7 +994,7 @@ void Call::DestroyVideoReceiveStream(
FlexfecReceiveStream* Call::CreateFlexfecReceiveStream(
const FlexfecReceiveStream::Config& config) {
TRACE_EVENT0("webrtc", "Call::CreateFlexfecReceiveStream");
RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_);
RTC_DCHECK_RUN_ON(&configuration_sequence_checker_);
RecoveredPacketReceiver* recovered_packet_receiver = this;
@ -1026,7 +1026,7 @@ FlexfecReceiveStream* Call::CreateFlexfecReceiveStream(
void Call::DestroyFlexfecReceiveStream(FlexfecReceiveStream* receive_stream) {
TRACE_EVENT0("webrtc", "Call::DestroyFlexfecReceiveStream");
RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_);
RTC_DCHECK_RUN_ON(&configuration_sequence_checker_);
RTC_DCHECK(receive_stream != nullptr);
{
@ -1052,7 +1052,7 @@ RtpTransportControllerSendInterface* Call::GetTransportControllerSend() {
Call::Stats Call::GetStats() const {
// TODO(solenberg): Some test cases in EndToEndTest use this from a different
// thread. Re-enable once that is fixed.
// RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_);
// RTC_DCHECK_RUN_ON(&configuration_sequence_checker_);
Stats stats;
// Fetch available send/receive bitrates.
std::vector<unsigned int> ssrcs;
@ -1101,7 +1101,7 @@ void Call::SetBitrateAllocationStrategy(
}
void Call::SignalChannelNetworkState(MediaType media, NetworkState state) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_);
RTC_DCHECK_RUN_ON(&configuration_sequence_checker_);
switch (media) {
case MediaType::AUDIO:
audio_network_state_ = state;
@ -1141,7 +1141,7 @@ void Call::OnAudioTransportOverheadChanged(int transport_overhead_per_packet) {
}
void Call::UpdateAggregateNetworkState() {
RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_);
RTC_DCHECK_RUN_ON(&configuration_sequence_checker_);
bool have_audio = false;
bool have_video = false;
@ -1453,7 +1453,7 @@ PacketReceiver::DeliveryStatus Call::DeliverPacket(
MediaType media_type,
rtc::CopyOnWriteBuffer packet,
int64_t packet_time_us) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_);
RTC_DCHECK_RUN_ON(&configuration_sequence_checker_);
if (RtpHeaderParser::IsRtcp(packet.cdata(), packet.size()))
return DeliverRtcp(media_type, packet.cdata(), packet.size());

2
logging/BUILD.gn
View File

@ -264,7 +264,7 @@ rtc_static_library("rtc_event_log_impl_base") {
"../rtc_base:rtc_base_approved",
"../rtc_base:rtc_task_queue",
"../rtc_base:safe_minmax",
"../rtc_base:sequenced_task_checker",
"../rtc_base/synchronization:sequence_checker",
"//third_party/abseil-cpp/absl/memory",
"//third_party/abseil-cpp/absl/types:optional",
]

10
logging/rtc_event_log/rtc_event_log_impl.cc
View File

@ -30,7 +30,7 @@
#include "rtc_base/logging.h"
#include "rtc_base/numerics/safe_conversions.h"
#include "rtc_base/numerics/safe_minmax.h"
#include "rtc_base/sequenced_task_checker.h"
#include "rtc_base/synchronization/sequence_checker.h"
#include "rtc_base/task_queue.h"
#include "rtc_base/thread_annotations.h"
#include "rtc_base/time_utils.h"
@ -114,7 +114,7 @@ class RtcEventLogImpl final : public RtcEventLog {
// Make sure that the event log is "managed" - created/destroyed, as well
// as started/stopped - from the same thread/task-queue.
rtc::SequencedTaskChecker owner_sequence_checker_;
SequenceChecker owner_sequence_checker_;
// History containing all past configuration events.
std::deque<std::unique_ptr<RtcEvent>> config_history_
@ -158,7 +158,7 @@ RtcEventLogImpl::RtcEventLogImpl(
}
RtcEventLogImpl::~RtcEventLogImpl() {
RTC_DCHECK_CALLED_SEQUENTIALLY(&owner_sequence_checker_);
RTC_DCHECK_RUN_ON(&owner_sequence_checker_);
// If we're logging to the output, this will stop that. Blocking function.
StopLogging();
@ -172,7 +172,7 @@ RtcEventLogImpl::~RtcEventLogImpl() {
bool RtcEventLogImpl::StartLogging(std::unique_ptr<RtcEventLogOutput> output,
int64_t output_period_ms) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&owner_sequence_checker_);
RTC_DCHECK_RUN_ON(&owner_sequence_checker_);
RTC_DCHECK(output_period_ms == kImmediateOutput || output_period_ms > 0);
@ -207,7 +207,7 @@ bool RtcEventLogImpl::StartLogging(std::unique_ptr<RtcEventLogOutput> output,
}
void RtcEventLogImpl::StopLogging() {
RTC_DCHECK_CALLED_SEQUENTIALLY(&owner_sequence_checker_);
RTC_DCHECK_RUN_ON(&owner_sequence_checker_);
RTC_LOG(LS_INFO) << "Stopping WebRTC event log.";

4
media/BUILD.gn
View File

@ -75,8 +75,8 @@ rtc_static_library("rtc_media_base") {
"../rtc_base:rtc_base_approved",
"../rtc_base:rtc_task_queue",
"../rtc_base:sanitizer",
"../rtc_base:sequenced_task_checker",
"../rtc_base:stringutils",
"../rtc_base/synchronization:sequence_checker",
]
sources = [
"base/adapted_video_track_source.cc",
@ -167,8 +167,8 @@ rtc_static_library("rtc_simulcast_encoder_adapter") {
"../modules/video_coding:video_coding_utility",
"../rtc_base:checks",
"../rtc_base:rtc_base_approved",
"../rtc_base:sequenced_task_checker",
"../rtc_base/experiments:rate_control_settings",
"../rtc_base/synchronization:sequence_checker",
"../rtc_base/system:rtc_export",
"../system_wrappers",
"../system_wrappers:field_trial",

10
media/engine/simulcast_encoder_adapter.cc
View File

@ -144,7 +144,7 @@ SimulcastEncoderAdapter::~SimulcastEncoderAdapter() {
}
int SimulcastEncoderAdapter::Release() {
RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_);
RTC_DCHECK_RUN_ON(&encoder_queue_);
while (!streaminfos_.empty()) {
std::unique_ptr<VideoEncoder> encoder =
@ -169,7 +169,7 @@ int SimulcastEncoderAdapter::Release() {
int SimulcastEncoderAdapter::InitEncode(const VideoCodec* inst,
int number_of_cores,
size_t max_payload_size) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_);
RTC_DCHECK_RUN_ON(&encoder_queue_);
if (number_of_cores < 1) {
return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
@ -339,7 +339,7 @@ int SimulcastEncoderAdapter::InitEncode(const VideoCodec* inst,
int SimulcastEncoderAdapter::Encode(
const VideoFrame& input_image,
const std::vector<VideoFrameType>* frame_types) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_);
RTC_DCHECK_RUN_ON(&encoder_queue_);
if (!Initialized()) {
return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
@ -438,7 +438,7 @@ int SimulcastEncoderAdapter::Encode(
int SimulcastEncoderAdapter::RegisterEncodeCompleteCallback(
EncodedImageCallback* callback) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_);
RTC_DCHECK_RUN_ON(&encoder_queue_);
encoded_complete_callback_ = callback;
return WEBRTC_VIDEO_CODEC_OK;
}
@ -446,7 +446,7 @@ int SimulcastEncoderAdapter::RegisterEncodeCompleteCallback(
int SimulcastEncoderAdapter::SetRateAllocation(
const VideoBitrateAllocation& bitrate,
uint32_t new_framerate) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_);
RTC_DCHECK_RUN_ON(&encoder_queue_);
if (!Initialized()) {
return WEBRTC_VIDEO_CODEC_UNINITIALIZED;

4
media/engine/simulcast_encoder_adapter.h
View File

@ -22,7 +22,7 @@
#include "api/video_codecs/sdp_video_format.h"
#include "modules/video_coding/include/video_codec_interface.h"
#include "rtc_base/atomic_ops.h"
#include "rtc_base/sequenced_task_checker.h"
#include "rtc_base/synchronization/sequence_checker.h"
#include "rtc_base/system/rtc_export.h"
namespace webrtc {
@ -109,7 +109,7 @@ class RTC_EXPORT SimulcastEncoderAdapter : public VideoEncoder {
EncoderInfo encoder_info_;
// Used for checking the single-threaded access of the encoder interface.
rtc::SequencedTaskChecker encoder_queue_;
SequenceChecker encoder_queue_;
// Store encoders in between calls to Release and InitEncode, so they don't
// have to be recreated. Remaining encoders are destroyed by the destructor.

2
modules/congestion_controller/rtp/BUILD.gn
View File

@ -32,7 +32,7 @@ rtc_source_set("control_handler") {
"../../../rtc_base:checks",
"../../../rtc_base:rate_limiter",
"../../../rtc_base:safe_minmax",
"../../../rtc_base:sequenced_task_checker",
"../../../rtc_base/synchronization:sequence_checker",
"../../../system_wrappers",
"../../../system_wrappers:field_trial",
"../../pacing",

8
modules/congestion_controller/rtp/control_handler.cc
View File

@ -37,22 +37,22 @@ CongestionControlHandler::~CongestionControlHandler() {}
void CongestionControlHandler::SetTargetRate(
TargetTransferRate new_target_rate) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&sequenced_checker_);
RTC_DCHECK_RUN_ON(&sequenced_checker_);
last_incoming_ = new_target_rate;
}
void CongestionControlHandler::SetNetworkAvailability(bool network_available) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&sequenced_checker_);
RTC_DCHECK_RUN_ON(&sequenced_checker_);
network_available_ = network_available;
}
void CongestionControlHandler::SetPacerQueue(TimeDelta expected_queue_time) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&sequenced_checker_);
RTC_DCHECK_RUN_ON(&sequenced_checker_);
pacer_expected_queue_ms_ = expected_queue_time.ms();
}
absl::optional<TargetTransferRate> CongestionControlHandler::GetUpdate() {
RTC_DCHECK_CALLED_SEQUENTIALLY(&sequenced_checker_);
RTC_DCHECK_RUN_ON(&sequenced_checker_);
if (!last_incoming_.has_value())
return absl::nullopt;
TargetTransferRate new_outgoing = *last_incoming_;

4
modules/congestion_controller/rtp/control_handler.h
View File

@ -19,7 +19,7 @@
#include "api/units/time_delta.h"
#include "modules/pacing/paced_sender.h"
#include "rtc_base/constructor_magic.h"
#include "rtc_base/sequenced_task_checker.h"
#include "rtc_base/synchronization/sequence_checker.h"
namespace webrtc {
// This is used to observe the network controller state and route calls to
@ -46,7 +46,7 @@ class CongestionControlHandler {
const bool disable_pacer_emergency_stop_;
int64_t pacer_expected_queue_ms_ = 0;
rtc::SequencedTaskChecker sequenced_checker_;
SequenceChecker sequenced_checker_;
RTC_DISALLOW_COPY_AND_ASSIGN(CongestionControlHandler);
};
} // namespace webrtc

2
modules/rtp_rtcp/BUILD.gn
View File

@ -227,7 +227,7 @@ rtc_static_library("rtp_rtcp") {
"../../rtc_base:rtc_base_approved",
"../../rtc_base:rtc_numerics",
"../../rtc_base:safe_minmax",
"../../rtc_base:sequenced_task_checker",
"../../rtc_base/synchronization:sequence_checker",
"../../rtc_base/system:fallthrough",
"../../rtc_base/time:timestamp_extrapolator",
"../../system_wrappers",

4
modules/rtp_rtcp/include/flexfec_receiver.h
View File

@ -18,7 +18,7 @@
#include "modules/rtp_rtcp/include/ulpfec_receiver.h"
#include "modules/rtp_rtcp/source/forward_error_correction.h"
#include "modules/rtp_rtcp/source/rtp_packet_received.h"
#include "rtc_base/sequenced_task_checker.h"
#include "rtc_base/synchronization/sequence_checker.h"
#include "rtc_base/thread_annotations.h"
namespace webrtc {
@ -68,7 +68,7 @@ class FlexfecReceiver {
int64_t last_recovered_packet_ms_ RTC_GUARDED_BY(sequence_checker_);
FecPacketCounter packet_counter_ RTC_GUARDED_BY(sequence_checker_);
rtc::SequencedTaskChecker sequence_checker_;
SequenceChecker sequence_checker_;
};
} // namespace webrtc

8
modules/rtp_rtcp/source/flexfec_receiver.cc
View File

@ -61,7 +61,7 @@ FlexfecReceiver::FlexfecReceiver(
FlexfecReceiver::~FlexfecReceiver() = default;
void FlexfecReceiver::OnRtpPacket(const RtpPacketReceived& packet) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_);
RTC_DCHECK_RUN_ON(&sequence_checker_);
// If this packet was recovered, it might be originating from
// ProcessReceivedPacket in this object. To avoid lifetime issues with
@ -79,7 +79,7 @@ void FlexfecReceiver::OnRtpPacket(const RtpPacketReceived& packet) {
}
FecPacketCounter FlexfecReceiver::GetPacketCounter() const {
RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_);
RTC_DCHECK_RUN_ON(&sequence_checker_);
return packet_counter_;
}
@ -87,7 +87,7 @@ FecPacketCounter FlexfecReceiver::GetPacketCounter() const {
// recovered packets here.
std::unique_ptr<ReceivedPacket> FlexfecReceiver::AddReceivedPacket(
const RtpPacketReceived& packet) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_);
RTC_DCHECK_RUN_ON(&sequence_checker_);
// RTP packets with a full base header (12 bytes), but without payload,
// could conceivably be useful in the decoding. Therefore we check
@ -145,7 +145,7 @@ std::unique_ptr<ReceivedPacket> FlexfecReceiver::AddReceivedPacket(
// of non-recovered media packets.
void FlexfecReceiver::ProcessReceivedPacket(
const ReceivedPacket& received_packet) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_);
RTC_DCHECK_RUN_ON(&sequence_checker_);
// Decode.
erasure_code_->DecodeFec(received_packet, &recovered_packets_);

2
modules/rtp_rtcp/source/rtp_sender_video.h
View File

@ -26,7 +26,7 @@
#include "rtc_base/critical_section.h"
#include "rtc_base/one_time_event.h"
#include "rtc_base/rate_statistics.h"
#include "rtc_base/sequenced_task_checker.h"
#include "rtc_base/synchronization/sequence_checker.h"
#include "rtc_base/thread_annotations.h"
namespace webrtc {

6
modules/video_coding/BUILD.gn
View File

@ -165,10 +165,10 @@ rtc_static_library("video_coding") {
"../../rtc_base:rtc_base_approved",
"../../rtc_base:rtc_numerics",
"../../rtc_base:rtc_task_queue",
"../../rtc_base:sequenced_task_checker",
"../../rtc_base/experiments:alr_experiment",
"../../rtc_base/experiments:jitter_upper_bound_experiment",
"../../rtc_base/experiments:rtt_mult_experiment",
"../../rtc_base/synchronization:sequence_checker",
"../../rtc_base/system:fallthrough",
"../../rtc_base/third_party/base64",
"../../rtc_base/time:timestamp_extrapolator",
@ -255,9 +255,9 @@ rtc_source_set("video_coding_utility") {
"../../rtc_base:rtc_base_approved",
"../../rtc_base:rtc_numerics",
"../../rtc_base:rtc_task_queue",
"../../rtc_base:sequenced_task_checker",
"../../rtc_base/experiments:quality_scaling_experiment",
"../../rtc_base/experiments:rate_control_settings",
"../../rtc_base/synchronization:sequence_checker",
"../../rtc_base/system:arch",
"../../rtc_base/system:file_wrapper",
"../../rtc_base/task_utils:repeating_task",
@ -577,7 +577,7 @@ if (rtc_include_tests) {
"../../rtc_base:checks",
"../../rtc_base:rtc_base_approved",
"../../rtc_base:rtc_task_queue",
"../../rtc_base:sequenced_task_checker",
"../../rtc_base/synchronization:sequence_checker",
"../../rtc_base/task_utils:to_queued_task",
"../../test:test_support",
"../../test:video_test_common",

12
modules/video_coding/codecs/test/videoprocessor.cc
View File

@ -226,7 +226,7 @@ VideoProcessor::VideoProcessor(webrtc::VideoEncoder* encoder,
}
VideoProcessor::~VideoProcessor() {
RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_);
RTC_DCHECK_RUN_ON(&sequence_checker_);
// Explicitly reset codecs, in case they don't do that themselves when they
// go out of scope.
@ -242,7 +242,7 @@ VideoProcessor::~VideoProcessor() {
}
void VideoProcessor::ProcessFrame() {
RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_);
RTC_DCHECK_RUN_ON(&sequence_checker_);
const size_t frame_number = last_inputed_frame_num_++;
// Get input frame and store for future quality calculation.
@ -296,7 +296,7 @@ void VideoProcessor::ProcessFrame() {
}
void VideoProcessor::SetRates(size_t bitrate_kbps, size_t framerate_fps) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_);
RTC_DCHECK_RUN_ON(&sequence_checker_);
framerate_fps_ = static_cast<uint32_t>(framerate_fps);
bitrate_allocation_ = bitrate_allocator_->GetAllocation(
static_cast<uint32_t>(bitrate_kbps * 1000), framerate_fps_);
@ -333,7 +333,7 @@ int32_t VideoProcessor::VideoProcessorDecodeCompleteCallback::Decoded(
void VideoProcessor::FrameEncoded(
const webrtc::EncodedImage& encoded_image,
const webrtc::CodecSpecificInfo& codec_specific) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_);
RTC_DCHECK_RUN_ON(&sequence_checker_);
// For the highest measurement accuracy of the encode time, the start/stop
// time recordings should wrap the Encode call as tightly as possible.
@ -455,7 +455,7 @@ void VideoProcessor::FrameEncoded(
void VideoProcessor::FrameDecoded(const VideoFrame& decoded_frame,
size_t spatial_idx) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_);
RTC_DCHECK_RUN_ON(&sequence_checker_);
// For the highest measurement accuracy of the decode time, the start/stop
// time recordings should wrap the Decode call as tightly as possible.
@ -529,7 +529,7 @@ void VideoProcessor::FrameDecoded(const VideoFrame& decoded_frame,
void VideoProcessor::DecodeFrame(const EncodedImage& encoded_image,
size_t spatial_idx) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_);
RTC_DCHECK_RUN_ON(&sequence_checker_);
FrameStatistics* frame_stat =
stats_->GetFrameWithTimestamp(encoded_image.Timestamp(), spatial_idx);

4
modules/video_coding/codecs/test/videoprocessor.h
View File

@ -36,7 +36,7 @@
#include "rtc_base/buffer.h"
#include "rtc_base/checks.h"
#include "rtc_base/constructor_magic.h"
#include "rtc_base/sequenced_task_checker.h"
#include "rtc_base/synchronization/sequence_checker.h"
#include "rtc_base/thread_annotations.h"
#include "rtc_base/thread_checker.h"
#include "test/testsupport/frame_reader.h"
@ -250,7 +250,7 @@ class VideoProcessor {
int64_t post_encode_time_ns_ RTC_GUARDED_BY(sequence_checker_);
// This class must be operated on a TaskQueue.
rtc::SequencedTaskChecker sequence_checker_;
SequenceChecker sequence_checker_;
RTC_DISALLOW_COPY_AND_ASSIGN(VideoProcessor);
};

8
modules/video_coding/loss_notification_controller.cc
View File

@ -44,7 +44,7 @@ LossNotificationController::LossNotificationController(
LossNotificationController::~LossNotificationController() = default;
void LossNotificationController::OnReceivedPacket(const VCMPacket& packet) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&sequenced_task_checker_);
RTC_DCHECK_RUN_ON(&sequence_checker_);
if (!packet.generic_descriptor) {
RTC_LOG(LS_WARNING) << "Generic frame descriptor missing. Buggy remote? "
@ -116,7 +116,7 @@ void LossNotificationController::OnAssembledFrame(
uint16_t frame_id,
bool discardable,
rtc::ArrayView<const uint16_t> frame_dependency_diffs) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&sequenced_task_checker_);
RTC_DCHECK_RUN_ON(&sequence_checker_);
DiscardOldInformation(); // Prevent memory overconsumption.
@ -144,7 +144,7 @@ void LossNotificationController::DiscardOldInformation() {
bool LossNotificationController::AllDependenciesDecodable(
int64_t unwrapped_frame_id,
rtc::ArrayView<const uint16_t> frame_dependency_diffs) const {
RTC_DCHECK_CALLED_SEQUENTIALLY(&sequenced_task_checker_);
RTC_DCHECK_RUN_ON(&sequence_checker_);
// Due to packet reordering, frame buffering and asynchronous decoders, it is
// infeasible to make reliable conclusions on the decodability of a frame
@ -170,7 +170,7 @@ bool LossNotificationController::AllDependenciesDecodable(
void LossNotificationController::HandleLoss(uint16_t last_received_seq_num,
bool decodability_flag) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&sequenced_task_checker_);
RTC_DCHECK_RUN_ON(&sequence_checker_);
if (last_decodable_non_discardable_) {
RTC_DCHECK(AheadOf(last_received_seq_num,

21
modules/video_coding/loss_notification_controller.h
View File

@ -17,7 +17,7 @@
#include "modules/include/module_common_types.h"
#include "modules/video_coding/packet.h"
#include "rtc_base/numerics/sequence_number_util.h"
#include "rtc_base/sequenced_task_checker.h"
#include "rtc_base/synchronization/sequence_checker.h"
namespace webrtc {
@ -61,26 +61,25 @@ class LossNotificationController {
void HandleLoss(uint16_t last_received_seq_num, bool decodability_flag);
KeyFrameRequestSender* const key_frame_request_sender_
RTC_GUARDED_BY(sequenced_task_checker_);
RTC_GUARDED_BY(sequence_checker_);
LossNotificationSender* const loss_notification_sender_
RTC_GUARDED_BY(sequenced_task_checker_);
RTC_GUARDED_BY(sequence_checker_);
SeqNumUnwrapper<uint16_t> frame_id_unwrapper_
RTC_GUARDED_BY(sequenced_task_checker_);
RTC_GUARDED_BY(sequence_checker_);
// Tracked to avoid processing repeated frames (buggy/malicious remote).
absl::optional<int64_t> last_received_unwrapped_frame_id_
RTC_GUARDED_BY(sequenced_task_checker_);
RTC_GUARDED_BY(sequence_checker_);
// Tracked to avoid processing repeated packets.
absl::optional<uint16_t> last_received_seq_num_
RTC_GUARDED_BY(sequenced_task_checker_);
RTC_GUARDED_BY(sequence_checker_);
// Tracked in order to correctly report the potential-decodability of
// multi-packet frames.
bool current_frame_potentially_decodable_
RTC_GUARDED_BY(sequenced_task_checker_);
bool current_frame_potentially_decodable_ RTC_GUARDED_BY(sequence_checker_);
// Loss notifications contain the sequence number of the first packet of
// the last decodable-and-non-discardable frame. Since this is a bit of
@ -92,15 +91,15 @@ class LossNotificationController {
uint16_t first_seq_num;
};
absl::optional<FrameInfo> last_decodable_non_discardable_
RTC_GUARDED_BY(sequenced_task_checker_);
RTC_GUARDED_BY(sequence_checker_);
// Track which frames are decodable. Later frames are also decodable if
// all of their dependencies can be found in this container.
// (Naturally, later frames must also be assemblable to be decodable.)
std::set<int64_t> decodable_unwrapped_frame_ids_
RTC_GUARDED_BY(sequenced_task_checker_);
RTC_GUARDED_BY(sequence_checker_);
rtc::SequencedTaskChecker sequenced_task_checker_;
SequenceChecker sequence_checker_;
};
} // namespace webrtc

20
modules/video_coding/utility/quality_scaler.cc
View File

@ -88,7 +88,7 @@ QualityScaler::QualityScaler(rtc::TaskQueue* task_queue,
framedrop_percent_all_(5 * 30),
experiment_enabled_(QualityScalingExperiment::Enabled()),
observed_enough_frames_(false) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&task_checker_);
RTC_DCHECK_RUN_ON(&task_checker_);
if (experiment_enabled_) {
config_ = QualityScalingExperiment::GetConfig();
qp_smoother_high_.reset(new QpSmoother(config_.alpha_high));
@ -105,12 +105,12 @@ QualityScaler::QualityScaler(rtc::TaskQueue* task_queue,
}
QualityScaler::~QualityScaler() {
RTC_DCHECK_CALLED_SEQUENTIALLY(&task_checker_);
RTC_DCHECK_RUN_ON(&task_checker_);
check_qp_task_.Stop();
}
int64_t QualityScaler::GetSamplingPeriodMs() const {
RTC_DCHECK_CALLED_SEQUENTIALLY(&task_checker_);
RTC_DCHECK_RUN_ON(&task_checker_);
if (fast_rampup_) {
return sampling_period_ms_;
}
@ -122,18 +122,18 @@ int64_t QualityScaler::GetSamplingPeriodMs() const {
}
void QualityScaler::ReportDroppedFrameByMediaOpt() {
RTC_DCHECK_CALLED_SEQUENTIALLY(&task_checker_);
RTC_DCHECK_RUN_ON(&task_checker_);
framedrop_percent_media_opt_.AddSample(100);
framedrop_percent_all_.AddSample(100);
}
void QualityScaler::ReportDroppedFrameByEncoder() {
RTC_DCHECK_CALLED_SEQUENTIALLY(&task_checker_);
RTC_DCHECK_RUN_ON(&task_checker_);
framedrop_percent_all_.AddSample(100);
}
void QualityScaler::ReportQp(int qp, int64_t time_sent_us) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&task_checker_);
RTC_DCHECK_RUN_ON(&task_checker_);
framedrop_percent_media_opt_.AddSample(0);
framedrop_percent_all_.AddSample(0);
average_qp_.AddSample(qp);
@ -144,7 +144,7 @@ void QualityScaler::ReportQp(int qp, int64_t time_sent_us) {
}
void QualityScaler::CheckQp() {
RTC_DCHECK_CALLED_SEQUENTIALLY(&task_checker_);
RTC_DCHECK_RUN_ON(&task_checker_);
// Should be set through InitEncode -> Should be set by now.
RTC_DCHECK_GE(thresholds_.low, 0);
@ -193,13 +193,13 @@ void QualityScaler::CheckQp() {
}
void QualityScaler::ReportQpLow() {
RTC_DCHECK_CALLED_SEQUENTIALLY(&task_checker_);
RTC_DCHECK_RUN_ON(&task_checker_);
ClearSamples();
observer_->AdaptUp(AdaptationObserverInterface::AdaptReason::kQuality);
}
void QualityScaler::ReportQpHigh() {
RTC_DCHECK_CALLED_SEQUENTIALLY(&task_checker_);
RTC_DCHECK_RUN_ON(&task_checker_);
ClearSamples();
observer_->AdaptDown(AdaptationObserverInterface::AdaptReason::kQuality);
// If we've scaled down, wait longer before scaling up again.
@ -209,7 +209,7 @@ void QualityScaler::ReportQpHigh() {
}
void QualityScaler::ClearSamples() {
RTC_DCHECK_CALLED_SEQUENTIALLY(&task_checker_);
RTC_DCHECK_RUN_ON(&task_checker_);
framedrop_percent_media_opt_.Reset();
framedrop_percent_all_.Reset();
average_qp_.Reset();

4
modules/video_coding/utility/quality_scaler.h
View File

@ -18,7 +18,7 @@
#include "api/video_codecs/video_encoder.h"
#include "rtc_base/experiments/quality_scaling_experiment.h"
#include "rtc_base/numerics/moving_average.h"
#include "rtc_base/sequenced_task_checker.h"
#include "rtc_base/synchronization/sequence_checker.h"
#include "rtc_base/task_queue.h"
#include "rtc_base/task_utils/repeating_task.h"
@ -77,7 +77,7 @@ class QualityScaler {
RepeatingTaskHandle check_qp_task_ RTC_GUARDED_BY(&task_checker_);
AdaptationObserverInterface* const observer_ RTC_GUARDED_BY(&task_checker_);
rtc::SequencedTaskChecker task_checker_;
SequenceChecker task_checker_;
const VideoEncoder::QpThresholds thresholds_;
const int64_t sampling_period_ms_;

2
modules/video_coding/video_coding_impl.h
View File

@ -25,7 +25,7 @@
#include "modules/video_coding/receiver.h"
#include "modules/video_coding/timing.h"
#include "rtc_base/one_time_event.h"
#include "rtc_base/sequenced_task_checker.h"
#include "rtc_base/synchronization/sequence_checker.h"
#include "rtc_base/thread_annotations.h"
#include "rtc_base/thread_checker.h"
#include "system_wrappers/include/clock.h"

31
rtc_base/BUILD.gn
View File

@ -228,7 +228,7 @@ rtc_source_set("platform_thread") {
":rtc_task_queue_libevent",
":rtc_task_queue_win",
":rtc_task_queue_stdlib",
":sequenced_task_checker",
"synchronization:sequence_checker",
]
sources = [
"platform_thread.cc",
@ -573,15 +573,6 @@ rtc_source_set("rtc_task_queue_stdlib") {
]
}
rtc_source_set("sequenced_task_checker") {
sources = [
"sequenced_task_checker.h",
]
deps = [
"synchronization:sequence_checker",
]
}
rtc_static_library("weak_ptr") {
sources = [
"weak_ptr.cc",
@ -589,8 +580,8 @@ rtc_static_library("weak_ptr") {
]
deps = [
":refcount",
":sequenced_task_checker",
"../api:scoped_refptr",
"synchronization:sequence_checker",
]
}
@ -1280,24 +1271,6 @@ if (rtc_include_tests) {
]
}
rtc_source_set("sequenced_task_checker_unittests") {
testonly = true
sources = [
"sequenced_task_checker_unittest.cc",
]
deps = [
":checks",
":rtc_base_approved",
":rtc_base_tests_main",
":sequenced_task_checker",
":task_queue_for_test",
"../api:function_view",
"../test:test_support",
"//third_party/abseil-cpp/absl/memory",
]
}
rtc_source_set("weak_ptr_unittests") {
testonly = true

26
rtc_base/sequenced_task_checker.h
View File

@ -1,26 +0,0 @@
/*
* Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#ifndef RTC_BASE_SEQUENCED_TASK_CHECKER_H_
#define RTC_BASE_SEQUENCED_TASK_CHECKER_H_
#include "rtc_base/synchronization/sequence_checker.h"
namespace rtc {
// TODO(srte): Replace usages of this with SequenceChecker.
class SequencedTaskChecker : public webrtc::SequenceChecker {
public:
bool CalledSequentially() const { return IsCurrent(); }
};
} // namespace rtc
#define RTC_DCHECK_CALLED_SEQUENTIALLY(x) RTC_DCHECK_RUN_ON(x)
#endif // RTC_BASE_SEQUENCED_TASK_CHECKER_H_

173
rtc_base/sequenced_task_checker_unittest.cc
View File

@ -1,173 +0,0 @@
/*
* Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include "rtc_base/sequenced_task_checker.h"
#include <memory>
#include <utility>
#include "absl/memory/memory.h"
#include "api/function_view.h"
#include "rtc_base/event.h"
#include "rtc_base/platform_thread.h"
#include "rtc_base/task_queue_for_test.h"
#include "rtc_base/thread_checker.h"
#include "test/gtest.h"
namespace rtc {
namespace {
using ::webrtc::TaskQueueForTest;
// This class is dead code, but its purpose is to make sure that
// SequencedTaskChecker is compatible with the RTC_GUARDED_BY and RTC_RUN_ON
// attributes that are checked at compile-time.
class CompileTimeTestForGuardedBy {
public:
int CalledOnSequence() RTC_RUN_ON(sequence_checker_) { return guarded_; }
void CallMeFromSequence() {
RTC_DCHECK_RUN_ON(&sequence_checker_) << "Should be called on sequence";
guarded_ = 41;
}
private:
int guarded_ RTC_GUARDED_BY(sequence_checker_);
SequencedTaskChecker sequence_checker_;
};
void RunOnDifferentThread(FunctionView<void()> run) {
struct Object {
static void Run(void* obj) {
auto* me = static_cast<Object*>(obj);
me->run();
me->thread_has_run_event.Set();
}
FunctionView<void()> run;
Event thread_has_run_event;
} object{run};
PlatformThread thread(&Object::Run, &object, "thread");
thread.Start();
EXPECT_TRUE(object.thread_has_run_event.Wait(1000));
thread.Stop();
}
} // namespace
TEST(SequencedTaskCheckerTest, CallsAllowedOnSameThread) {
SequencedTaskChecker sequenced_task_checker;
EXPECT_TRUE(sequenced_task_checker.CalledSequentially());
}
TEST(SequencedTaskCheckerTest, DestructorAllowedOnDifferentThread) {
auto sequenced_task_checker = absl::make_unique<SequencedTaskChecker>();
RunOnDifferentThread([&] {
// Verify that the destructor doesn't assert when called on a different
// thread.
sequenced_task_checker.reset();
});
}
TEST(SequencedTaskCheckerTest, Detach) {
SequencedTaskChecker sequenced_task_checker;
sequenced_task_checker.Detach();
RunOnDifferentThread(
[&] { EXPECT_TRUE(sequenced_task_checker.CalledSequentially()); });
}
TEST(SequencedTaskCheckerTest, DetachFromThreadAndUseOnTaskQueue) {
SequencedTaskChecker sequenced_task_checker;
sequenced_task_checker.Detach();
TaskQueueForTest queue;
queue.SendTask(
[&] { EXPECT_TRUE(sequenced_task_checker.CalledSequentially()); });
}
TEST(SequencedTaskCheckerTest, DetachFromTaskQueueAndUseOnThread) {
TaskQueueForTest queue;
queue.SendTask([] {
SequencedTaskChecker sequenced_task_checker;
sequenced_task_checker.Detach();
RunOnDifferentThread(
[&] { EXPECT_TRUE(sequenced_task_checker.CalledSequentially()); });
});
}
TEST(SequencedTaskCheckerTest, MethodNotAllowedOnDifferentThreadInDebug) {
SequencedTaskChecker sequenced_task_checker;
RunOnDifferentThread([&] {
EXPECT_EQ(sequenced_task_checker.CalledSequentially(), !RTC_DCHECK_IS_ON);
});
}
TEST(SequencedTaskCheckerTest, MethodNotAllowedOnDifferentTaskQueueInDebug) {
SequencedTaskChecker sequenced_task_checker;
TaskQueueForTest queue;
queue.SendTask([&] {
EXPECT_EQ(sequenced_task_checker.CalledSequentially(), !RTC_DCHECK_IS_ON);
});
}
TEST(SequencedTaskCheckerTest, DetachFromTaskQueueInDebug) {
SequencedTaskChecker sequenced_task_checker;
sequenced_task_checker.Detach();
TaskQueueForTest queue1;
queue1.SendTask(
[&] { EXPECT_TRUE(sequenced_task_checker.CalledSequentially()); });
// CalledSequentially should return false in debug builds after moving to
// another task queue.
TaskQueueForTest queue2;
queue2.SendTask([&] {
EXPECT_EQ(sequenced_task_checker.CalledSequentially(), !RTC_DCHECK_IS_ON);
});
}
class TestAnnotations {
public:
TestAnnotations() : test_var_(false) {}
void ModifyTestVar() {
RTC_DCHECK_CALLED_SEQUENTIALLY(&checker_);
test_var_ = true;
}
private:
bool test_var_ RTC_GUARDED_BY(&checker_);
SequencedTaskChecker checker_;
};
TEST(SequencedTaskCheckerTest, TestAnnotations) {
TestAnnotations annotations;
annotations.ModifyTestVar();
}
#if GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID)
void TestAnnotationsOnWrongQueue() {
TestAnnotations annotations;
TaskQueueForTest queue;
queue.SendTask([&] { annotations.ModifyTestVar(); });
}
#if RTC_DCHECK_IS_ON
TEST(SequencedTaskCheckerTest, TestAnnotationsOnWrongQueueDebug) {
ASSERT_DEATH({ TestAnnotationsOnWrongQueue(); }, "");
}
#else
TEST(SequencedTaskCheckerTest, TestAnnotationsOnWrongQueueRelease) {
TestAnnotationsOnWrongQueue();
}
#endif
#endif // GTEST_HAS_DEATH_TEST
} // namespace rtc

18
rtc_base/synchronization/BUILD.gn
View File

@ -72,4 +72,22 @@ if (rtc_include_tests) {
"../../test:test_support",
]
}
rtc_source_set("sequence_checker_unittests") {
testonly = true
sources = [
"sequence_checker_unittest.cc",
]
deps = [
":sequence_checker",
"..:checks",
"..:rtc_base_approved",
"..:rtc_base_tests_main",
"..:task_queue_for_test",
"../../api:function_view",
"../../test:test_support",
"//third_party/abseil-cpp/absl/memory",
]
}
}

164
rtc_base/synchronization/sequence_checker_unittest.cc Normal file
View File

@ -0,0 +1,164 @@
/*
* Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include "rtc_base/synchronization/sequence_checker.h"
#include <memory>
#include <utility>
#include "absl/memory/memory.h"
#include "api/function_view.h"
#include "rtc_base/event.h"
#include "rtc_base/platform_thread.h"
#include "rtc_base/task_queue_for_test.h"
#include "rtc_base/thread_checker.h"
#include "test/gtest.h"
namespace webrtc {
namespace {
// This class is dead code, but its purpose is to make sure that
// SequenceChecker is compatible with the RTC_GUARDED_BY and RTC_RUN_ON
// attributes that are checked at compile-time.
class CompileTimeTestForGuardedBy {
public:
int CalledOnSequence() RTC_RUN_ON(sequence_checker_) { return guarded_; }
void CallMeFromSequence() {
RTC_DCHECK_RUN_ON(&sequence_checker_) << "Should be called on sequence";
guarded_ = 41;
}
private:
int guarded_ RTC_GUARDED_BY(sequence_checker_);
::webrtc::SequenceChecker sequence_checker_;
};
void RunOnDifferentThread(rtc::FunctionView<void()> run) {
struct Object {
static void Run(void* obj) {
auto* me = static_cast<Object*>(obj);
me->run();
me->thread_has_run_event.Set();
}
rtc::FunctionView<void()> run;
rtc::Event thread_has_run_event;
} object{run};
rtc::PlatformThread thread(&Object::Run, &object, "thread");
thread.Start();
EXPECT_TRUE(object.thread_has_run_event.Wait(1000));
thread.Stop();
}
} // namespace
TEST(SequenceCheckerTest, CallsAllowedOnSameThread) {
SequenceChecker sequence_checker;
EXPECT_TRUE(sequence_checker.IsCurrent());
}
TEST(SequenceCheckerTest, DestructorAllowedOnDifferentThread) {
auto sequence_checker = absl::make_unique<SequenceChecker>();
RunOnDifferentThread([&] {
// Verify that the destructor doesn't assert when called on a different
// thread.
sequence_checker.reset();
});
}
TEST(SequenceCheckerTest, Detach) {
SequenceChecker sequence_checker;
sequence_checker.Detach();
RunOnDifferentThread([&] { EXPECT_TRUE(sequence_checker.IsCurrent()); });
}
TEST(SequenceCheckerTest, DetachFromThreadAndUseOnTaskQueue) {
SequenceChecker sequence_checker;
sequence_checker.Detach();
TaskQueueForTest queue;
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()); });
});
}
TEST(SequenceCheckerTest, MethodNotAllowedOnDifferentThreadInDebug) {
SequenceChecker sequence_checker;
RunOnDifferentThread(
[&] { EXPECT_EQ(sequence_checker.IsCurrent(), !RTC_DCHECK_IS_ON); });
}
TEST(SequenceCheckerTest, MethodNotAllowedOnDifferentTaskQueueInDebug) {
SequenceChecker sequence_checker;
TaskQueueForTest queue;
queue.SendTask(
[&] { EXPECT_EQ(sequence_checker.IsCurrent(), !RTC_DCHECK_IS_ON); });
}
TEST(SequenceCheckerTest, DetachFromTaskQueueInDebug) {
SequenceChecker sequence_checker;
sequence_checker.Detach();
TaskQueueForTest queue1;
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); });
}
class TestAnnotations {
public:
TestAnnotations() : test_var_(false) {}
void ModifyTestVar() {
RTC_DCHECK_RUN_ON(&checker_);
test_var_ = true;
}
private:
bool test_var_ RTC_GUARDED_BY(&checker_);
SequenceChecker checker_;
};
TEST(SequenceCheckerTest, TestAnnotations) {
TestAnnotations annotations;
annotations.ModifyTestVar();
}
#if GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID)
void TestAnnotationsOnWrongQueue() {
TestAnnotations annotations;
TaskQueueForTest queue;
queue.SendTask([&] { annotations.ModifyTestVar(); });
}
#if RTC_DCHECK_IS_ON
TEST(SequenceCheckerTest, TestAnnotationsOnWrongQueueDebug) {
ASSERT_DEATH({ TestAnnotationsOnWrongQueue(); }, "");
}
#else
TEST(SequenceCheckerTest, TestAnnotationsOnWrongQueueRelease) {
TestAnnotationsOnWrongQueue();
}
#endif
#endif // GTEST_HAS_DEATH_TEST
} // namespace webrtc

2
rtc_base/task_utils/BUILD.gn
View File

@ -16,12 +16,12 @@ rtc_source_set("repeating_task") {
deps = [
":to_queued_task",
"..:logging",
"..:sequenced_task_checker",
"..:thread_checker",
"..:timeutils",
"../../api/task_queue",
"../../api/units:time_delta",
"../../api/units:timestamp",
"../synchronization:sequence_checker",
"//third_party/abseil-cpp/absl/memory",
]
}

2
rtc_base/task_utils/repeating_task.h
View File

@ -19,7 +19,7 @@
#include "api/task_queue/task_queue_base.h"
#include "api/units/time_delta.h"
#include "api/units/timestamp.h"
#include "rtc_base/sequenced_task_checker.h"
#include "rtc_base/synchronization/sequence_checker.h"
#include "rtc_base/thread_checker.h"
namespace webrtc {

4
rtc_base/weak_ptr.cc
View File

@ -24,13 +24,13 @@ WeakReference::Flag::Flag() : is_valid_(true) {
}
void WeakReference::Flag::Invalidate() {
RTC_DCHECK(checker_.CalledSequentially())
RTC_DCHECK(checker_.IsCurrent())
<< "WeakPtrs must be invalidated on the same sequence.";
is_valid_ = false;
}
bool WeakReference::Flag::IsValid() const {
RTC_DCHECK(checker_.CalledSequentially())
RTC_DCHECK(checker_.IsCurrent())
<< "WeakPtrs must be checked on the same sequence.";
return is_valid_;
}

4
rtc_base/weak_ptr.h
View File

@ -18,7 +18,7 @@
#include "api/scoped_refptr.h"
#include "rtc_base/ref_count.h"
#include "rtc_base/ref_counted_object.h"
#include "rtc_base/sequenced_task_checker.h"
#include "rtc_base/synchronization/sequence_checker.h"
// The implementation is borrowed from chromium except that it does not
// implement SupportsWeakPtr.
@ -104,7 +104,7 @@ class WeakReference {
~Flag() override;
SequencedTaskChecker checker_;
::webrtc::SequenceChecker checker_;
bool is_valid_;
};

2
rtc_tools/network_tester/BUILD.gn
View File

@ -51,7 +51,7 @@ if (rtc_enable_protobuf) {
"../../rtc_base:protobuf_utils",
"../../rtc_base:rtc_base_approved",
"../../rtc_base:rtc_task_queue",
"../../rtc_base:sequenced_task_checker",
"../../rtc_base/synchronization:sequence_checker",
"../../rtc_base/third_party/sigslot",
"//third_party/abseil-cpp/absl/memory",
"//third_party/abseil-cpp/absl/types:optional",

12
rtc_tools/network_tester/packet_sender.cc
View File

@ -96,7 +96,7 @@ PacketSender::~PacketSender() = default;
void PacketSender::StartSending() {
worker_queue_checker_.Detach();
worker_queue_.PostTask([this]() {
RTC_DCHECK_CALLED_SEQUENTIALLY(&worker_queue_checker_);
RTC_DCHECK_RUN_ON(&worker_queue_checker_);
sending_ = true;
});
worker_queue_.PostTask(absl::make_unique<UpdateTestSettingTask>(
@ -105,18 +105,18 @@ void PacketSender::StartSending() {
}
void PacketSender::StopSending() {
RTC_DCHECK_CALLED_SEQUENTIALLY(&worker_queue_checker_);
RTC_DCHECK_RUN_ON(&worker_queue_checker_);
sending_ = false;
test_controller_->OnTestDone();
}
bool PacketSender::IsSending() const {
RTC_DCHECK_CALLED_SEQUENTIALLY(&worker_queue_checker_);
RTC_DCHECK_RUN_ON(&worker_queue_checker_);
return sending_;
}
void PacketSender::SendPacket() {
RTC_DCHECK_CALLED_SEQUENTIALLY(&worker_queue_checker_);
RTC_DCHECK_RUN_ON(&worker_queue_checker_);
NetworkTesterPacket packet;
packet.set_type(NetworkTesterPacket::TEST_DATA);
packet.set_sequence_number(sequence_number_++);
@ -125,13 +125,13 @@ void PacketSender::SendPacket() {
}
int64_t PacketSender::GetSendIntervalMs() const {
RTC_DCHECK_CALLED_SEQUENTIALLY(&worker_queue_checker_);
RTC_DCHECK_RUN_ON(&worker_queue_checker_);
return send_interval_ms_;
}
void PacketSender::UpdateTestSetting(size_t packet_size,
int64_t send_interval_ms) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&worker_queue_checker_);
RTC_DCHECK_RUN_ON(&worker_queue_checker_);
send_interval_ms_ = send_interval_ms;
packet_size_ = packet_size;
}

4
rtc_tools/network_tester/packet_sender.h
View File

@ -17,7 +17,7 @@
#include "api/task_queue/task_queue_factory.h"
#include "rtc_base/constructor_magic.h"
#include "rtc_base/ignore_wundef.h"
#include "rtc_base/sequenced_task_checker.h"
#include "rtc_base/synchronization/sequence_checker.h"
#include "rtc_base/task_queue.h"
#ifdef WEBRTC_NETWORK_TESTER_PROTO
@ -49,7 +49,7 @@ class PacketSender {
void UpdateTestSetting(size_t packet_size, int64_t send_interval_ms);
private:
rtc::SequencedTaskChecker worker_queue_checker_;
SequenceChecker worker_queue_checker_;
size_t packet_size_ RTC_GUARDED_BY(worker_queue_checker_);
int64_t send_interval_ms_ RTC_GUARDED_BY(worker_queue_checker_);
int64_t sequence_number_ RTC_GUARDED_BY(worker_queue_checker_);

2
rtc_tools/network_tester/test_controller.cc
View File

@ -67,7 +67,7 @@ void TestController::SendData(const NetworkTesterPacket& packet,
}
void TestController::OnTestDone() {
RTC_DCHECK_CALLED_SEQUENTIALLY(&packet_sender_checker_);
RTC_DCHECK_RUN_ON(&packet_sender_checker_);
NetworkTesterPacket packet;
packet.set_type(NetworkTesterPacket::TEST_DONE);
SendData(packet, absl::nullopt);

4
rtc_tools/network_tester/test_controller.h
View File

@ -23,8 +23,8 @@
#include "rtc_base/constructor_magic.h"
#include "rtc_base/critical_section.h"
#include "rtc_base/ignore_wundef.h"
#include "rtc_base/sequenced_task_checker.h"
#include "rtc_base/socket_address.h"
#include "rtc_base/synchronization/sequence_checker.h"
#include "rtc_base/third_party/sigslot/sigslot.h"
#include "rtc_base/thread_annotations.h"
#include "rtc_base/thread_checker.h"
@ -70,7 +70,7 @@ class TestController : public sigslot::has_slots<> {
const rtc::SocketAddress& remote_addr,
const int64_t& packet_time_us);
rtc::ThreadChecker test_controller_thread_checker_;
rtc::SequencedTaskChecker packet_sender_checker_;
SequenceChecker packet_sender_checker_;
rtc::BasicPacketSocketFactory socket_factory_;
const std::string config_file_path_;
PacketLogger packet_logger_;

2
sdk/android/BUILD.gn
View File

@ -632,8 +632,8 @@ if (is_android) {
"../../rtc_base",
"../../rtc_base:checks",
"../../rtc_base:rtc_task_queue",
"../../rtc_base:sequenced_task_checker",
"../../rtc_base:weak_ptr",
"../../rtc_base/synchronization:sequence_checker",
"../../system_wrappers:field_trial",
"//third_party/abseil-cpp/absl/memory",
"//third_party/libyuv",

26
sdk/android/src/jni/android_media_encoder.cc
View File

@ -32,7 +32,7 @@
#include "rtc_base/bind.h"
#include "rtc_base/checks.h"
#include "rtc_base/logging.h"
#include "rtc_base/sequenced_task_checker.h"
#include "rtc_base/synchronization/sequence_checker.h"
#include "rtc_base/thread.h"
#include "rtc_base/time_utils.h"
#include "rtc_base/weak_ptr.h"
@ -197,7 +197,7 @@ class MediaCodecVideoEncoder : public VideoEncoder {
// State that is constant for the lifetime of this object once the ctor
// returns.
rtc::SequencedTaskChecker encoder_queue_checker_;
SequenceChecker encoder_queue_checker_;
ScopedJavaGlobalRef<jobject> j_media_codec_video_encoder_;
// State that is valid only between InitEncode() and the next Release().
@ -307,7 +307,7 @@ MediaCodecVideoEncoder::MediaCodecVideoEncoder(JNIEnv* jni,
int32_t MediaCodecVideoEncoder::InitEncode(const VideoCodec* codec_settings,
int32_t /* number_of_cores */,
size_t /* max_payload_size */) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_checker_);
RTC_DCHECK_RUN_ON(&encoder_queue_checker_);
if (codec_settings == NULL) {
ALOGE << "NULL VideoCodec instance";
return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
@ -367,7 +367,7 @@ int32_t MediaCodecVideoEncoder::InitEncode(const VideoCodec* codec_settings,
}
bool MediaCodecVideoEncoder::ResetCodec() {
RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_checker_);
RTC_DCHECK_RUN_ON(&encoder_queue_checker_);
ALOGE << "Reset";
if (Release() != WEBRTC_VIDEO_CODEC_OK) {
ALOGE << "Releasing codec failed during reset.";
@ -391,7 +391,7 @@ bool MediaCodecVideoEncoder::EncodeTask::Run() {
return true;
}
RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_->encoder_queue_checker_);
RTC_DCHECK_RUN_ON(&encoder_->encoder_queue_checker_);
JNIEnv* jni = AttachCurrentThreadIfNeeded();
ScopedLocalRefFrame local_ref_frame(jni);
@ -468,7 +468,7 @@ int32_t MediaCodecVideoEncoder::InitEncodeInternal(int width,
int kbps,
int fps,
bool use_surface) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_checker_);
RTC_DCHECK_RUN_ON(&encoder_queue_checker_);
if (sw_fallback_required_) {
return WEBRTC_VIDEO_CODEC_OK;
}
@ -595,7 +595,7 @@ int32_t MediaCodecVideoEncoder::InitEncodeInternal(int width,
int32_t MediaCodecVideoEncoder::Encode(
const VideoFrame& frame,
const std::vector<VideoFrameType>* frame_types) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_checker_);
RTC_DCHECK_RUN_ON(&encoder_queue_checker_);
if (sw_fallback_required_)
return WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE;
JNIEnv* jni = AttachCurrentThreadIfNeeded();
@ -753,7 +753,7 @@ int32_t MediaCodecVideoEncoder::Encode(
bool MediaCodecVideoEncoder::MaybeReconfigureEncoder(JNIEnv* jni,
const VideoFrame& frame) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_checker_);
RTC_DCHECK_RUN_ON(&encoder_queue_checker_);
bool is_texture = IsTextureFrame(jni, frame);
const bool reconfigure_due_to_format = is_texture != use_surface_;
@ -798,7 +798,7 @@ bool MediaCodecVideoEncoder::EncodeByteBuffer(JNIEnv* jni,
bool key_frame,
const VideoFrame& frame,
int input_buffer_index) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_checker_);
RTC_DCHECK_RUN_ON(&encoder_queue_checker_);
RTC_CHECK(!use_surface_);
rtc::scoped_refptr<I420BufferInterface> i420_buffer =
@ -861,7 +861,7 @@ bool MediaCodecVideoEncoder::EncodeJavaFrame(JNIEnv* jni,
int32_t MediaCodecVideoEncoder::RegisterEncodeCompleteCallback(
EncodedImageCallback* callback) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_checker_);
RTC_DCHECK_RUN_ON(&encoder_queue_checker_);
JNIEnv* jni = AttachCurrentThreadIfNeeded();
ScopedLocalRefFrame local_ref_frame(jni);
callback_ = callback;
@ -869,7 +869,7 @@ int32_t MediaCodecVideoEncoder::RegisterEncodeCompleteCallback(
}
int32_t MediaCodecVideoEncoder::Release() {
RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_checker_);
RTC_DCHECK_RUN_ON(&encoder_queue_checker_);
if (!inited_) {
return WEBRTC_VIDEO_CODEC_OK;
}
@ -903,7 +903,7 @@ int32_t MediaCodecVideoEncoder::Release() {
int32_t MediaCodecVideoEncoder::SetRateAllocation(
const VideoBitrateAllocation& rate_allocation,
uint32_t frame_rate) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_checker_);
RTC_DCHECK_RUN_ON(&encoder_queue_checker_);
const uint32_t new_bit_rate = rate_allocation.get_sum_kbps();
if (sw_fallback_required_)
return WEBRTC_VIDEO_CODEC_OK;
@ -937,7 +937,7 @@ VideoEncoder::EncoderInfo MediaCodecVideoEncoder::GetEncoderInfo() const {
}
bool MediaCodecVideoEncoder::DeliverPendingOutputs(JNIEnv* jni) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_checker_);
RTC_DCHECK_RUN_ON(&encoder_queue_checker_);
while (true) {
ScopedJavaLocalRef<jobject> j_output_buffer_info =

4
test/BUILD.gn
View File

@ -592,7 +592,7 @@ rtc_source_set("direct_transport") {
"../call:simulated_packet_receiver",
"../modules/rtp_rtcp",
"../rtc_base:rtc_base_approved",
"../rtc_base:sequenced_task_checker",
"../rtc_base/synchronization:sequence_checker",
"../system_wrappers",
"//third_party/abseil-cpp/absl/memory",
]
@ -650,7 +650,7 @@ rtc_source_set("fake_video_codecs") {
"../rtc_base:checks",
"../rtc_base:rtc_base_approved",
"../rtc_base:rtc_task_queue",
"../rtc_base:sequenced_task_checker",
"../rtc_base/synchronization:sequence_checker",
"../system_wrappers",
"//third_party/abseil-cpp/absl/memory",
"//third_party/abseil-cpp/absl/types:optional",

2
test/direct_transport.h
View File

@ -16,7 +16,7 @@
#include "api/test/simulated_network.h"
#include "call/call.h"
#include "call/simulated_packet_receiver.h"
#include "rtc_base/sequenced_task_checker.h"
#include "rtc_base/synchronization/sequence_checker.h"
#include "rtc_base/thread_annotations.h"
#include "test/single_threaded_task_queue.h"

10
test/fake_encoder.cc
View File

@ -349,13 +349,13 @@ DelayedEncoder::DelayedEncoder(Clock* clock, int delay_ms)
}
void DelayedEncoder::SetDelay(int delay_ms) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_);
RTC_DCHECK_RUN_ON(&sequence_checker_);
delay_ms_ = delay_ms;
}
int32_t DelayedEncoder::Encode(const VideoFrame& input_image,
const std::vector<VideoFrameType>* frame_types) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_);
RTC_DCHECK_RUN_ON(&sequence_checker_);
SleepMs(delay_ms_);
@ -378,7 +378,7 @@ MultithreadedFakeH264Encoder::MultithreadedFakeH264Encoder(
int32_t MultithreadedFakeH264Encoder::InitEncode(const VideoCodec* config,
int32_t number_of_cores,
size_t max_payload_size) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_);
RTC_DCHECK_RUN_ON(&sequence_checker_);
queue1_ = task_queue_factory_->CreateTaskQueue(
"Queue 1", TaskQueueFactory::Priority::NORMAL);
@ -411,7 +411,7 @@ class MultithreadedFakeH264Encoder::EncodeTask : public QueuedTask {
int32_t MultithreadedFakeH264Encoder::Encode(
const VideoFrame& input_image,
const std::vector<VideoFrameType>* frame_types) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_);
RTC_DCHECK_RUN_ON(&sequence_checker_);
TaskQueueBase* queue =
(current_queue_++ % 2 == 0) ? queue1_.get() : queue2_.get();
@ -433,7 +433,7 @@ int32_t MultithreadedFakeH264Encoder::EncodeCallback(
}
int32_t MultithreadedFakeH264Encoder::Release() {
RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_);
RTC_DCHECK_RUN_ON(&sequence_checker_);
queue1_.reset();
queue2_.reset();

6
test/fake_encoder.h
View File

@ -25,7 +25,7 @@
#include "modules/include/module_common_types.h"
#include "modules/video_coding/include/video_codec_interface.h"
#include "rtc_base/critical_section.h"
#include "rtc_base/sequenced_task_checker.h"
#include "rtc_base/synchronization/sequence_checker.h"
#include "rtc_base/thread_annotations.h"
#include "system_wrappers/include/clock.h"
@ -127,7 +127,7 @@ class DelayedEncoder : public test::FakeEncoder {
private:
int delay_ms_ RTC_GUARDED_BY(sequence_checker_);
rtc::SequencedTaskChecker sequence_checker_;
SequenceChecker sequence_checker_;
};
// This class implements a multi-threaded fake encoder by posting
@ -161,7 +161,7 @@ class MultithreadedFakeH264Encoder : public test::FakeH264Encoder {
RTC_GUARDED_BY(sequence_checker_);
std::unique_ptr<TaskQueueBase, TaskQueueDeleter> queue2_
RTC_GUARDED_BY(sequence_checker_);
rtc::SequencedTaskChecker sequence_checker_;
SequenceChecker sequence_checker_;
};
} // namespace test

6
test/fake_vp8_encoder.cc
View File

@ -51,7 +51,7 @@ FakeVP8Encoder::FakeVP8Encoder(Clock* clock) : FakeEncoder(clock) {
int32_t FakeVP8Encoder::InitEncode(const VideoCodec* config,
int32_t number_of_cores,
size_t max_payload_size) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_);
RTC_DCHECK_RUN_ON(&sequence_checker_);
auto result =
FakeEncoder::InitEncode(config, number_of_cores, max_payload_size);
if (result != WEBRTC_VIDEO_CODEC_OK) {
@ -75,7 +75,7 @@ void FakeVP8Encoder::PopulateCodecSpecific(CodecSpecificInfo* codec_specific,
VideoFrameType frame_type,
int stream_idx,
uint32_t timestamp) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_);
RTC_DCHECK_RUN_ON(&sequence_checker_);
codec_specific->codecType = kVideoCodecVP8;
codec_specific->codecSpecific.VP8.keyIdx = kNoKeyIdx;
codec_specific->codecSpecific.VP8.nonReference = false;
@ -87,7 +87,7 @@ void FakeVP8Encoder::PopulateCodecSpecific(CodecSpecificInfo* codec_specific,
std::unique_ptr<RTPFragmentationHeader> FakeVP8Encoder::EncodeHook(
EncodedImage* encoded_image,
CodecSpecificInfo* codec_specific) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_);
RTC_DCHECK_RUN_ON(&sequence_checker_);
uint8_t stream_idx = encoded_image->SpatialIndex().value_or(0);
frame_buffer_controller_->UpdateLayerConfig(stream_idx,
encoded_image->Timestamp());

4
test/fake_vp8_encoder.h
View File

@ -23,7 +23,7 @@
#include "api/video_codecs/vp8_temporal_layers.h"
#include "modules/include/module_common_types.h"
#include "modules/video_coding/include/video_codec_interface.h"
#include "rtc_base/sequenced_task_checker.h"
#include "rtc_base/synchronization/sequence_checker.h"
#include "rtc_base/thread_annotations.h"
#include "system_wrappers/include/clock.h"
#include "test/fake_encoder.h"
@ -55,7 +55,7 @@ class FakeVP8Encoder : public FakeEncoder {
EncodedImage* encoded_image,
CodecSpecificInfo* codec_specific) override;
rtc::SequencedTaskChecker sequence_checker_;
SequenceChecker sequence_checker_;
std::unique_ptr<Vp8FrameBufferController> frame_buffer_controller_
RTC_GUARDED_BY(sequence_checker_);

2
test/scenario/BUILD.gn
View File

@ -128,8 +128,8 @@ if (rtc_include_tests) {
"../../rtc_base:rtc_base_tests_utils",
"../../rtc_base:rtc_task_queue",
"../../rtc_base:safe_minmax",
"../../rtc_base:sequenced_task_checker",
"../../rtc_base:task_queue_for_test",
"../../rtc_base/synchronization:sequence_checker",
"../../rtc_base/task_utils:repeating_task",
"../../system_wrappers",
"../../system_wrappers:field_trial",

2
test/time_controller/BUILD.gn
View File

@ -29,7 +29,7 @@ if (rtc_include_tests) {
"../../rtc_base",
"../../rtc_base:rtc_base_tests_utils",
"../../rtc_base:rtc_event",
"../../rtc_base:sequenced_task_checker",
"../../rtc_base/synchronization:sequence_checker",
"../../rtc_base/synchronization:yield_policy",
"../../rtc_base/task_utils:to_queued_task",
"../../system_wrappers",

4
video/BUILD.gn
View File

@ -94,13 +94,13 @@ rtc_static_library("video") {
"../rtc_base:rtc_base_approved",
"../rtc_base:rtc_numerics",
"../rtc_base:rtc_task_queue",
"../rtc_base:sequenced_task_checker",
"../rtc_base:stringutils",
"../rtc_base:weak_ptr",
"../rtc_base/experiments:alr_experiment",
"../rtc_base/experiments:keyframe_interval_settings_experiment",
"../rtc_base/experiments:quality_scaling_experiment",
"../rtc_base/experiments:rate_control_settings",
"../rtc_base/synchronization:sequence_checker",
"../rtc_base/system:fallthrough",
"../rtc_base/system:thread_registry",
"../rtc_base/task_utils:repeating_task",
@ -203,11 +203,11 @@ rtc_source_set("video_stream_encoder_impl") {
"../rtc_base:rtc_event",
"../rtc_base:rtc_numerics",
"../rtc_base:rtc_task_queue",
"../rtc_base:sequenced_task_checker",
"../rtc_base:timeutils",
"../rtc_base/experiments:alr_experiment",
"../rtc_base/experiments:quality_scaling_experiment",
"../rtc_base/experiments:rate_control_settings",
"../rtc_base/synchronization:sequence_checker",
"../rtc_base/system:fallthrough",
"../rtc_base/task_utils:repeating_task",
"../system_wrappers:field_trial",

26
video/overuse_frame_detector.cc
View File

@ -541,7 +541,7 @@ void OveruseFrameDetector::StartCheckForOveruse(
rtc::TaskQueue* task_queue,
const CpuOveruseOptions& options,
AdaptationObserverInterface* overuse_observer) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&task_checker_);
RTC_DCHECK_RUN_ON(&task_checker_);
RTC_DCHECK(!check_overuse_task_.Running());
RTC_DCHECK(overuse_observer != nullptr);
@ -554,12 +554,12 @@ void OveruseFrameDetector::StartCheckForOveruse(
});
}
void OveruseFrameDetector::StopCheckForOveruse() {
RTC_DCHECK_CALLED_SEQUENTIALLY(&task_checker_);
RTC_DCHECK_RUN_ON(&task_checker_);
check_overuse_task_.Stop();
}
void OveruseFrameDetector::EncodedFrameTimeMeasured(int encode_duration_ms) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&task_checker_);
RTC_DCHECK_RUN_ON(&task_checker_);
encode_usage_percent_ = usage_->Value();
metrics_observer_->OnEncodedFrameTimeMeasured(encode_duration_ms,
@ -567,7 +567,7 @@ void OveruseFrameDetector::EncodedFrameTimeMeasured(int encode_duration_ms) {
}
bool OveruseFrameDetector::FrameSizeChanged(int num_pixels) const {
RTC_DCHECK_CALLED_SEQUENTIALLY(&task_checker_);
RTC_DCHECK_RUN_ON(&task_checker_);
if (num_pixels != num_pixels_) {
return true;
}
@ -575,7 +575,7 @@ bool OveruseFrameDetector::FrameSizeChanged(int num_pixels) const {
}
bool OveruseFrameDetector::FrameTimeoutDetected(int64_t now_us) const {
RTC_DCHECK_CALLED_SEQUENTIALLY(&task_checker_);
RTC_DCHECK_RUN_ON(&task_checker_);
if (last_capture_time_us_ == -1)
return false;
return (now_us - last_capture_time_us_) >
@ -585,7 +585,7 @@ bool OveruseFrameDetector::FrameTimeoutDetected(int64_t now_us) const {
void OveruseFrameDetector::ResetAll(int num_pixels) {
// Reset state, as a result resolution being changed. Do not however change
// the current frame rate back to the default.
RTC_DCHECK_CALLED_SEQUENTIALLY(&task_checker_);
RTC_DCHECK_RUN_ON(&task_checker_);
num_pixels_ = num_pixels;
usage_->Reset();
last_capture_time_us_ = -1;
@ -595,7 +595,7 @@ void OveruseFrameDetector::ResetAll(int num_pixels) {
}
void OveruseFrameDetector::OnTargetFramerateUpdated(int framerate_fps) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&task_checker_);
RTC_DCHECK_RUN_ON(&task_checker_);
RTC_DCHECK_GE(framerate_fps, 0);
max_framerate_ = std::min(kMaxFramerate, framerate_fps);
usage_->SetMaxSampleDiffMs((1000 / std::max(kMinFramerate, max_framerate_)) *
@ -604,7 +604,7 @@ void OveruseFrameDetector::OnTargetFramerateUpdated(int framerate_fps) {
void OveruseFrameDetector::FrameCaptured(const VideoFrame& frame,
int64_t time_when_first_seen_us) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&task_checker_);
RTC_DCHECK_RUN_ON(&task_checker_);
if (FrameSizeChanged(frame.width() * frame.height()) ||
FrameTimeoutDetected(time_when_first_seen_us)) {
@ -619,7 +619,7 @@ void OveruseFrameDetector::FrameSent(uint32_t timestamp,
int64_t time_sent_in_us,
int64_t capture_time_us,
absl::optional<int> encode_duration_us) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&task_checker_);
RTC_DCHECK_RUN_ON(&task_checker_);
encode_duration_us = usage_->FrameSent(timestamp, time_sent_in_us,
capture_time_us, encode_duration_us);
@ -631,7 +631,7 @@ void OveruseFrameDetector::FrameSent(uint32_t timestamp,
void OveruseFrameDetector::CheckForOveruse(
AdaptationObserverInterface* observer) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&task_checker_);
RTC_DCHECK_RUN_ON(&task_checker_);
RTC_DCHECK(observer);
++num_process_times_;
if (num_process_times_ <= options_.min_process_count ||
@ -681,7 +681,7 @@ void OveruseFrameDetector::CheckForOveruse(
}
void OveruseFrameDetector::SetOptions(const CpuOveruseOptions& options) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&task_checker_);
RTC_DCHECK_RUN_ON(&task_checker_);
options_ = options;
// Force reset with next frame.
num_pixels_ = 0;
@ -689,7 +689,7 @@ void OveruseFrameDetector::SetOptions(const CpuOveruseOptions& options) {
}
bool OveruseFrameDetector::IsOverusing(int usage_percent) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&task_checker_);
RTC_DCHECK_RUN_ON(&task_checker_);
if (usage_percent >= options_.high_encode_usage_threshold_percent) {
++checks_above_threshold_;
@ -700,7 +700,7 @@ bool OveruseFrameDetector::IsOverusing(int usage_percent) {
}
bool OveruseFrameDetector::IsUnderusing(int usage_percent, int64_t time_now) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&task_checker_);
RTC_DCHECK_RUN_ON(&task_checker_);
int delay = in_quick_rampup_ ? kQuickRampUpDelayMs : current_rampup_delay_ms_;
if (time_now < last_rampup_time_ms_ + delay)
return false;

4
video/overuse_frame_detector.h
View File

@ -19,7 +19,7 @@
#include "modules/video_coding/utility/quality_scaler.h"
#include "rtc_base/constructor_magic.h"
#include "rtc_base/numerics/exp_filter.h"
#include "rtc_base/sequenced_task_checker.h"
#include "rtc_base/synchronization/sequence_checker.h"
#include "rtc_base/task_queue.h"
#include "rtc_base/task_utils/repeating_task.h"
#include "rtc_base/thread_annotations.h"
@ -122,7 +122,7 @@ class OveruseFrameDetector {
static std::unique_ptr<ProcessingUsage> CreateProcessingUsage(
const CpuOveruseOptions& options);
rtc::SequencedTaskChecker task_checker_;
SequenceChecker task_checker_;
// Owned by the task queue from where StartCheckForOveruse is called.
RepeatingTaskHandle check_overuse_task_ RTC_GUARDED_BY(task_checker_);

14
video/rtp_video_stream_receiver.cc
View File

@ -318,7 +318,7 @@ void RtpVideoStreamReceiver::OnRecoveredPacket(const uint8_t* rtp_packet,
// This method handles both regular RTP packets and packets recovered
// via FlexFEC.
void RtpVideoStreamReceiver::OnRtpPacket(const RtpPacketReceived& packet) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&worker_task_checker_);
RTC_DCHECK_RUN_ON(&worker_task_checker_);
if (!receiving_) {
return;
@ -480,14 +480,14 @@ absl::optional<int64_t> RtpVideoStreamReceiver::LastReceivedKeyframePacketMs()
}
void RtpVideoStreamReceiver::AddSecondarySink(RtpPacketSinkInterface* sink) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&worker_task_checker_);
RTC_DCHECK_RUN_ON(&worker_task_checker_);
RTC_DCHECK(!absl::c_linear_search(secondary_sinks_, sink));
secondary_sinks_.push_back(sink);
}
void RtpVideoStreamReceiver::RemoveSecondarySink(
const RtpPacketSinkInterface* sink) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&worker_task_checker_);
RTC_DCHECK_RUN_ON(&worker_task_checker_);
auto it = absl::c_find(secondary_sinks_, sink);
if (it == secondary_sinks_.end()) {
// We might be rolling-back a call whose setup failed mid-way. In such a
@ -610,7 +610,7 @@ void RtpVideoStreamReceiver::ReceivePacket(const RtpPacketReceived& packet) {
void RtpVideoStreamReceiver::ParseAndHandleEncapsulatingHeader(
const RtpPacketReceived& packet) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&worker_task_checker_);
RTC_DCHECK_RUN_ON(&worker_task_checker_);
if (packet.PayloadType() == config_.rtp.red_payload_type &&
packet.payload_size() > 0) {
if (packet.payload()[0] == config_.rtp.ulpfec_payload_type) {
@ -648,7 +648,7 @@ void RtpVideoStreamReceiver::NotifyReceiverOfEmptyPacket(uint16_t seq_num) {
bool RtpVideoStreamReceiver::DeliverRtcp(const uint8_t* rtcp_packet,
size_t rtcp_packet_length) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&worker_task_checker_);
RTC_DCHECK_RUN_ON(&worker_task_checker_);
if (!receiving_) {
return false;
@ -725,12 +725,12 @@ int RtpVideoStreamReceiver::GetUniqueFramesSeen() const {
}
void RtpVideoStreamReceiver::StartReceive() {
RTC_DCHECK_CALLED_SEQUENTIALLY(&worker_task_checker_);
RTC_DCHECK_RUN_ON(&worker_task_checker_);
receiving_ = true;
}
void RtpVideoStreamReceiver::StopReceive() {
RTC_DCHECK_CALLED_SEQUENTIALLY(&worker_task_checker_);
RTC_DCHECK_RUN_ON(&worker_task_checker_);
receiving_ = false;
}

4
video/rtp_video_stream_receiver.h
View File

@ -39,7 +39,7 @@
#include "rtc_base/constructor_magic.h"
#include "rtc_base/critical_section.h"
#include "rtc_base/numerics/sequence_number_util.h"
#include "rtc_base/sequenced_task_checker.h"
#include "rtc_base/synchronization/sequence_checker.h"
#include "rtc_base/thread_annotations.h"
#include "rtc_base/thread_checker.h"
#include "video/buffered_frame_decryptor.h"
@ -199,7 +199,7 @@ class RtpVideoStreamReceiver : public LossNotificationSender,
ReceiveStatistics* const rtp_receive_statistics_;
std::unique_ptr<UlpfecReceiver> ulpfec_receiver_;
rtc::SequencedTaskChecker worker_task_checker_;
SequenceChecker worker_task_checker_;
bool receiving_ RTC_GUARDED_BY(worker_task_checker_);
int64_t last_packet_log_ms_ RTC_GUARDED_BY(worker_task_checker_);

24
video/video_receive_stream.cc
View File

@ -285,7 +285,7 @@ VideoReceiveStream::VideoReceiveStream(
new VCMTiming(clock)) {}
VideoReceiveStream::~VideoReceiveStream() {
RTC_DCHECK_CALLED_SEQUENTIALLY(&worker_sequence_checker_);
RTC_DCHECK_RUN_ON(&worker_sequence_checker_);
RTC_LOG(LS_INFO) << "~VideoReceiveStream: " << config_.ToString();
Stop();
if (config_.media_transport) {
@ -296,7 +296,7 @@ VideoReceiveStream::~VideoReceiveStream() {
}
void VideoReceiveStream::SignalNetworkState(NetworkState state) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&worker_sequence_checker_);
RTC_DCHECK_RUN_ON(&worker_sequence_checker_);
rtp_video_stream_receiver_.SignalNetworkState(state);
}
@ -305,12 +305,12 @@ bool VideoReceiveStream::DeliverRtcp(const uint8_t* packet, size_t length) {
}
void VideoReceiveStream::SetSync(Syncable* audio_syncable) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&worker_sequence_checker_);
RTC_DCHECK_RUN_ON(&worker_sequence_checker_);
rtp_stream_sync_.ConfigureSync(audio_syncable);
}
void VideoReceiveStream::Start() {
RTC_DCHECK_CALLED_SEQUENTIALLY(&worker_sequence_checker_);
RTC_DCHECK_RUN_ON(&worker_sequence_checker_);
if (decode_thread_.IsRunning()) {
return;
@ -396,7 +396,7 @@ void VideoReceiveStream::Start() {
}
void VideoReceiveStream::Stop() {
RTC_DCHECK_CALLED_SEQUENTIALLY(&worker_sequence_checker_);
RTC_DCHECK_RUN_ON(&worker_sequence_checker_);
rtp_video_stream_receiver_.StopReceive();
stats_proxy_.OnUniqueFramesCounted(
@ -441,7 +441,7 @@ void VideoReceiveStream::RemoveSecondarySink(
}
bool VideoReceiveStream::SetBaseMinimumPlayoutDelayMs(int delay_ms) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&worker_sequence_checker_);
RTC_DCHECK_RUN_ON(&worker_sequence_checker_);
if (delay_ms < kMinBaseMinimumDelayMs || delay_ms > kMaxBaseMinimumDelayMs) {
return false;
}
@ -453,7 +453,7 @@ bool VideoReceiveStream::SetBaseMinimumPlayoutDelayMs(int delay_ms) {
}
int VideoReceiveStream::GetBaseMinimumPlayoutDelayMs() const {
RTC_DCHECK_CALLED_SEQUENTIALLY(&worker_sequence_checker_);
RTC_DCHECK_RUN_ON(&worker_sequence_checker_);
rtc::CritScope cs(&playout_delay_lock_);
return base_minimum_playout_delay_ms_;
@ -499,7 +499,7 @@ void VideoReceiveStream::RequestKeyFrame() {
void VideoReceiveStream::OnCompleteFrame(
std::unique_ptr<video_coding::EncodedFrame> frame) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&network_sequence_checker_);
RTC_DCHECK_RUN_ON(&network_sequence_checker_);
// TODO(https://bugs.webrtc.org/9974): Consider removing this workaround.
int64_t time_now_ms = rtc::TimeMillis();
if (last_complete_frame_time_ms_ > 0 &&
@ -533,7 +533,7 @@ void VideoReceiveStream::OnData(uint64_t channel_id,
}
void VideoReceiveStream::OnRttUpdate(int64_t avg_rtt_ms, int64_t max_rtt_ms) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&module_process_sequence_checker_);
RTC_DCHECK_RUN_ON(&module_process_sequence_checker_);
frame_buffer_->UpdateRtt(max_rtt_ms);
rtp_video_stream_receiver_.UpdateRtt(max_rtt_ms);
}
@ -543,12 +543,12 @@ void VideoReceiveStream::OnRttUpdated(int64_t rtt_ms) {
}
int VideoReceiveStream::id() const {
RTC_DCHECK_CALLED_SEQUENTIALLY(&worker_sequence_checker_);
RTC_DCHECK_RUN_ON(&worker_sequence_checker_);
return config_.rtp.remote_ssrc;
}
absl::optional<Syncable::Info> VideoReceiveStream::GetInfo() const {
RTC_DCHECK_CALLED_SEQUENTIALLY(&module_process_sequence_checker_);
RTC_DCHECK_RUN_ON(&module_process_sequence_checker_);
absl::optional<Syncable::Info> info =
rtp_video_stream_receiver_.GetSyncInfo();
@ -565,7 +565,7 @@ uint32_t VideoReceiveStream::GetPlayoutTimestamp() const {
}
void VideoReceiveStream::SetMinimumPlayoutDelay(int delay_ms) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&module_process_sequence_checker_);
RTC_DCHECK_RUN_ON(&module_process_sequence_checker_);
rtc::CritScope cs(&playout_delay_lock_);
syncable_minimum_playout_delay_ms_ = delay_ms;
UpdatePlayoutDelays();

8
video/video_receive_stream.h
View File

@ -22,7 +22,7 @@
#include "modules/rtp_rtcp/include/flexfec_receiver.h"
#include "modules/video_coding/frame_buffer2.h"
#include "modules/video_coding/video_coding_impl.h"
#include "rtc_base/sequenced_task_checker.h"
#include "rtc_base/synchronization/sequence_checker.h"
#include "system_wrappers/include/clock.h"
#include "video/receive_statistics_proxy.h"
#include "video/rtp_streams_synchronizer.h"
@ -141,9 +141,9 @@ class VideoReceiveStream : public webrtc::VideoReceiveStream,
void UpdatePlayoutDelays() const
RTC_EXCLUSIVE_LOCKS_REQUIRED(playout_delay_lock_);
rtc::SequencedTaskChecker worker_sequence_checker_;
rtc::SequencedTaskChecker module_process_sequence_checker_;
rtc::SequencedTaskChecker network_sequence_checker_;
SequenceChecker worker_sequence_checker_;
SequenceChecker module_process_sequence_checker_;
SequenceChecker network_sequence_checker_;
TaskQueueFactory* const task_queue_factory_;

2
video/video_send_stream_impl.cc
View File

@ -29,7 +29,7 @@
#include "rtc_base/experiments/rate_control_settings.h"
#include "rtc_base/logging.h"
#include "rtc_base/numerics/safe_conversions.h"
#include "rtc_base/sequenced_task_checker.h"
#include "rtc_base/synchronization/sequence_checker.h"
#include "rtc_base/thread_checker.h"
#include "rtc_base/trace_event.h"
#include "system_wrappers/include/clock.h"

4
video/video_stream_encoder.cc
View File

@ -228,7 +228,7 @@ class VideoStreamEncoder::VideoSourceProxy {
void SetSource(rtc::VideoSourceInterface<VideoFrame>* source,
const DegradationPreference& degradation_preference) {
// Called on libjingle's worker thread.
RTC_DCHECK_CALLED_SEQUENTIALLY(&main_checker_);
RTC_DCHECK_RUN_ON(&main_checker_);
rtc::VideoSourceInterface<VideoFrame>* old_source = nullptr;
rtc::VideoSinkWants wants;
{
@ -434,7 +434,7 @@ class VideoStreamEncoder::VideoSourceProxy {
}
rtc::CriticalSection crit_;
rtc::SequencedTaskChecker main_checker_;
SequenceChecker main_checker_;
VideoStreamEncoder* const video_stream_encoder_;
rtc::VideoSinkWants sink_wants_ RTC_GUARDED_BY(&crit_);
DegradationPreference degradation_preference_ RTC_GUARDED_BY(&crit_);

2
video/video_stream_encoder.h
View File

@ -32,7 +32,7 @@
#include "rtc_base/experiments/rate_control_settings.h"
#include "rtc_base/race_checker.h"
#include "rtc_base/rate_statistics.h"
#include "rtc_base/sequenced_task_checker.h"
#include "rtc_base/synchronization/sequence_checker.h"
#include "rtc_base/task_queue.h"
#include "video/encoder_bitrate_adjuster.h"
#include "video/frame_encode_timer.h"