Migrate call/ to webrtc::Mutex.
Bug: webrtc:11567
Change-Id: Iab7142c77bc0c1a026cf5121b756094e05bccefe
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/176742
Commit-Queue: Markus Handell <handellm@webrtc.org>
Reviewed-by: Sebastian Jansson <srte@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#31636}
diff --git a/call/BUILD.gn b/call/BUILD.gn
index 5f7c603..eb71a33 100644
--- a/call/BUILD.gn
+++ b/call/BUILD.gn
@@ -183,6 +183,7 @@
"../rtc_base:rate_limiter",
"../rtc_base:rtc_base_approved",
"../rtc_base:rtc_task_queue",
+ "../rtc_base/synchronization:mutex",
"../rtc_base/task_utils:repeating_task",
]
absl_deps = [
@@ -341,6 +342,7 @@
"../api/units:timestamp",
"../rtc_base:checks",
"../rtc_base:rtc_base_approved",
+ "../rtc_base/synchronization:mutex",
"../rtc_base/synchronization:sequence_checker",
]
absl_deps = [ "//third_party/abseil-cpp/absl/types:optional" ]
@@ -369,6 +371,7 @@
"../modules/utility",
"../rtc_base:checks",
"../rtc_base:rtc_base_approved",
+ "../rtc_base/synchronization:mutex",
"../rtc_base/synchronization:sequence_checker",
"../system_wrappers",
]
@@ -434,6 +437,7 @@
"../rtc_base:rate_limiter",
"../rtc_base:rtc_base_approved",
"../rtc_base:task_queue_for_test",
+ "../rtc_base/synchronization:mutex",
"../system_wrappers",
"../test:audio_codec_mocks",
"../test:direct_transport",
@@ -493,6 +497,7 @@
"../rtc_base:rtc_base_approved",
"../rtc_base:task_queue_for_test",
"../rtc_base:task_queue_for_test",
+ "../rtc_base/synchronization:mutex",
"../rtc_base/task_utils:repeating_task",
"../system_wrappers",
"../system_wrappers:metrics",
diff --git a/call/adaptation/BUILD.gn b/call/adaptation/BUILD.gn
index 084b7bd..6aa82e5 100644
--- a/call/adaptation/BUILD.gn
+++ b/call/adaptation/BUILD.gn
@@ -49,6 +49,7 @@
"../../rtc_base:rtc_base_approved",
"../../rtc_base:rtc_task_queue",
"../../rtc_base/experiments:balanced_degradation_settings",
+ "../../rtc_base/synchronization:mutex",
"../../rtc_base/synchronization:sequence_checker",
"../../rtc_base/task_utils:to_queued_task",
]
@@ -85,6 +86,7 @@
"../../rtc_base:rtc_base_approved",
"../../rtc_base:rtc_task_queue",
"../../rtc_base:task_queue_for_test",
+ "../../rtc_base/synchronization:mutex",
"../../test:field_trial",
"../../test:rtc_expect_death",
"../../test:test_support",
diff --git a/call/adaptation/broadcast_resource_listener.cc b/call/adaptation/broadcast_resource_listener.cc
index 2a4d8ca..59bd1e0 100644
--- a/call/adaptation/broadcast_resource_listener.cc
+++ b/call/adaptation/broadcast_resource_listener.cc
@@ -15,8 +15,8 @@
#include <utility>
#include "rtc_base/checks.h"
-#include "rtc_base/critical_section.h"
#include "rtc_base/ref_counted_object.h"
+#include "rtc_base/synchronization/mutex.h"
namespace webrtc {
@@ -29,7 +29,7 @@
// The parent is letting us know we have a usage neasurement.
void OnResourceUsageStateMeasured(ResourceUsageState usage_state) {
- rtc::CritScope crit(&lock_);
+ MutexLock lock(&lock_);
if (!listener_)
return;
listener_->OnResourceUsageStateMeasured(this, usage_state);
@@ -38,14 +38,14 @@
// Resource implementation.
std::string Name() const override { return name_; }
void SetResourceListener(ResourceListener* listener) override {
- rtc::CritScope crit(&lock_);
+ MutexLock lock(&lock_);
RTC_DCHECK(!listener_ || !listener);
listener_ = listener;
}
private:
const std::string name_;
- rtc::CriticalSection lock_;
+ Mutex lock_;
ResourceListener* listener_ RTC_GUARDED_BY(lock_) = nullptr;
};
@@ -64,14 +64,14 @@
}
void BroadcastResourceListener::StartListening() {
- rtc::CritScope crit(&lock_);
+ MutexLock lock(&lock_);
RTC_DCHECK(!is_listening_);
source_resource_->SetResourceListener(this);
is_listening_ = true;
}
void BroadcastResourceListener::StopListening() {
- rtc::CritScope crit(&lock_);
+ MutexLock lock(&lock_);
RTC_DCHECK(is_listening_);
RTC_DCHECK(adapters_.empty());
source_resource_->SetResourceListener(nullptr);
@@ -80,7 +80,7 @@
rtc::scoped_refptr<Resource>
BroadcastResourceListener::CreateAdapterResource() {
- rtc::CritScope crit(&lock_);
+ MutexLock lock(&lock_);
RTC_DCHECK(is_listening_);
rtc::scoped_refptr<AdapterResource> adapter =
new rtc::RefCountedObject<AdapterResource>(source_resource_->Name() +
@@ -91,7 +91,7 @@
void BroadcastResourceListener::RemoveAdapterResource(
rtc::scoped_refptr<Resource> resource) {
- rtc::CritScope crit(&lock_);
+ MutexLock lock(&lock_);
auto it = std::find(adapters_.begin(), adapters_.end(), resource);
RTC_DCHECK(it != adapters_.end());
adapters_.erase(it);
@@ -100,7 +100,7 @@
std::vector<rtc::scoped_refptr<Resource>>
BroadcastResourceListener::GetAdapterResources() {
std::vector<rtc::scoped_refptr<Resource>> resources;
- rtc::CritScope crit(&lock_);
+ MutexLock lock(&lock_);
for (const auto& adapter : adapters_) {
resources.push_back(adapter);
}
@@ -111,7 +111,7 @@
rtc::scoped_refptr<Resource> resource,
ResourceUsageState usage_state) {
RTC_DCHECK_EQ(resource, source_resource_);
- rtc::CritScope crit(&lock_);
+ MutexLock lock(&lock_);
for (const auto& adapter : adapters_) {
adapter->OnResourceUsageStateMeasured(usage_state);
}
diff --git a/call/adaptation/broadcast_resource_listener.h b/call/adaptation/broadcast_resource_listener.h
index f0d035d..2c5a5c7 100644
--- a/call/adaptation/broadcast_resource_listener.h
+++ b/call/adaptation/broadcast_resource_listener.h
@@ -15,7 +15,7 @@
#include "api/adaptation/resource.h"
#include "api/scoped_refptr.h"
-#include "rtc_base/critical_section.h"
+#include "rtc_base/synchronization/mutex.h"
namespace webrtc {
@@ -62,7 +62,7 @@
friend class AdapterResource;
const rtc::scoped_refptr<Resource> source_resource_;
- rtc::CriticalSection lock_;
+ Mutex lock_;
bool is_listening_ RTC_GUARDED_BY(lock_);
// The AdapterResource unregisters itself prior to destruction, guaranteeing
// that these pointers are safe to use.
diff --git a/call/adaptation/resource_adaptation_processor_unittest.cc b/call/adaptation/resource_adaptation_processor_unittest.cc
index 4e0f885..e7298d6 100644
--- a/call/adaptation/resource_adaptation_processor_unittest.cc
+++ b/call/adaptation/resource_adaptation_processor_unittest.cc
@@ -20,9 +20,9 @@
#include "call/adaptation/test/fake_resource.h"
#include "call/adaptation/video_source_restrictions.h"
#include "call/adaptation/video_stream_input_state_provider.h"
-#include "rtc_base/critical_section.h"
#include "rtc_base/event.h"
#include "rtc_base/gunit.h"
+#include "rtc_base/synchronization/mutex.h"
#include "rtc_base/task_queue_for_test.h"
#include "test/gtest.h"
diff --git a/call/adaptation/video_stream_input_state_provider.cc b/call/adaptation/video_stream_input_state_provider.cc
index 4ecf858..3c0a7e3 100644
--- a/call/adaptation/video_stream_input_state_provider.cc
+++ b/call/adaptation/video_stream_input_state_provider.cc
@@ -19,19 +19,19 @@
VideoStreamInputStateProvider::~VideoStreamInputStateProvider() {}
void VideoStreamInputStateProvider::OnHasInputChanged(bool has_input) {
- rtc::CritScope lock(&crit_);
+ MutexLock lock(&mutex_);
input_state_.set_has_input(has_input);
}
void VideoStreamInputStateProvider::OnFrameSizeObserved(int frame_size_pixels) {
RTC_DCHECK_GT(frame_size_pixels, 0);
- rtc::CritScope lock(&crit_);
+ MutexLock lock(&mutex_);
input_state_.set_frame_size_pixels(frame_size_pixels);
}
void VideoStreamInputStateProvider::OnEncoderSettingsChanged(
EncoderSettings encoder_settings) {
- rtc::CritScope lock(&crit_);
+ MutexLock lock(&mutex_);
input_state_.set_video_codec_type(
encoder_settings.encoder_config().codec_type);
input_state_.set_min_pixels_per_frame(
@@ -41,7 +41,7 @@
VideoStreamInputState VideoStreamInputStateProvider::InputState() {
// GetInputFrameRate() is thread-safe.
int input_fps = frame_rate_provider_->GetInputFrameRate();
- rtc::CritScope lock(&crit_);
+ MutexLock lock(&mutex_);
input_state_.set_frames_per_second(input_fps);
return input_state_;
}
diff --git a/call/adaptation/video_stream_input_state_provider.h b/call/adaptation/video_stream_input_state_provider.h
index a20ac17..f4a3e0b 100644
--- a/call/adaptation/video_stream_input_state_provider.h
+++ b/call/adaptation/video_stream_input_state_provider.h
@@ -14,7 +14,7 @@
#include "api/video/video_stream_encoder_observer.h"
#include "call/adaptation/encoder_settings.h"
#include "call/adaptation/video_stream_input_state.h"
-#include "rtc_base/critical_section.h"
+#include "rtc_base/synchronization/mutex.h"
namespace webrtc {
@@ -31,9 +31,9 @@
virtual VideoStreamInputState InputState();
private:
- mutable rtc::CriticalSection crit_;
+ Mutex mutex_;
VideoStreamEncoderObserver* const frame_rate_provider_;
- VideoStreamInputState input_state_ RTC_GUARDED_BY(crit_);
+ VideoStreamInputState input_state_ RTC_GUARDED_BY(mutex_);
};
} // namespace webrtc
diff --git a/call/bitrate_estimator_tests.cc b/call/bitrate_estimator_tests.cc
index 50da12b..cd052dc 100644
--- a/call/bitrate_estimator_tests.cc
+++ b/call/bitrate_estimator_tests.cc
@@ -19,6 +19,7 @@
#include "rtc_base/checks.h"
#include "rtc_base/event.h"
#include "rtc_base/logging.h"
+#include "rtc_base/synchronization/mutex.h"
#include "rtc_base/task_queue_for_test.h"
#include "rtc_base/thread_annotations.h"
#include "test/call_test.h"
@@ -49,7 +50,7 @@
class Callback : public rtc::LogSink {
public:
void OnLogMessage(const std::string& message) override {
- rtc::CritScope lock(&crit_sect_);
+ MutexLock lock(&mutex_);
// Ignore log lines that are due to missing AST extensions, these are
// logged when we switch back from AST to TOF until the wrapping bitrate
// estimator gives up on using AST.
@@ -78,15 +79,15 @@
bool Wait() { return done_.Wait(test::CallTest::kDefaultTimeoutMs); }
void PushExpectedLogLine(const std::string& expected_log_line) {
- rtc::CritScope lock(&crit_sect_);
+ MutexLock lock(&mutex_);
expected_log_lines_.push_back(expected_log_line);
}
private:
typedef std::list<std::string> Strings;
- rtc::CriticalSection crit_sect_;
- Strings received_log_lines_ RTC_GUARDED_BY(crit_sect_);
- Strings expected_log_lines_ RTC_GUARDED_BY(crit_sect_);
+ Mutex mutex_;
+ Strings received_log_lines_ RTC_GUARDED_BY(mutex_);
+ Strings expected_log_lines_ RTC_GUARDED_BY(mutex_);
rtc::Event done_;
};
diff --git a/call/call_perf_tests.cc b/call/call_perf_tests.cc
index 123be7d..9214ae5 100644
--- a/call/call_perf_tests.cc
+++ b/call/call_perf_tests.cc
@@ -29,6 +29,7 @@
#include "modules/audio_mixer/audio_mixer_impl.h"
#include "modules/rtp_rtcp/source/rtp_packet.h"
#include "rtc_base/checks.h"
+#include "rtc_base/synchronization/mutex.h"
#include "rtc_base/task_queue_for_test.h"
#include "rtc_base/thread.h"
#include "rtc_base/thread_annotations.h"
@@ -409,7 +410,7 @@
}
void OnFrame(const VideoFrame& video_frame) override {
- rtc::CritScope lock(&crit_);
+ MutexLock lock(&mutex_);
if (video_frame.ntp_time_ms() <= 0) {
// Haven't got enough RTCP SR in order to calculate the capture ntp
// time.
@@ -445,7 +446,7 @@
}
Action OnSendRtp(const uint8_t* packet, size_t length) override {
- rtc::CritScope lock(&crit_);
+ MutexLock lock(&mutex_);
RtpPacket rtp_packet;
EXPECT_TRUE(rtp_packet.Parse(packet, length));
@@ -488,7 +489,7 @@
time_offset_ms_list_, "ms", true);
}
- rtc::CriticalSection crit_;
+ Mutex mutex_;
const BuiltInNetworkBehaviorConfig net_config_;
Clock* const clock_;
int threshold_ms_;
@@ -499,7 +500,7 @@
bool rtp_start_timestamp_set_;
uint32_t rtp_start_timestamp_;
typedef std::map<uint32_t, uint32_t> FrameCaptureTimeList;
- FrameCaptureTimeList capture_time_list_ RTC_GUARDED_BY(&crit_);
+ FrameCaptureTimeList capture_time_list_ RTC_GUARDED_BY(&mutex_);
std::vector<double> time_offset_ms_list_;
} test(net_config, threshold_ms, start_time_ms, run_time_ms);
diff --git a/call/fake_network_pipe.cc b/call/fake_network_pipe.cc
index 8844700..324a7bd 100644
--- a/call/fake_network_pipe.cc
+++ b/call/fake_network_pipe.cc
@@ -122,17 +122,17 @@
}
void FakeNetworkPipe::SetReceiver(PacketReceiver* receiver) {
- rtc::CritScope crit(&config_lock_);
+ MutexLock lock(&config_lock_);
receiver_ = receiver;
}
void FakeNetworkPipe::AddActiveTransport(Transport* transport) {
- rtc::CritScope crit(&config_lock_);
+ MutexLock lock(&config_lock_);
active_transports_[transport]++;
}
void FakeNetworkPipe::RemoveActiveTransport(Transport* transport) {
- rtc::CritScope crit(&config_lock_);
+ MutexLock lock(&config_lock_);
auto it = active_transports_.find(transport);
RTC_CHECK(it != active_transports_.end());
if (--(it->second) == 0) {
@@ -186,7 +186,7 @@
}
void FakeNetworkPipe::SetClockOffset(int64_t offset_ms) {
- rtc::CritScope crit(&config_lock_);
+ MutexLock lock(&config_lock_);
clock_offset_ms_ = offset_ms;
}
@@ -198,7 +198,7 @@
bool is_rtcp,
MediaType media_type,
absl::optional<int64_t> packet_time_us) {
- rtc::CritScope crit(&process_lock_);
+ MutexLock lock(&process_lock_);
int64_t time_now_us = clock_->TimeInMicroseconds();
return EnqueuePacket(NetworkPacket(std::move(packet), time_now_us,
time_now_us, options, is_rtcp, media_type,
@@ -209,7 +209,7 @@
absl::optional<PacketOptions> options,
bool is_rtcp,
Transport* transport) {
- rtc::CritScope crit(&process_lock_);
+ MutexLock lock(&process_lock_);
int64_t time_now_us = clock_->TimeInMicroseconds();
return EnqueuePacket(NetworkPacket(std::move(packet), time_now_us,
time_now_us, options, is_rtcp,
@@ -233,7 +233,7 @@
}
float FakeNetworkPipe::PercentageLoss() {
- rtc::CritScope crit(&process_lock_);
+ MutexLock lock(&process_lock_);
if (sent_packets_ == 0)
return 0;
@@ -242,7 +242,7 @@
}
int FakeNetworkPipe::AverageDelay() {
- rtc::CritScope crit(&process_lock_);
+ MutexLock lock(&process_lock_);
if (sent_packets_ == 0)
return 0;
@@ -251,12 +251,12 @@
}
size_t FakeNetworkPipe::DroppedPackets() {
- rtc::CritScope crit(&process_lock_);
+ MutexLock lock(&process_lock_);
return dropped_packets_;
}
size_t FakeNetworkPipe::SentPackets() {
- rtc::CritScope crit(&process_lock_);
+ MutexLock lock(&process_lock_);
return sent_packets_;
}
@@ -264,7 +264,7 @@
int64_t time_now_us;
std::queue<NetworkPacket> packets_to_deliver;
{
- rtc::CritScope crit(&process_lock_);
+ MutexLock lock(&process_lock_);
time_now_us = clock_->TimeInMicroseconds();
if (time_now_us - last_log_time_us_ > kLogIntervalMs * 1000) {
int64_t queueing_delay_us = 0;
@@ -318,7 +318,7 @@
}
}
- rtc::CritScope crit(&config_lock_);
+ MutexLock lock(&config_lock_);
while (!packets_to_deliver.empty()) {
NetworkPacket packet = std::move(packets_to_deliver.front());
packets_to_deliver.pop();
@@ -354,7 +354,7 @@
}
absl::optional<int64_t> FakeNetworkPipe::TimeUntilNextProcess() {
- rtc::CritScope crit(&process_lock_);
+ MutexLock lock(&process_lock_);
absl::optional<int64_t> delivery_us = network_behavior_->NextDeliveryTimeUs();
if (delivery_us) {
int64_t delay_us = *delivery_us - clock_->TimeInMicroseconds();
@@ -364,17 +364,17 @@
}
bool FakeNetworkPipe::HasReceiver() const {
- rtc::CritScope crit(&config_lock_);
+ MutexLock lock(&config_lock_);
return receiver_ != nullptr;
}
void FakeNetworkPipe::DeliverPacketWithLock(NetworkPacket* packet) {
- rtc::CritScope crit(&config_lock_);
+ MutexLock lock(&config_lock_);
DeliverNetworkPacket(packet);
}
void FakeNetworkPipe::ResetStats() {
- rtc::CritScope crit(&process_lock_);
+ MutexLock lock(&process_lock_);
dropped_packets_ = 0;
sent_packets_ = 0;
total_packet_delay_us_ = 0;
diff --git a/call/fake_network_pipe.h b/call/fake_network_pipe.h
index 24340a2..1e5bb51 100644
--- a/call/fake_network_pipe.h
+++ b/call/fake_network_pipe.h
@@ -24,7 +24,7 @@
#include "call/call.h"
#include "call/simulated_packet_receiver.h"
#include "rtc_base/constructor_magic.h"
-#include "rtc_base/critical_section.h"
+#include "rtc_base/synchronization/mutex.h"
#include "rtc_base/thread_annotations.h"
namespace webrtc {
@@ -204,14 +204,14 @@
Clock* const clock_;
// |config_lock| guards the mostly constant things like the callbacks.
- rtc::CriticalSection config_lock_;
+ mutable Mutex config_lock_;
const std::unique_ptr<NetworkBehaviorInterface> network_behavior_;
PacketReceiver* receiver_ RTC_GUARDED_BY(config_lock_);
Transport* const global_transport_;
// |process_lock| guards the data structures involved in delay and loss
// processes, such as the packet queues.
- rtc::CriticalSection process_lock_;
+ Mutex process_lock_;
// Packets are added at the back of the deque, this makes the deque ordered
// by increasing send time. The common case when removing packets from the
// deque is removing early packets, which will be close to the front of the
diff --git a/call/rtp_video_sender.cc b/call/rtp_video_sender.cc
index 854a18a..3217b3c 100644
--- a/call/rtp_video_sender.cc
+++ b/call/rtp_video_sender.cc
@@ -467,7 +467,7 @@
}
void RtpVideoSender::SetActive(bool active) {
- rtc::CritScope lock(&crit_);
+ MutexLock lock(&mutex_);
if (active_ == active)
return;
const std::vector<bool> active_modules(rtp_streams_.size(), active);
@@ -475,7 +475,7 @@
}
void RtpVideoSender::SetActiveModules(const std::vector<bool> active_modules) {
- rtc::CritScope lock(&crit_);
+ MutexLock lock(&mutex_);
return SetActiveModulesLocked(active_modules);
}
@@ -495,7 +495,7 @@
}
bool RtpVideoSender::IsActive() {
- rtc::CritScope lock(&crit_);
+ MutexLock lock(&mutex_);
return IsActiveLocked();
}
@@ -509,7 +509,7 @@
const RTPFragmentationHeader* fragmentation) {
fec_controller_->UpdateWithEncodedData(encoded_image.size(),
encoded_image._frameType);
- rtc::CritScope lock(&crit_);
+ MutexLock lock(&mutex_);
RTC_DCHECK(!rtp_streams_.empty());
if (!active_)
return Result(Result::ERROR_SEND_FAILED);
@@ -583,7 +583,7 @@
void RtpVideoSender::OnBitrateAllocationUpdated(
const VideoBitrateAllocation& bitrate) {
- rtc::CritScope lock(&crit_);
+ MutexLock lock(&mutex_);
if (IsActiveLocked()) {
if (rtp_streams_.size() == 1) {
// If spatial scalability is enabled, it is covered by a single stream.
@@ -726,7 +726,7 @@
std::map<uint32_t, RtpPayloadState> RtpVideoSender::GetRtpPayloadStates()
const {
- rtc::CritScope lock(&crit_);
+ MutexLock lock(&mutex_);
std::map<uint32_t, RtpPayloadState> payload_states;
for (const auto& param : params_) {
payload_states[param.ssrc()] = param.state();
@@ -737,7 +737,7 @@
void RtpVideoSender::OnTransportOverheadChanged(
size_t transport_overhead_bytes_per_packet) {
- rtc::CritScope lock(&crit_);
+ MutexLock lock(&mutex_);
transport_overhead_bytes_per_packet_ = transport_overhead_bytes_per_packet;
size_t max_rtp_packet_size =
@@ -751,7 +751,7 @@
void RtpVideoSender::OnBitrateUpdated(BitrateAllocationUpdate update,
int framerate) {
// Substract overhead from bitrate.
- rtc::CritScope lock(&crit_);
+ MutexLock lock(&mutex_);
size_t num_active_streams = 0;
size_t overhead_bytes_per_packet = 0;
for (const auto& stream : rtp_streams_) {
@@ -880,14 +880,14 @@
}
void RtpVideoSender::SetFecAllowed(bool fec_allowed) {
- rtc::CritScope cs(&crit_);
+ MutexLock lock(&mutex_);
fec_allowed_ = fec_allowed;
}
void RtpVideoSender::OnPacketFeedbackVector(
std::vector<StreamPacketInfo> packet_feedback_vector) {
if (fec_controller_->UseLossVectorMask()) {
- rtc::CritScope cs(&crit_);
+ MutexLock lock(&mutex_);
for (const StreamPacketInfo& packet : packet_feedback_vector) {
loss_mask_vector_.push_back(!packet.received);
}
diff --git a/call/rtp_video_sender.h b/call/rtp_video_sender.h
index e364729..876f6e9 100644
--- a/call/rtp_video_sender.h
+++ b/call/rtp_video_sender.h
@@ -36,8 +36,8 @@
#include "modules/rtp_rtcp/source/rtp_video_header.h"
#include "modules/utility/include/process_thread.h"
#include "rtc_base/constructor_magic.h"
-#include "rtc_base/critical_section.h"
#include "rtc_base/rate_limiter.h"
+#include "rtc_base/synchronization/mutex.h"
#include "rtc_base/thread_annotations.h"
#include "rtc_base/thread_checker.h"
@@ -97,27 +97,27 @@
// TODO(perkj): Replace the use of |module_process_thread| with a TaskQueue,
// maybe |worker_queue|.
void RegisterProcessThread(ProcessThread* module_process_thread)
- RTC_LOCKS_EXCLUDED(crit_) override;
- void DeRegisterProcessThread() RTC_LOCKS_EXCLUDED(crit_) override;
+ RTC_LOCKS_EXCLUDED(mutex_) override;
+ void DeRegisterProcessThread() RTC_LOCKS_EXCLUDED(mutex_) override;
// RtpVideoSender will only route packets if being active, all packets will be
// dropped otherwise.
- void SetActive(bool active) RTC_LOCKS_EXCLUDED(crit_) override;
+ void SetActive(bool active) RTC_LOCKS_EXCLUDED(mutex_) override;
// Sets the sending status of the rtp modules and appropriately sets the
// payload router to active if any rtp modules are active.
void SetActiveModules(const std::vector<bool> active_modules)
- RTC_LOCKS_EXCLUDED(crit_) override;
- bool IsActive() RTC_LOCKS_EXCLUDED(crit_) override;
+ RTC_LOCKS_EXCLUDED(mutex_) override;
+ bool IsActive() RTC_LOCKS_EXCLUDED(mutex_) override;
void OnNetworkAvailability(bool network_available)
- RTC_LOCKS_EXCLUDED(crit_) override;
+ RTC_LOCKS_EXCLUDED(mutex_) override;
std::map<uint32_t, RtpState> GetRtpStates() const
- RTC_LOCKS_EXCLUDED(crit_) override;
+ RTC_LOCKS_EXCLUDED(mutex_) override;
std::map<uint32_t, RtpPayloadState> GetRtpPayloadStates() const
- RTC_LOCKS_EXCLUDED(crit_) override;
+ RTC_LOCKS_EXCLUDED(mutex_) override;
void DeliverRtcp(const uint8_t* packet, size_t length)
- RTC_LOCKS_EXCLUDED(crit_) override;
+ RTC_LOCKS_EXCLUDED(mutex_) override;
// Implements webrtc::VCMProtectionCallback.
int ProtectionRequest(const FecProtectionParams* delta_params,
@@ -125,10 +125,10 @@
uint32_t* sent_video_rate_bps,
uint32_t* sent_nack_rate_bps,
uint32_t* sent_fec_rate_bps)
- RTC_LOCKS_EXCLUDED(crit_) override;
+ RTC_LOCKS_EXCLUDED(mutex_) override;
// Implements FecControllerOverride.
- void SetFecAllowed(bool fec_allowed) RTC_LOCKS_EXCLUDED(crit_) override;
+ void SetFecAllowed(bool fec_allowed) RTC_LOCKS_EXCLUDED(mutex_) override;
// Implements EncodedImageCallback.
// Returns 0 if the packet was routed / sent, -1 otherwise.
@@ -136,35 +136,35 @@
const EncodedImage& encoded_image,
const CodecSpecificInfo* codec_specific_info,
const RTPFragmentationHeader* fragmentation)
- RTC_LOCKS_EXCLUDED(crit_) override;
+ RTC_LOCKS_EXCLUDED(mutex_) override;
void OnBitrateAllocationUpdated(const VideoBitrateAllocation& bitrate)
- RTC_LOCKS_EXCLUDED(crit_) override;
+ RTC_LOCKS_EXCLUDED(mutex_) override;
void OnTransportOverheadChanged(size_t transport_overhead_bytes_per_packet)
- RTC_LOCKS_EXCLUDED(crit_) override;
+ RTC_LOCKS_EXCLUDED(mutex_) override;
void OnBitrateUpdated(BitrateAllocationUpdate update, int framerate)
- RTC_LOCKS_EXCLUDED(crit_) override;
- uint32_t GetPayloadBitrateBps() const RTC_LOCKS_EXCLUDED(crit_) override;
- uint32_t GetProtectionBitrateBps() const RTC_LOCKS_EXCLUDED(crit_) override;
+ RTC_LOCKS_EXCLUDED(mutex_) override;
+ uint32_t GetPayloadBitrateBps() const RTC_LOCKS_EXCLUDED(mutex_) override;
+ uint32_t GetProtectionBitrateBps() const RTC_LOCKS_EXCLUDED(mutex_) override;
void SetEncodingData(size_t width, size_t height, size_t num_temporal_layers)
- RTC_LOCKS_EXCLUDED(crit_) override;
+ RTC_LOCKS_EXCLUDED(mutex_) override;
std::vector<RtpSequenceNumberMap::Info> GetSentRtpPacketInfos(
uint32_t ssrc,
rtc::ArrayView<const uint16_t> sequence_numbers) const
- RTC_LOCKS_EXCLUDED(crit_) override;
+ RTC_LOCKS_EXCLUDED(mutex_) override;
// From StreamFeedbackObserver.
void OnPacketFeedbackVector(
std::vector<StreamPacketInfo> packet_feedback_vector)
- RTC_LOCKS_EXCLUDED(crit_) override;
+ RTC_LOCKS_EXCLUDED(mutex_) override;
private:
- bool IsActiveLocked() RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_);
+ bool IsActiveLocked() RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
void SetActiveModulesLocked(const std::vector<bool> active_modules)
- RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_);
- void UpdateModuleSendingState() RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_);
+ RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
+ void UpdateModuleSendingState() RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
void ConfigureProtection();
void ConfigureSsrcs();
void ConfigureRids();
@@ -178,17 +178,17 @@
const bool has_packet_feedback_;
const bool use_deferred_fec_;
- // TODO(holmer): Remove crit_ once RtpVideoSender runs on the
+ // TODO(holmer): Remove mutex_ once RtpVideoSender runs on the
// transport task queue.
- rtc::CriticalSection crit_;
- bool active_ RTC_GUARDED_BY(crit_);
+ mutable Mutex mutex_;
+ bool active_ RTC_GUARDED_BY(mutex_);
ProcessThread* module_process_thread_;
rtc::ThreadChecker module_process_thread_checker_;
std::map<uint32_t, RtpState> suspended_ssrcs_;
const std::unique_ptr<FecController> fec_controller_;
- bool fec_allowed_ RTC_GUARDED_BY(crit_);
+ bool fec_allowed_ RTC_GUARDED_BY(mutex_);
// Rtp modules are assumed to be sorted in simulcast index order.
const std::vector<webrtc_internal_rtp_video_sender::RtpStreamSender>
@@ -202,15 +202,15 @@
// rewrite the frame id), therefore |shared_frame_id| has to live in a place
// where we are aware of all the different streams.
int64_t shared_frame_id_ = 0;
- std::vector<RtpPayloadParams> params_ RTC_GUARDED_BY(crit_);
+ std::vector<RtpPayloadParams> params_ RTC_GUARDED_BY(mutex_);
- size_t transport_overhead_bytes_per_packet_ RTC_GUARDED_BY(crit_);
+ size_t transport_overhead_bytes_per_packet_ RTC_GUARDED_BY(mutex_);
uint32_t protection_bitrate_bps_;
uint32_t encoder_target_rate_bps_;
- std::vector<bool> loss_mask_vector_ RTC_GUARDED_BY(crit_);
+ std::vector<bool> loss_mask_vector_ RTC_GUARDED_BY(mutex_);
- std::vector<FrameCounts> frame_counts_ RTC_GUARDED_BY(crit_);
+ std::vector<FrameCounts> frame_counts_ RTC_GUARDED_BY(mutex_);
FrameCountObserver* const frame_count_observer_;
// Effectively const map from SSRC to RtpRtcp, for all media SSRCs.
diff --git a/call/simulated_network.cc b/call/simulated_network.cc
index b298fdb..2ed9140 100644
--- a/call/simulated_network.cc
+++ b/call/simulated_network.cc
@@ -87,7 +87,7 @@
SimulatedNetwork::~SimulatedNetwork() = default;
void SimulatedNetwork::SetConfig(const Config& config) {
- rtc::CritScope crit(&config_lock_);
+ MutexLock lock(&config_lock_);
config_state_.config = config; // Shallow copy of the struct.
double prob_loss = config.loss_percent / 100.0;
if (config_state_.config.avg_burst_loss_length == -1) {
@@ -113,12 +113,12 @@
void SimulatedNetwork::UpdateConfig(
std::function<void(BuiltInNetworkBehaviorConfig*)> config_modifier) {
- rtc::CritScope crit(&config_lock_);
+ MutexLock lock(&config_lock_);
config_modifier(&config_state_.config);
}
void SimulatedNetwork::PauseTransmissionUntil(int64_t until_us) {
- rtc::CritScope crit(&config_lock_);
+ MutexLock lock(&config_lock_);
config_state_.pause_transmission_until_us = until_us;
}
@@ -260,7 +260,7 @@
}
SimulatedNetwork::ConfigState SimulatedNetwork::GetConfigState() const {
- rtc::CritScope crit(&config_lock_);
+ MutexLock lock(&config_lock_);
return config_state_;
}
diff --git a/call/simulated_network.h b/call/simulated_network.h
index 2ff90ec..b53ecc0 100644
--- a/call/simulated_network.h
+++ b/call/simulated_network.h
@@ -20,9 +20,9 @@
#include "api/test/simulated_network.h"
#include "api/units/data_size.h"
#include "api/units/timestamp.h"
-#include "rtc_base/critical_section.h"
#include "rtc_base/race_checker.h"
#include "rtc_base/random.h"
+#include "rtc_base/synchronization/mutex.h"
#include "rtc_base/thread_annotations.h"
#include "rtc_base/thread_checker.h"
@@ -96,7 +96,7 @@
RTC_RUN_ON(&process_checker_);
ConfigState GetConfigState() const;
- rtc::CriticalSection config_lock_;
+ mutable Mutex config_lock_;
// |process_checker_| guards the data structures involved in delay and loss
// processes, such as the packet queues.
