Deprecating ThreadChecker specific interface.
All changes outside thread_checker.h are by:
s/CalledOnValidThread/IsCurrent/
s/DetachFromThread/Detach/
Bug: webrtc:9883
Change-Id: Idbb1086bff0817db58e770116acf4c9d60fae8b3
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/131023
Commit-Queue: Sebastian Jansson <srte@webrtc.org>
Reviewed-by: Karl Wiberg <kwiberg@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#27494}diff --git a/api/stats_types.cc b/api/stats_types.cc
index a01ecd0..4c69a82 100644
--- a/api/stats_types.cc
+++ b/api/stats_types.cc
@@ -781,28 +781,28 @@
StatsCollection::StatsCollection() {}
StatsCollection::~StatsCollection() {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
for (auto* r : list_)
delete r;
}
StatsCollection::const_iterator StatsCollection::begin() const {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
return list_.begin();
}
StatsCollection::const_iterator StatsCollection::end() const {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
return list_.end();
}
size_t StatsCollection::size() const {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
return list_.size();
}
StatsReport* StatsCollection::InsertNew(const StatsReport::Id& id) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(Find(id) == nullptr);
StatsReport* report = new StatsReport(id);
list_.push_back(report);
@@ -810,13 +810,13 @@
}
StatsReport* StatsCollection::FindOrAddNew(const StatsReport::Id& id) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
StatsReport* ret = Find(id);
return ret ? ret : InsertNew(id);
}
StatsReport* StatsCollection::ReplaceOrAddNew(const StatsReport::Id& id) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(id.get());
Container::iterator it = absl::c_find_if(
list_,
@@ -833,7 +833,7 @@
// Looks for a report with the given |id|. If one is not found, null
// will be returned.
StatsReport* StatsCollection::Find(const StatsReport::Id& id) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
Container::iterator it = absl::c_find_if(
list_,
[&id](const StatsReport* r) -> bool { return r->id()->Equals(id); });
diff --git a/api/test/test_dependency_factory.cc b/api/test/test_dependency_factory.cc
index 3b80662..d343bee 100644
--- a/api/test/test_dependency_factory.cc
+++ b/api/test/test_dependency_factory.cc
@@ -29,7 +29,7 @@
nullptr;
const TestDependencyFactory& TestDependencyFactory::GetInstance() {
- RTC_DCHECK(GetThreadChecker()->CalledOnValidThread());
+ RTC_DCHECK(GetThreadChecker()->IsCurrent());
if (instance_ == nullptr) {
instance_ = absl::make_unique<TestDependencyFactory>();
}
@@ -38,14 +38,14 @@
void TestDependencyFactory::SetInstance(
std::unique_ptr<TestDependencyFactory> instance) {
- RTC_DCHECK(GetThreadChecker()->CalledOnValidThread());
+ RTC_DCHECK(GetThreadChecker()->IsCurrent());
RTC_CHECK(instance_ == nullptr);
instance_ = std::move(instance);
}
std::unique_ptr<VideoQualityTestFixtureInterface::InjectionComponents>
TestDependencyFactory::CreateComponents() const {
- RTC_DCHECK(GetThreadChecker()->CalledOnValidThread());
+ RTC_DCHECK(GetThreadChecker()->IsCurrent());
return nullptr;
}
diff --git a/audio/audio_receive_stream.cc b/audio/audio_receive_stream.cc
index 584f1f9..e13e880 100644
--- a/audio/audio_receive_stream.cc
+++ b/audio/audio_receive_stream.cc
@@ -120,7 +120,7 @@
RTC_DCHECK(audio_state_);
RTC_DCHECK(channel_receive_);
- module_process_thread_checker_.DetachFromThread();
+ module_process_thread_checker_.Detach();
if (!config.media_transport) {
RTC_DCHECK(receiver_controller);
@@ -147,7 +147,7 @@
void AudioReceiveStream::Reconfigure(
const webrtc::AudioReceiveStream::Config& config) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
ConfigureStream(this, config, false);
}
@@ -317,7 +317,7 @@
// TODO(solenberg): Tests call this function on a network thread, libjingle
// calls on the worker thread. We should move towards always using a network
// thread. Then this check can be enabled.
- // RTC_DCHECK(!thread_checker_.CalledOnValidThread());
+ // RTC_DCHECK(!thread_checker_.IsCurrent());
channel_receive_->ReceivedRTCPPacket(packet, length);
}
@@ -325,7 +325,7 @@
// TODO(solenberg): Tests call this function on a network thread, libjingle
// calls on the worker thread. We should move towards always using a network
// thread. Then this check can be enabled.
- // RTC_DCHECK(!thread_checker_.CalledOnValidThread());
+ // RTC_DCHECK(!thread_checker_.IsCurrent());
channel_receive_->OnRtpPacket(packet);
}
diff --git a/audio/audio_send_stream.cc b/audio/audio_send_stream.cc
index e9b89be..7804f55 100644
--- a/audio/audio_send_stream.cc
+++ b/audio/audio_send_stream.cc
@@ -166,7 +166,7 @@
ConfigureStream(this, config, true);
- pacer_thread_checker_.DetachFromThread();
+ pacer_thread_checker_.Detach();
if (rtp_transport_) {
// Signal congestion controller this object is ready for OnPacket*
// callbacks.
@@ -175,7 +175,7 @@
}
AudioSendStream::~AudioSendStream() {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
RTC_LOG(LS_INFO) << "~AudioSendStream: " << config_.rtp.ssrc;
RTC_DCHECK(!sending_);
if (rtp_transport_) {
@@ -190,13 +190,13 @@
}
const webrtc::AudioSendStream::Config& AudioSendStream::GetConfig() const {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
return config_;
}
void AudioSendStream::Reconfigure(
const webrtc::AudioSendStream::Config& new_config) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
ConfigureStream(this, new_config, false);
}
@@ -345,7 +345,7 @@
}
void AudioSendStream::Stop() {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
if (!sending_) {
return;
}
@@ -365,14 +365,14 @@
int payload_frequency,
int event,
int duration_ms) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
channel_send_->SetSendTelephoneEventPayloadType(payload_type,
payload_frequency);
return channel_send_->SendTelephoneEventOutband(event, duration_ms);
}
void AudioSendStream::SetMuted(bool muted) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
channel_send_->SetInputMute(muted);
}
@@ -382,7 +382,7 @@
webrtc::AudioSendStream::Stats AudioSendStream::GetStats(
bool has_remote_tracks) const {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
webrtc::AudioSendStream::Stats stats;
stats.local_ssrc = config_.rtp.ssrc;
stats.target_bitrate_bps = channel_send_->GetBitrate();
@@ -432,14 +432,14 @@
}
void AudioSendStream::SignalNetworkState(NetworkState state) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
}
void AudioSendStream::DeliverRtcp(const uint8_t* packet, size_t length) {
// TODO(solenberg): Tests call this function on a network thread, libjingle
// calls on the worker thread. We should move towards always using a network
// thread. Then this check can be enabled.
- // RTC_DCHECK(!worker_thread_checker_.CalledOnValidThread());
+ // RTC_DCHECK(!worker_thread_checker_.IsCurrent());
channel_send_->ReceivedRTCPPacket(packet, length);
}
@@ -465,7 +465,7 @@
}
void AudioSendStream::OnPacketAdded(uint32_t ssrc, uint16_t seq_num) {
- RTC_DCHECK(pacer_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(pacer_thread_checker_.IsCurrent());
// Only packets that belong to this stream are of interest.
if (ssrc == config_.rtp.ssrc) {
rtc::CritScope lock(&packet_loss_tracker_cs_);
@@ -478,7 +478,7 @@
void AudioSendStream::OnPacketFeedbackVector(
const std::vector<PacketFeedback>& packet_feedback_vector) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
absl::optional<float> plr;
absl::optional<float> rplr;
{
@@ -500,7 +500,7 @@
void AudioSendStream::SetTransportOverhead(
int transport_overhead_per_packet_bytes) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
rtc::CritScope cs(&overhead_per_packet_lock_);
transport_overhead_per_packet_bytes_ = transport_overhead_per_packet_bytes;
UpdateOverheadForEncoder();
@@ -563,7 +563,7 @@
void AudioSendStream::StoreEncoderProperties(int sample_rate_hz,
size_t num_channels) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
encoder_sample_rate_hz_ = sample_rate_hz;
encoder_num_channels_ = num_channels;
if (sending_) {
@@ -806,7 +806,7 @@
}
void AudioSendStream::RemoveBitrateObserver() {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
rtc::Event thread_sync_event;
worker_queue_->PostTask([this, &thread_sync_event] {
RTC_DCHECK_RUN_ON(worker_queue_);
diff --git a/audio/audio_state.cc b/audio/audio_state.cc
index 334eaed..edba0cf 100644
--- a/audio/audio_state.cc
+++ b/audio/audio_state.cc
@@ -28,13 +28,13 @@
AudioState::AudioState(const AudioState::Config& config)
: config_(config),
audio_transport_(config_.audio_mixer, config_.audio_processing.get()) {
- process_thread_checker_.DetachFromThread();
+ process_thread_checker_.Detach();
RTC_DCHECK(config_.audio_mixer);
RTC_DCHECK(config_.audio_device_module);
}
AudioState::~AudioState() {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(receiving_streams_.empty());
RTC_DCHECK(sending_streams_.empty());
}
@@ -49,12 +49,12 @@
}
bool AudioState::typing_noise_detected() const {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
return audio_transport_.typing_noise_detected();
}
void AudioState::AddReceivingStream(webrtc::AudioReceiveStream* stream) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK_EQ(0, receiving_streams_.count(stream));
receiving_streams_.insert(stream);
if (!config_.audio_mixer->AddSource(
@@ -76,7 +76,7 @@
}
void AudioState::RemoveReceivingStream(webrtc::AudioReceiveStream* stream) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
auto count = receiving_streams_.erase(stream);
RTC_DCHECK_EQ(1, count);
config_.audio_mixer->RemoveSource(
@@ -89,7 +89,7 @@
void AudioState::AddSendingStream(webrtc::AudioSendStream* stream,
int sample_rate_hz,
size_t num_channels) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
auto& properties = sending_streams_[stream];
properties.sample_rate_hz = sample_rate_hz;
properties.num_channels = num_channels;
@@ -109,7 +109,7 @@
}
void AudioState::RemoveSendingStream(webrtc::AudioSendStream* stream) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
auto count = sending_streams_.erase(stream);
RTC_DCHECK_EQ(1, count);
UpdateAudioTransportWithSendingStreams();
@@ -120,7 +120,7 @@
void AudioState::SetPlayout(bool enabled) {
RTC_LOG(INFO) << "SetPlayout(" << enabled << ")";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (playout_enabled_ != enabled) {
playout_enabled_ = enabled;
if (enabled) {
@@ -138,7 +138,7 @@
void AudioState::SetRecording(bool enabled) {
RTC_LOG(INFO) << "SetRecording(" << enabled << ")";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (recording_enabled_ != enabled) {
recording_enabled_ = enabled;
if (enabled) {
@@ -152,7 +152,7 @@
}
AudioState::Stats AudioState::GetAudioInputStats() const {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
const voe::AudioLevel& audio_level = audio_transport_.audio_level();
Stats result;
result.audio_level = audio_level.LevelFullRange();
@@ -164,12 +164,12 @@
}
void AudioState::SetStereoChannelSwapping(bool enable) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
audio_transport_.SetStereoChannelSwapping(enable);
}
void AudioState::UpdateAudioTransportWithSendingStreams() {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
std::vector<webrtc::AudioSendStream*> sending_streams;
int max_sample_rate_hz = 8000;
size_t max_num_channels = 1;
diff --git a/audio/channel_receive.cc b/audio/channel_receive.cc
index b3d771a..088aa57 100644
--- a/audio/channel_receive.cc
+++ b/audio/channel_receive.cc
@@ -462,7 +462,7 @@
frame_decryptor_(frame_decryptor),
crypto_options_(crypto_options) {
// TODO(nisse): Use _moduleProcessThreadPtr instead?
- module_process_thread_checker_.DetachFromThread();
+ module_process_thread_checker_.Detach();
RTC_DCHECK(module_process_thread);
RTC_DCHECK(audio_device_module);
@@ -509,7 +509,7 @@
}
ChannelReceive::~ChannelReceive() {
- RTC_DCHECK(construction_thread_.CalledOnValidThread());
+ RTC_DCHECK(construction_thread_.IsCurrent());
if (media_transport_) {
media_transport_->SetReceiveAudioSink(nullptr);
@@ -525,19 +525,19 @@
}
void ChannelReceive::SetSink(AudioSinkInterface* sink) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
rtc::CritScope cs(&_callbackCritSect);
audio_sink_ = sink;
}
void ChannelReceive::StartPlayout() {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
rtc::CritScope lock(&playing_lock_);
playing_ = true;
}
void ChannelReceive::StopPlayout() {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
rtc::CritScope lock(&playing_lock_);
playing_ = false;
_outputAudioLevel.Clear();
@@ -545,12 +545,12 @@
absl::optional<std::pair<int, SdpAudioFormat>>
ChannelReceive::GetReceiveCodec() const {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
return audio_coding_->ReceiveCodec();
}
std::vector<webrtc::RtpSource> ChannelReceive::GetSources() const {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
int64_t now_ms = rtc::TimeMillis();
std::vector<RtpSource> sources;
{
@@ -568,7 +568,7 @@
void ChannelReceive::SetReceiveCodecs(
const std::map<int, SdpAudioFormat>& codecs) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
for (const auto& kv : codecs) {
RTC_DCHECK_GE(kv.second.clockrate_hz, 1000);
payload_type_frequencies_[kv.first] = kv.second.clockrate_hz;
@@ -693,34 +693,34 @@
}
int ChannelReceive::GetSpeechOutputLevelFullRange() const {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
return _outputAudioLevel.LevelFullRange();
}
double ChannelReceive::GetTotalOutputEnergy() const {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
return _outputAudioLevel.TotalEnergy();
}
double ChannelReceive::GetTotalOutputDuration() const {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
return _outputAudioLevel.TotalDuration();
}
void ChannelReceive::SetChannelOutputVolumeScaling(float scaling) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
rtc::CritScope cs(&volume_settings_critsect_);
_outputGain = scaling;
}
void ChannelReceive::SetLocalSSRC(uint32_t ssrc) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
_rtpRtcpModule->SetSSRC(ssrc);
}
void ChannelReceive::RegisterReceiverCongestionControlObjects(
PacketRouter* packet_router) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
RTC_DCHECK(packet_router);
RTC_DCHECK(!packet_router_);
constexpr bool remb_candidate = false;
@@ -729,14 +729,14 @@
}
void ChannelReceive::ResetReceiverCongestionControlObjects() {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
RTC_DCHECK(packet_router_);
packet_router_->RemoveReceiveRtpModule(_rtpRtcpModule.get());
packet_router_ = nullptr;
}
CallReceiveStatistics ChannelReceive::GetRTCPStatistics() const {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
// --- RtcpStatistics
CallReceiveStatistics stats;
@@ -779,7 +779,7 @@
}
void ChannelReceive::SetNACKStatus(bool enable, int max_packets) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
// None of these functions can fail.
if (enable) {
rtp_receive_statistics_->SetMaxReorderingThreshold(max_packets);
@@ -799,13 +799,13 @@
void ChannelReceive::SetAssociatedSendChannel(
const ChannelSendInterface* channel) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
rtc::CritScope lock(&assoc_send_channel_lock_);
associated_send_channel_ = channel;
}
NetworkStatistics ChannelReceive::GetNetworkStatistics() const {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
NetworkStatistics stats;
int error = audio_coding_->GetNetworkStatistics(&stats);
RTC_DCHECK_EQ(0, error);
@@ -813,21 +813,21 @@
}
AudioDecodingCallStats ChannelReceive::GetDecodingCallStatistics() const {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
AudioDecodingCallStats stats;
audio_coding_->GetDecodingCallStatistics(&stats);
return stats;
}
uint32_t ChannelReceive::GetDelayEstimate() const {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread() ||
- module_process_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent() ||
+ module_process_thread_checker_.IsCurrent());
rtc::CritScope lock(&video_sync_lock_);
return audio_coding_->FilteredCurrentDelayMs() + playout_delay_ms_;
}
void ChannelReceive::SetMinimumPlayoutDelay(int delay_ms) {
- RTC_DCHECK(module_process_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(module_process_thread_checker_.IsCurrent());
// Limit to range accepted by both VoE and ACM, so we're at least getting as
// close as possible, instead of failing.
delay_ms = rtc::SafeClamp(delay_ms, kVoiceEngineMinMinPlayoutDelayMs,
@@ -855,7 +855,7 @@
}
absl::optional<Syncable::Info> ChannelReceive::GetSyncInfo() const {
- RTC_DCHECK(module_process_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(module_process_thread_checker_.IsCurrent());
Syncable::Info info;
if (_rtpRtcpModule->RemoteNTP(&info.capture_time_ntp_secs,
&info.capture_time_ntp_frac, nullptr, nullptr,
diff --git a/audio/channel_send.cc b/audio/channel_send.cc
index 71c33d6..4e0094e 100644
--- a/audio/channel_send.cc
+++ b/audio/channel_send.cc
@@ -302,13 +302,13 @@
class TransportFeedbackProxy : public TransportFeedbackObserver {
public:
TransportFeedbackProxy() : feedback_observer_(nullptr) {
- pacer_thread_.DetachFromThread();
- network_thread_.DetachFromThread();
+ pacer_thread_.Detach();
+ network_thread_.Detach();
}
void SetTransportFeedbackObserver(
TransportFeedbackObserver* feedback_observer) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
rtc::CritScope lock(&crit_);
feedback_observer_ = feedback_observer;
}
@@ -318,14 +318,14 @@
uint16_t sequence_number,
size_t length,
const PacedPacketInfo& pacing_info) override {
- RTC_DCHECK(pacer_thread_.CalledOnValidThread());
+ RTC_DCHECK(pacer_thread_.IsCurrent());
rtc::CritScope lock(&crit_);
if (feedback_observer_)
feedback_observer_->AddPacket(ssrc, sequence_number, length, pacing_info);
}
void OnTransportFeedback(const rtcp::TransportFeedback& feedback) override {
- RTC_DCHECK(network_thread_.CalledOnValidThread());
+ RTC_DCHECK(network_thread_.IsCurrent());
rtc::CritScope lock(&crit_);
if (feedback_observer_)
feedback_observer_->OnTransportFeedback(feedback);
@@ -342,19 +342,19 @@
class TransportSequenceNumberProxy : public TransportSequenceNumberAllocator {
public:
TransportSequenceNumberProxy() : seq_num_allocator_(nullptr) {
- pacer_thread_.DetachFromThread();
+ pacer_thread_.Detach();
}
void SetSequenceNumberAllocator(
TransportSequenceNumberAllocator* seq_num_allocator) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
rtc::CritScope lock(&crit_);
seq_num_allocator_ = seq_num_allocator;
}
// Implements TransportSequenceNumberAllocator.
uint16_t AllocateSequenceNumber() override {
- RTC_DCHECK(pacer_thread_.CalledOnValidThread());
+ RTC_DCHECK(pacer_thread_.IsCurrent());
rtc::CritScope lock(&crit_);
if (!seq_num_allocator_)
return 0;
@@ -373,7 +373,7 @@
RtpPacketSenderProxy() : rtp_packet_sender_(nullptr) {}
void SetPacketSender(RtpPacketSender* rtp_packet_sender) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
rtc::CritScope lock(&crit_);
rtp_packet_sender_ = rtp_packet_sender;
}
@@ -660,7 +660,7 @@
"AudioEncoder",
TaskQueueFactory::Priority::NORMAL)) {
RTC_DCHECK(module_process_thread);
- module_process_thread_checker_.DetachFromThread();
+ module_process_thread_checker_.Detach();
audio_coding_.reset(AudioCodingModule::Create(AudioCodingModule::Config()));
@@ -723,7 +723,7 @@
}
ChannelSend::~ChannelSend() {
- RTC_DCHECK(construction_thread_.CalledOnValidThread());
+ RTC_DCHECK(construction_thread_.IsCurrent());
if (media_transport_) {
media_transport_->RemoveTargetTransferRateObserver(this);
@@ -823,8 +823,8 @@
// or on a TaskQueue via VideoSendStreamImpl::OnEncoderConfigurationChanged.
// TODO(solenberg): Figure out a good way to check this or enforce calling
// rules.
- // RTC_DCHECK(worker_thread_checker_.CalledOnValidThread() ||
- // module_process_thread_checker_.CalledOnValidThread());
+ // RTC_DCHECK(worker_thread_checker_.IsCurrent() ||
+ // module_process_thread_checker_.IsCurrent());
rtc::CritScope lock(&bitrate_crit_section_);
CallEncoder([&](AudioEncoder* encoder) {
@@ -1152,7 +1152,7 @@
}
RtpRtcp* ChannelSend::GetRtpRtcp() const {
- RTC_DCHECK(module_process_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(module_process_thread_checker_.IsCurrent());
return _rtpRtcpModule.get();
}
diff --git a/audio/null_audio_poller.cc b/audio/null_audio_poller.cc
index 063a367..22f575d 100644
--- a/audio/null_audio_poller.cc
+++ b/audio/null_audio_poller.cc
@@ -38,12 +38,12 @@
}
NullAudioPoller::~NullAudioPoller() {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
rtc::Thread::Current()->Clear(this);
}
void NullAudioPoller::OnMessage(rtc::Message* msg) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
// Buffer to hold the audio samples.
int16_t buffer[kNumSamples * kNumChannels];
diff --git a/call/rtp_video_sender.cc b/call/rtp_video_sender.cc
index cd9283e..98cdd9a 100644
--- a/call/rtp_video_sender.cc
+++ b/call/rtp_video_sender.cc
@@ -254,7 +254,7 @@
frame_counts_(rtp_config.ssrcs.size()),
frame_count_observer_(observers.frame_count_observer) {
RTC_DCHECK_EQ(rtp_config.ssrcs.size(), rtp_streams_.size());
- module_process_thread_checker_.DetachFromThread();
+ module_process_thread_checker_.Detach();
// SSRCs are assumed to be sorted in the same order as |rtp_modules|.
for (uint32_t ssrc : rtp_config.ssrcs) {
// Restore state if it previously existed.
diff --git a/common_video/incoming_video_stream.cc b/common_video/incoming_video_stream.cc
index 6cce4ec..69e9d9c 100644
--- a/common_video/incoming_video_stream.cc
+++ b/common_video/incoming_video_stream.cc
@@ -31,7 +31,7 @@
TaskQueueFactory::Priority::HIGH)) {}
IncomingVideoStream::~IncomingVideoStream() {
- RTC_DCHECK(main_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(main_thread_checker_.IsCurrent());
}
void IncomingVideoStream::OnFrame(const VideoFrame& video_frame) {
diff --git a/examples/androidnativeapi/jni/android_call_client.cc b/examples/androidnativeapi/jni/android_call_client.cc
index 119444b..69afc89 100644
--- a/examples/androidnativeapi/jni/android_call_client.cc
+++ b/examples/androidnativeapi/jni/android_call_client.cc
@@ -78,7 +78,7 @@
AndroidCallClient::AndroidCallClient()
: call_started_(false), pc_observer_(absl::make_unique<PCObserver>(this)) {
- thread_checker_.DetachFromThread();
+ thread_checker_.Detach();
CreatePeerConnectionFactory();
}
diff --git a/examples/objcnativeapi/objc/objc_call_client.mm b/examples/objcnativeapi/objc/objc_call_client.mm
index a30f7f6..cbe2bab 100644
--- a/examples/objcnativeapi/objc/objc_call_client.mm
+++ b/examples/objcnativeapi/objc/objc_call_client.mm
@@ -60,7 +60,7 @@
ObjCCallClient::ObjCCallClient()
: call_started_(false), pc_observer_(absl::make_unique<PCObserver>(this)) {
- thread_checker_.DetachFromThread();
+ thread_checker_.Detach();
CreatePeerConnectionFactory();
}
diff --git a/media/engine/webrtc_video_engine.cc b/media/engine/webrtc_video_engine.cc
index 229a6c8..b3abf00 100644
--- a/media/engine/webrtc_video_engine.cc
+++ b/media/engine/webrtc_video_engine.cc
@@ -536,7 +536,7 @@
"WebRTC-Video-BufferPacketsWithUnknownSsrc")
? new UnhandledPacketsBuffer()
: nullptr) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
rtcp_receiver_report_ssrc_ = kDefaultRtcpReceiverReportSsrc;
sending_ = false;
diff --git a/media/engine/webrtc_voice_engine.cc b/media/engine/webrtc_voice_engine.cc
index dc9bc1c..b35090d 100644
--- a/media/engine/webrtc_voice_engine.cc
+++ b/media/engine/webrtc_voice_engine.cc
@@ -191,8 +191,8 @@
audio_mixer_(audio_mixer),
apm_(audio_processing) {
// This may be called from any thread, so detach thread checkers.
- worker_thread_checker_.DetachFromThread();
- signal_thread_checker_.DetachFromThread();
+ worker_thread_checker_.Detach();
+ signal_thread_checker_.Detach();
RTC_LOG(LS_INFO) << "WebRtcVoiceEngine::WebRtcVoiceEngine";
RTC_DCHECK(decoder_factory);
RTC_DCHECK(encoder_factory);
@@ -201,7 +201,7 @@
}
WebRtcVoiceEngine::~WebRtcVoiceEngine() {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
RTC_LOG(LS_INFO) << "WebRtcVoiceEngine::~WebRtcVoiceEngine";
if (initialized_) {
StopAecDump();
@@ -215,7 +215,7 @@
}
void WebRtcVoiceEngine::Init() {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
RTC_LOG(LS_INFO) << "WebRtcVoiceEngine::Init";
// TaskQueue expects to be created/destroyed on the same thread.
@@ -290,7 +290,7 @@
rtc::scoped_refptr<webrtc::AudioState> WebRtcVoiceEngine::GetAudioState()
const {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
return audio_state_;
}
@@ -299,13 +299,13 @@
const MediaConfig& config,
const AudioOptions& options,
const webrtc::CryptoOptions& crypto_options) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
return new WebRtcVoiceMediaChannel(this, config, options, crypto_options,
call);
}
bool WebRtcVoiceEngine::ApplyOptions(const AudioOptions& options_in) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
RTC_LOG(LS_INFO) << "WebRtcVoiceEngine::ApplyOptions: "
<< options_in.ToString();
AudioOptions options = options_in; // The options are modified below.
@@ -541,17 +541,17 @@
}
const std::vector<AudioCodec>& WebRtcVoiceEngine::send_codecs() const {
- RTC_DCHECK(signal_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(signal_thread_checker_.IsCurrent());
return send_codecs_;
}
const std::vector<AudioCodec>& WebRtcVoiceEngine::recv_codecs() const {
- RTC_DCHECK(signal_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(signal_thread_checker_.IsCurrent());
return recv_codecs_;
}
RtpCapabilities WebRtcVoiceEngine::GetCapabilities() const {
- RTC_DCHECK(signal_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(signal_thread_checker_.IsCurrent());
RtpCapabilities capabilities;
int id = 1;
capabilities.header_extensions.push_back(
@@ -562,13 +562,13 @@
}
void WebRtcVoiceEngine::RegisterChannel(WebRtcVoiceMediaChannel* channel) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
RTC_DCHECK(channel);
channels_.push_back(channel);
}
void WebRtcVoiceEngine::UnregisterChannel(WebRtcVoiceMediaChannel* channel) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
auto it = absl::c_find(channels_, channel);
RTC_DCHECK(it != channels_.end());
channels_.erase(it);
@@ -576,7 +576,7 @@
bool WebRtcVoiceEngine::StartAecDump(rtc::PlatformFile file,
int64_t max_size_bytes) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
auto aec_dump = webrtc::AecDumpFactory::Create(
file, max_size_bytes, low_priority_worker_queue_.get());
if (!aec_dump) {
@@ -587,7 +587,7 @@
}
void WebRtcVoiceEngine::StartAecDump(const std::string& filename) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
auto aec_dump = webrtc::AecDumpFactory::Create(
filename, -1, low_priority_worker_queue_.get());
@@ -597,24 +597,24 @@
}
void WebRtcVoiceEngine::StopAecDump() {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
apm()->DetachAecDump();
}
webrtc::AudioDeviceModule* WebRtcVoiceEngine::adm() {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
RTC_DCHECK(adm_);
return adm_.get();
}
webrtc::AudioProcessing* WebRtcVoiceEngine::apm() const {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
RTC_DCHECK(apm_);
return apm_.get();
}
webrtc::AudioState* WebRtcVoiceEngine::audio_state() {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
RTC_DCHECK(audio_state_);
return audio_state_.get();
}
@@ -746,7 +746,7 @@
}
~WebRtcAudioSendStream() override {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
ClearSource();
call_->DestroyAudioSendStream(stream_);
}
@@ -758,7 +758,7 @@
}
void SetRtpExtensions(const std::vector<webrtc::RtpExtension>& extensions) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
config_.rtp.extensions = extensions;
rtp_parameters_.header_extensions = extensions;
ReconfigureAudioSendStream();
@@ -770,7 +770,7 @@
}
void SetMid(const std::string& mid) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
if (config_.rtp.mid == mid) {
return;
}
@@ -780,14 +780,14 @@
void SetFrameEncryptor(
rtc::scoped_refptr<webrtc::FrameEncryptorInterface> frame_encryptor) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
config_.frame_encryptor = frame_encryptor;
ReconfigureAudioSendStream();
}
void SetAudioNetworkAdaptorConfig(
const absl::optional<std::string>& audio_network_adaptor_config) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
if (config_.audio_network_adaptor_config == audio_network_adaptor_config) {
return;
}
@@ -797,7 +797,7 @@
}
bool SetMaxSendBitrate(int bps) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
RTC_DCHECK(config_.send_codec_spec);
RTC_DCHECK(audio_codec_spec_);
auto send_rate = ComputeSendBitrate(
@@ -820,32 +820,32 @@
int payload_freq,
int event,
int duration_ms) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
RTC_DCHECK(stream_);
return stream_->SendTelephoneEvent(payload_type, payload_freq, event,
duration_ms);
}
void SetSend(bool send) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
send_ = send;
UpdateSendState();
}
void SetMuted(bool muted) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
RTC_DCHECK(stream_);
stream_->SetMuted(muted);
muted_ = muted;
}
bool muted() const {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
return muted_;
}
webrtc::AudioSendStream::Stats GetStats(bool has_remote_tracks) const {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
RTC_DCHECK(stream_);
return stream_->GetStats(has_remote_tracks);
}
@@ -855,7 +855,7 @@
// This method is called on the libjingle worker thread.
// TODO(xians): Make sure Start() is called only once.
void SetSource(AudioSource* source) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
RTC_DCHECK(source);
if (source_) {
RTC_DCHECK(source_ == source);
@@ -870,7 +870,7 @@
// callback will be received after this method.
// This method is called on the libjingle worker thread.
void ClearSource() {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
if (source_) {
source_->SetSink(nullptr);
source_ = nullptr;
@@ -899,7 +899,7 @@
// Callback from the |source_| when it is going away. In case Start() has
// never been called, this callback won't be triggered.
void OnClose() override {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
// Set |source_| to nullptr to make sure no more callback will get into
// the source.
source_ = nullptr;
@@ -961,7 +961,7 @@
private:
void UpdateSendState() {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
RTC_DCHECK(stream_);
RTC_DCHECK_EQ(1UL, rtp_parameters_.encodings.size());
if (send_ && source_ != nullptr && rtp_parameters_.encodings[0].active) {
@@ -972,7 +972,7 @@
}
void UpdateAllowedBitrateRange() {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
const bool is_opus =
config_.send_codec_spec &&
absl::EqualsIgnoreCase(config_.send_codec_spec->format.name,
@@ -986,7 +986,7 @@
void UpdateSendCodecSpec(
const webrtc::AudioSendStream::Config::SendCodecSpec& send_codec_spec) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
config_.send_codec_spec = send_codec_spec;
auto info =
config_.encoder_factory->QueryAudioEncoder(send_codec_spec.format);
@@ -1010,7 +1010,7 @@
}
void ReconfigureAudioSendStream() {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
RTC_DCHECK(stream_);
stream_->Reconfigure(config_);
}
@@ -1084,26 +1084,26 @@
}
~WebRtcAudioReceiveStream() {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
call_->DestroyAudioReceiveStream(stream_);
}
void SetFrameDecryptor(
rtc::scoped_refptr<webrtc::FrameDecryptorInterface> frame_decryptor) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
config_.frame_decryptor = frame_decryptor;
RecreateAudioReceiveStream();
}
void SetLocalSsrc(uint32_t local_ssrc) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
config_.rtp.local_ssrc = local_ssrc;
ReconfigureAudioReceiveStream();
}
void SetUseTransportCcAndRecreateStream(bool use_transport_cc,
bool use_nack) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
config_.rtp.transport_cc = use_transport_cc;
config_.rtp.nack.rtp_history_ms = use_nack ? kNackRtpHistoryMs : 0;
ReconfigureAudioReceiveStream();
@@ -1111,21 +1111,21 @@
void SetRtpExtensionsAndRecreateStream(
const std::vector<webrtc::RtpExtension>& extensions) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
config_.rtp.extensions = extensions;
RecreateAudioReceiveStream();
}
// Set a new payload type -> decoder map.
void SetDecoderMap(const std::map<int, webrtc::SdpAudioFormat>& decoder_map) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
config_.decoder_map = decoder_map;
ReconfigureAudioReceiveStream();
}
void MaybeRecreateAudioReceiveStream(
const std::vector<std::string>& stream_ids) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
std::string sync_group;
if (!stream_ids.empty()) {
sync_group = stream_ids[0];
@@ -1140,13 +1140,13 @@
}
webrtc::AudioReceiveStream::Stats GetStats() const {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
RTC_DCHECK(stream_);
return stream_->GetStats();
}
void SetRawAudioSink(std::unique_ptr<webrtc::AudioSinkInterface> sink) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
// Need to update the stream's sink first; once raw_audio_sink_ is
// reassigned, whatever was in there before is destroyed.
stream_->SetSink(sink.get());
@@ -1154,13 +1154,13 @@
}
void SetOutputVolume(double volume) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
output_volume_ = volume;
stream_->SetGain(volume);
}
void SetPlayout(bool playout) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
RTC_DCHECK(stream_);
if (playout) {
stream_->Start();
@@ -1171,7 +1171,7 @@
}
bool SetBaseMinimumPlayoutDelayMs(int delay_ms) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
RTC_DCHECK(stream_);
if (stream_->SetBaseMinimumPlayoutDelayMs(delay_ms)) {
// Memorize only valid delay because during stream recreation it will be
@@ -1188,13 +1188,13 @@
}
int GetBaseMinimumPlayoutDelayMs() const {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
RTC_DCHECK(stream_);
return stream_->GetBaseMinimumPlayoutDelayMs();
}
std::vector<webrtc::RtpSource> GetSources() {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
RTC_DCHECK(stream_);
return stream_->GetSources();
}
@@ -1210,7 +1210,7 @@
private:
void RecreateAudioReceiveStream() {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
if (stream_) {
call_->DestroyAudioReceiveStream(stream_);
}
@@ -1222,7 +1222,7 @@
}
void ReconfigureAudioReceiveStream() {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
RTC_DCHECK(stream_);
stream_->Reconfigure(config_);
}
@@ -1258,7 +1258,7 @@
}
WebRtcVoiceMediaChannel::~WebRtcVoiceMediaChannel() {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
RTC_LOG(LS_VERBOSE) << "WebRtcVoiceMediaChannel::~WebRtcVoiceMediaChannel";
// TODO(solenberg): Should be able to delete the streams directly, without
// going through RemoveNnStream(), once stream objects handle
@@ -1275,7 +1275,7 @@
bool WebRtcVoiceMediaChannel::SetSendParameters(
const AudioSendParameters& params) {
TRACE_EVENT0("webrtc", "WebRtcVoiceMediaChannel::SetSendParameters");
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
RTC_LOG(LS_INFO) << "WebRtcVoiceMediaChannel::SetSendParameters: "
<< params.ToString();
// TODO(pthatcher): Refactor this to be more clean now that we have
@@ -1320,7 +1320,7 @@
bool WebRtcVoiceMediaChannel::SetRecvParameters(
const AudioRecvParameters& params) {
TRACE_EVENT0("webrtc", "WebRtcVoiceMediaChannel::SetRecvParameters");
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
RTC_LOG(LS_INFO) << "WebRtcVoiceMediaChannel::SetRecvParameters: "
<< params.ToString();
// TODO(pthatcher): Refactor this to be more clean now that we have
@@ -1346,7 +1346,7 @@
webrtc::RtpParameters WebRtcVoiceMediaChannel::GetRtpSendParameters(
uint32_t ssrc) const {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
auto it = send_streams_.find(ssrc);
if (it == send_streams_.end()) {
RTC_LOG(LS_WARNING) << "Attempting to get RTP send parameters for stream "
@@ -1366,7 +1366,7 @@
webrtc::RTCError WebRtcVoiceMediaChannel::SetRtpSendParameters(
uint32_t ssrc,
const webrtc::RtpParameters& parameters) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
auto it = send_streams_.find(ssrc);
if (it == send_streams_.end()) {
RTC_LOG(LS_WARNING) << "Attempting to set RTP send parameters for stream "
@@ -1419,7 +1419,7 @@
webrtc::RtpParameters WebRtcVoiceMediaChannel::GetRtpReceiveParameters(
uint32_t ssrc) const {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
webrtc::RtpParameters rtp_params;
// SSRC of 0 represents the default receive stream.
if (ssrc == 0) {
@@ -1451,7 +1451,7 @@
bool WebRtcVoiceMediaChannel::SetRtpReceiveParameters(
uint32_t ssrc,
const webrtc::RtpParameters& parameters) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
// SSRC of 0 represents the default receive stream.
if (ssrc == 0) {
if (!default_sink_) {
@@ -1481,7 +1481,7 @@
}
bool WebRtcVoiceMediaChannel::SetOptions(const AudioOptions& options) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
RTC_LOG(LS_INFO) << "Setting voice channel options: " << options.ToString();
// We retain all of the existing options, and apply the given ones
@@ -1507,7 +1507,7 @@
bool WebRtcVoiceMediaChannel::SetRecvCodecs(
const std::vector<AudioCodec>& codecs) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
// Set the payload types to be used for incoming media.
RTC_LOG(LS_INFO) << "Setting receive voice codecs.";
@@ -1586,7 +1586,7 @@
// and receive streams may be reconfigured based on the new settings.
bool WebRtcVoiceMediaChannel::SetSendCodecs(
const std::vector<AudioCodec>& codecs) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
dtmf_payload_type_ = absl::nullopt;
dtmf_payload_freq_ = -1;
@@ -1720,7 +1720,7 @@
void WebRtcVoiceMediaChannel::ChangePlayout(bool playout) {
TRACE_EVENT0("webrtc", "WebRtcVoiceMediaChannel::ChangePlayout");
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
if (playout_ == playout) {
return;
}
@@ -1763,7 +1763,7 @@
bool enable,
const AudioOptions* options,
AudioSource* source) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
// TODO(solenberg): The state change should be fully rolled back if any one of
// these calls fail.
if (!SetLocalSource(ssrc, source)) {
@@ -1780,7 +1780,7 @@
bool WebRtcVoiceMediaChannel::AddSendStream(const StreamParams& sp) {
TRACE_EVENT0("webrtc", "WebRtcVoiceMediaChannel::AddSendStream");
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
RTC_LOG(LS_INFO) << "AddSendStream: " << sp.ToString();
uint32_t ssrc = sp.first_ssrc();
@@ -1819,7 +1819,7 @@
bool WebRtcVoiceMediaChannel::RemoveSendStream(uint32_t ssrc) {
TRACE_EVENT0("webrtc", "WebRtcVoiceMediaChannel::RemoveSendStream");
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
RTC_LOG(LS_INFO) << "RemoveSendStream: " << ssrc;
auto it = send_streams_.find(ssrc);
@@ -1845,7 +1845,7 @@
bool WebRtcVoiceMediaChannel::AddRecvStream(const StreamParams& sp) {
TRACE_EVENT0("webrtc", "WebRtcVoiceMediaChannel::AddRecvStream");
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
RTC_LOG(LS_INFO) << "AddRecvStream: " << sp.ToString();
if (!sp.has_ssrcs()) {
@@ -1896,7 +1896,7 @@
bool WebRtcVoiceMediaChannel::RemoveRecvStream(uint32_t ssrc) {
TRACE_EVENT0("webrtc", "WebRtcVoiceMediaChannel::RemoveRecvStream");
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
RTC_LOG(LS_INFO) << "RemoveRecvStream: " << ssrc;
if (ssrc == 0) {
@@ -1945,7 +1945,7 @@
}
bool WebRtcVoiceMediaChannel::SetOutputVolume(uint32_t ssrc, double volume) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
std::vector<uint32_t> ssrcs(1, ssrc);
// SSRC of 0 represents the default receive stream.
if (ssrc == 0) {
@@ -1967,7 +1967,7 @@
bool WebRtcVoiceMediaChannel::SetBaseMinimumPlayoutDelayMs(uint32_t ssrc,
int delay_ms) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
std::vector<uint32_t> ssrcs(1, ssrc);
// SSRC of 0 represents the default receive stream.
if (ssrc == 0) {
@@ -2010,7 +2010,7 @@
void WebRtcVoiceMediaChannel::SetFrameDecryptor(
uint32_t ssrc,
rtc::scoped_refptr<webrtc::FrameDecryptorInterface> frame_decryptor) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
auto matching_stream = recv_streams_.find(ssrc);
if (matching_stream != recv_streams_.end()) {
matching_stream->second->SetFrameDecryptor(frame_decryptor);
@@ -2024,7 +2024,7 @@
void WebRtcVoiceMediaChannel::SetFrameEncryptor(
uint32_t ssrc,
rtc::scoped_refptr<webrtc::FrameEncryptorInterface> frame_encryptor) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
auto matching_stream = send_streams_.find(ssrc);
if (matching_stream != send_streams_.end()) {
matching_stream->second->SetFrameEncryptor(frame_encryptor);
@@ -2034,7 +2034,7 @@
bool WebRtcVoiceMediaChannel::InsertDtmf(uint32_t ssrc,
int event,
int duration) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
RTC_LOG(LS_INFO) << "WebRtcVoiceMediaChannel::InsertDtmf";
if (!CanInsertDtmf()) {
return false;
@@ -2057,7 +2057,7 @@
void WebRtcVoiceMediaChannel::OnPacketReceived(rtc::CopyOnWriteBuffer packet,
int64_t packet_time_us) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
webrtc::PacketReceiver::DeliveryStatus delivery_result =
call_->Receiver()->DeliverPacket(webrtc::MediaType::AUDIO, packet,
@@ -2120,7 +2120,7 @@
void WebRtcVoiceMediaChannel::OnRtcpReceived(rtc::CopyOnWriteBuffer packet,
int64_t packet_time_us) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
// Forward packet to Call as well.
call_->Receiver()->DeliverPacket(webrtc::MediaType::AUDIO, packet,
@@ -2130,14 +2130,14 @@
void WebRtcVoiceMediaChannel::OnNetworkRouteChanged(
const std::string& transport_name,
const rtc::NetworkRoute& network_route) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
call_->GetTransportControllerSend()->OnNetworkRouteChanged(transport_name,
network_route);
call_->OnAudioTransportOverheadChanged(network_route.packet_overhead);
}
bool WebRtcVoiceMediaChannel::MuteStream(uint32_t ssrc, bool muted) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
const auto it = send_streams_.find(ssrc);
if (it == send_streams_.end()) {
RTC_LOG(LS_WARNING) << "The specified ssrc " << ssrc << " is not in use.";
@@ -2172,7 +2172,7 @@
}
void WebRtcVoiceMediaChannel::OnReadyToSend(bool ready) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
RTC_LOG(LS_VERBOSE) << "OnReadyToSend: " << (ready ? "Ready." : "Not ready.");
call_->SignalChannelNetworkState(
webrtc::MediaType::AUDIO,
@@ -2181,7 +2181,7 @@
bool WebRtcVoiceMediaChannel::GetStats(VoiceMediaInfo* info) {
TRACE_EVENT0("webrtc", "WebRtcVoiceMediaChannel::GetStats");
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
RTC_DCHECK(info);
// Get SSRC and stats for each sender.
@@ -2292,7 +2292,7 @@
void WebRtcVoiceMediaChannel::SetRawAudioSink(
uint32_t ssrc,
std::unique_ptr<webrtc::AudioSinkInterface> sink) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
RTC_LOG(LS_VERBOSE) << "WebRtcVoiceMediaChannel::SetRawAudioSink: ssrc:"
<< ssrc << " " << (sink ? "(ptr)" : "NULL");
if (ssrc == 0) {
@@ -2325,7 +2325,7 @@
bool WebRtcVoiceMediaChannel::MaybeDeregisterUnsignaledRecvStream(
uint32_t ssrc) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
auto it = absl::c_find(unsignaled_recv_ssrcs_, ssrc);
if (it != unsignaled_recv_ssrcs_.end()) {
unsignaled_recv_ssrcs_.erase(it);
diff --git a/modules/audio_device/android/aaudio_player.cc b/modules/audio_device/android/aaudio_player.cc
index d4b8372..7e3721f 100644
--- a/modules/audio_device/android/aaudio_player.cc
+++ b/modules/audio_device/android/aaudio_player.cc
@@ -27,7 +27,7 @@
: main_thread_(rtc::Thread::Current()),
aaudio_(audio_manager, AAUDIO_DIRECTION_OUTPUT, this) {
RTC_LOG(INFO) << "ctor";
- thread_checker_aaudio_.DetachFromThread();
+ thread_checker_aaudio_.Detach();
}
AAudioPlayer::~AAudioPlayer() {
@@ -101,7 +101,7 @@
RTC_LOG(LS_ERROR) << "StopPlayout failed";
return -1;
}
- thread_checker_aaudio_.DetachFromThread();
+ thread_checker_aaudio_.Detach();
initialized_ = false;
playing_ = false;
return 0;
diff --git a/modules/audio_device/android/aaudio_recorder.cc b/modules/audio_device/android/aaudio_recorder.cc
index 446512e..2aca3fe 100644
--- a/modules/audio_device/android/aaudio_recorder.cc
+++ b/modules/audio_device/android/aaudio_recorder.cc
@@ -29,19 +29,19 @@
: main_thread_(rtc::Thread::Current()),
aaudio_(audio_manager, AAUDIO_DIRECTION_INPUT, this) {
RTC_LOG(INFO) << "ctor";
- thread_checker_aaudio_.DetachFromThread();
+ thread_checker_aaudio_.Detach();
}
AAudioRecorder::~AAudioRecorder() {
RTC_LOG(INFO) << "dtor";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
Terminate();
RTC_LOG(INFO) << "detected owerflows: " << overflow_count_;
}
int AAudioRecorder::Init() {
RTC_LOG(INFO) << "Init";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (aaudio_.audio_parameters().channels() == 2) {
RTC_DLOG(LS_WARNING) << "Stereo mode is enabled";
}
@@ -50,14 +50,14 @@
int AAudioRecorder::Terminate() {
RTC_LOG(INFO) << "Terminate";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
StopRecording();
return 0;
}
int AAudioRecorder::InitRecording() {
RTC_LOG(INFO) << "InitRecording";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(!initialized_);
RTC_DCHECK(!recording_);
if (!aaudio_.Init()) {
@@ -69,7 +69,7 @@
int AAudioRecorder::StartRecording() {
RTC_LOG(INFO) << "StartRecording";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(initialized_);
RTC_DCHECK(!recording_);
if (fine_audio_buffer_) {
@@ -86,14 +86,14 @@
int AAudioRecorder::StopRecording() {
RTC_LOG(INFO) << "StopRecording";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (!initialized_ || !recording_) {
return 0;
}
if (!aaudio_.Stop()) {
return -1;
}
- thread_checker_aaudio_.DetachFromThread();
+ thread_checker_aaudio_.Detach();
initialized_ = false;
recording_ = false;
return 0;
@@ -101,7 +101,7 @@
void AAudioRecorder::AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) {
RTC_LOG(INFO) << "AttachAudioBuffer";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
audio_device_buffer_ = audioBuffer;
const AudioParameters audio_parameters = aaudio_.audio_parameters();
audio_device_buffer_->SetRecordingSampleRate(audio_parameters.sample_rate());
@@ -133,7 +133,7 @@
void AAudioRecorder::OnErrorCallback(aaudio_result_t error) {
RTC_LOG(LS_ERROR) << "OnErrorCallback: " << AAudio_convertResultToText(error);
- // RTC_DCHECK(thread_checker_aaudio_.CalledOnValidThread());
+ // RTC_DCHECK(thread_checker_aaudio_.IsCurrent());
if (aaudio_.stream_state() == AAUDIO_STREAM_STATE_DISCONNECTED) {
// The stream is disconnected and any attempt to use it will return
// AAUDIO_ERROR_DISCONNECTED..
@@ -153,7 +153,7 @@
void* audio_data,
int32_t num_frames) {
// TODO(henrika): figure out why we sometimes hit this one.
- // RTC_DCHECK(thread_checker_aaudio_.CalledOnValidThread());
+ // RTC_DCHECK(thread_checker_aaudio_.IsCurrent());
// RTC_LOG(INFO) << "OnDataCallback: " << num_frames;
// Drain the input buffer at first callback to ensure that it does not
// contain any old data. Will also ensure that the lowest possible latency
diff --git a/modules/audio_device/android/aaudio_wrapper.cc b/modules/audio_device/android/aaudio_wrapper.cc
index 7e0c9a0..ab12784 100644
--- a/modules/audio_device/android/aaudio_wrapper.cc
+++ b/modules/audio_device/android/aaudio_wrapper.cc
@@ -139,19 +139,19 @@
direction_ == AAUDIO_DIRECTION_OUTPUT
? audio_parameters_ = audio_manager->GetPlayoutAudioParameters()
: audio_parameters_ = audio_manager->GetRecordAudioParameters();
- aaudio_thread_checker_.DetachFromThread();
+ aaudio_thread_checker_.Detach();
RTC_LOG(INFO) << audio_parameters_.ToString();
}
AAudioWrapper::~AAudioWrapper() {
RTC_LOG(INFO) << "dtor";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(!stream_);
}
bool AAudioWrapper::Init() {
RTC_LOG(INFO) << "Init";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
// Creates a stream builder which can be used to open an audio stream.
ScopedStreamBuilder builder;
// Configures the stream builder using audio parameters given at construction.
@@ -175,7 +175,7 @@
bool AAudioWrapper::Start() {
RTC_LOG(INFO) << "Start";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
// TODO(henrika): this state check might not be needed.
aaudio_stream_state_t current_state = AAudioStream_getState(stream_);
if (current_state != AAUDIO_STREAM_STATE_OPEN) {
@@ -191,11 +191,11 @@
bool AAudioWrapper::Stop() {
RTC_LOG(INFO) << "Stop: " << DirectionToString(direction());
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
// Asynchronous request for the stream to stop.
RETURN_ON_ERROR(AAudioStream_requestStop(stream_), false);
CloseStream();
- aaudio_thread_checker_.DetachFromThread();
+ aaudio_thread_checker_.Detach();
return true;
}
@@ -242,7 +242,7 @@
bool AAudioWrapper::IncreaseOutputBufferSize() {
RTC_LOG(INFO) << "IncreaseBufferSize";
RTC_DCHECK(stream_);
- RTC_DCHECK(aaudio_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(aaudio_thread_checker_.IsCurrent());
RTC_DCHECK_EQ(direction(), AAUDIO_DIRECTION_OUTPUT);
aaudio_result_t buffer_size = AAudioStream_getBufferSizeInFrames(stream_);
// Try to increase size of buffer with one burst to reduce risk of underrun.
@@ -270,7 +270,7 @@
void AAudioWrapper::ClearInputStream(void* audio_data, int32_t num_frames) {
RTC_LOG(INFO) << "ClearInputStream";
RTC_DCHECK(stream_);
- RTC_DCHECK(aaudio_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(aaudio_thread_checker_.IsCurrent());
RTC_DCHECK_EQ(direction(), AAUDIO_DIRECTION_INPUT);
aaudio_result_t cleared_frames = 0;
do {
@@ -359,7 +359,7 @@
void AAudioWrapper::SetStreamConfiguration(AAudioStreamBuilder* builder) {
RTC_LOG(INFO) << "SetStreamConfiguration";
RTC_DCHECK(builder);
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
// Request usage of default primary output/input device.
// TODO(henrika): verify that default device follows Java APIs.
// https://developer.android.com/reference/android/media/AudioDeviceInfo.html.
diff --git a/modules/audio_device/android/audio_device_template.h b/modules/audio_device/android/audio_device_template.h
index 9fb72bd..a218504 100644
--- a/modules/audio_device/android/audio_device_template.h
+++ b/modules/audio_device/android/audio_device_template.h
@@ -55,7 +55,7 @@
InitStatus Init() override {
RTC_LOG(INFO) << __FUNCTION__;
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(!initialized_);
if (!audio_manager_->Init()) {
return InitStatus::OTHER_ERROR;
@@ -75,7 +75,7 @@
int32_t Terminate() override {
RTC_LOG(INFO) << __FUNCTION__;
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
int32_t err = input_.Terminate();
err |= output_.Terminate();
err |= !audio_manager_->Close();
@@ -86,7 +86,7 @@
bool Initialized() const override {
RTC_LOG(INFO) << __FUNCTION__;
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
return initialized_;
}
diff --git a/modules/audio_device/android/audio_manager.cc b/modules/audio_device/android/audio_manager.cc
index 7fe09a9..9c2bdd4 100644
--- a/modules/audio_device/android/audio_manager.cc
+++ b/modules/audio_device/android/audio_manager.cc
@@ -84,14 +84,14 @@
AudioManager::~AudioManager() {
RTC_LOG(INFO) << "dtor";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
Close();
}
void AudioManager::SetActiveAudioLayer(
AudioDeviceModule::AudioLayer audio_layer) {
RTC_LOG(INFO) << "SetActiveAudioLayer: " << audio_layer;
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(!initialized_);
// Store the currently utilized audio layer.
audio_layer_ = audio_layer;
@@ -109,7 +109,7 @@
SLObjectItf AudioManager::GetOpenSLEngine() {
RTC_LOG(INFO) << "GetOpenSLEngine";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
// Only allow usage of OpenSL ES if such an audio layer has been specified.
if (audio_layer_ != AudioDeviceModule::kAndroidOpenSLESAudio &&
audio_layer_ !=
@@ -150,7 +150,7 @@
bool AudioManager::Init() {
RTC_LOG(INFO) << "Init";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(!initialized_);
RTC_DCHECK_NE(audio_layer_, AudioDeviceModule::kPlatformDefaultAudio);
if (!j_audio_manager_->Init()) {
@@ -163,7 +163,7 @@
bool AudioManager::Close() {
RTC_LOG(INFO) << "Close";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (!initialized_)
return true;
j_audio_manager_->Close();
@@ -172,27 +172,27 @@
}
bool AudioManager::IsCommunicationModeEnabled() const {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
return j_audio_manager_->IsCommunicationModeEnabled();
}
bool AudioManager::IsAcousticEchoCancelerSupported() const {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
return hardware_aec_;
}
bool AudioManager::IsAutomaticGainControlSupported() const {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
return hardware_agc_;
}
bool AudioManager::IsNoiseSuppressorSupported() const {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
return hardware_ns_;
}
bool AudioManager::IsLowLatencyPlayoutSupported() const {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
// Some devices are blacklisted for usage of OpenSL ES even if they report
// that low-latency playout is supported. See b/21485703 for details.
return j_audio_manager_->IsDeviceBlacklistedForOpenSLESUsage()
@@ -201,12 +201,12 @@
}
bool AudioManager::IsLowLatencyRecordSupported() const {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
return low_latency_record_;
}
bool AudioManager::IsProAudioSupported() const {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
// TODO(henrika): return the state independently of if OpenSL ES is
// blacklisted or not for now. We could use the same approach as in
// IsLowLatencyPlayoutSupported() but I can't see the need for it yet.
@@ -223,12 +223,12 @@
}
bool AudioManager::IsStereoPlayoutSupported() const {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
return (playout_parameters_.channels() == 2);
}
bool AudioManager::IsStereoRecordSupported() const {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
return (record_parameters_.channels() == 2);
}
@@ -287,7 +287,7 @@
<< ", input_channels: " << static_cast<int>(input_channels)
<< ", output_buffer_size: " << static_cast<int>(output_buffer_size)
<< ", input_buffer_size: " << static_cast<int>(input_buffer_size);
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
hardware_aec_ = hardware_aec;
hardware_agc_ = hardware_agc;
hardware_ns_ = hardware_ns;
@@ -303,13 +303,13 @@
const AudioParameters& AudioManager::GetPlayoutAudioParameters() {
RTC_CHECK(playout_parameters_.is_valid());
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
return playout_parameters_;
}
const AudioParameters& AudioManager::GetRecordAudioParameters() {
RTC_CHECK(record_parameters_.is_valid());
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
return record_parameters_;
}
diff --git a/modules/audio_device/android/audio_manager.h b/modules/audio_device/android/audio_manager.h
index 685603d..d1debdb 100644
--- a/modules/audio_device/android/audio_manager.h
+++ b/modules/audio_device/android/audio_manager.h
@@ -158,7 +158,7 @@
jint input_buffer_size);
// Stores thread ID in the constructor.
- // We can then use ThreadChecker::CalledOnValidThread() to ensure that
+ // We can then use ThreadChecker::IsCurrent() to ensure that
// other methods are called from the same thread.
rtc::ThreadChecker thread_checker_;
diff --git a/modules/audio_device/android/audio_record_jni.cc b/modules/audio_device/android/audio_record_jni.cc
index 9205489..12ac458 100644
--- a/modules/audio_device/android/audio_record_jni.cc
+++ b/modules/audio_device/android/audio_record_jni.cc
@@ -111,31 +111,31 @@
"<init>", "(J)V", PointerTojlong(this))));
// Detach from this thread since we want to use the checker to verify calls
// from the Java based audio thread.
- thread_checker_java_.DetachFromThread();
+ thread_checker_java_.Detach();
}
AudioRecordJni::~AudioRecordJni() {
RTC_LOG(INFO) << "dtor";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
Terminate();
}
int32_t AudioRecordJni::Init() {
RTC_LOG(INFO) << "Init";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
return 0;
}
int32_t AudioRecordJni::Terminate() {
RTC_LOG(INFO) << "Terminate";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
StopRecording();
return 0;
}
int32_t AudioRecordJni::InitRecording() {
RTC_LOG(INFO) << "InitRecording";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(!initialized_);
RTC_DCHECK(!recording_);
ScopedHistogramTimer timer("WebRTC.Audio.InitRecordingDurationMs");
@@ -158,7 +158,7 @@
int32_t AudioRecordJni::StartRecording() {
RTC_LOG(INFO) << "StartRecording";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(!recording_);
if (!initialized_) {
RTC_DLOG(LS_WARNING)
@@ -176,7 +176,7 @@
int32_t AudioRecordJni::StopRecording() {
RTC_LOG(INFO) << "StopRecording";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (!initialized_ || !recording_) {
return 0;
}
@@ -187,7 +187,7 @@
// If we don't detach here, we will hit a RTC_DCHECK in OnDataIsRecorded()
// next time StartRecording() is called since it will create a new Java
// thread.
- thread_checker_java_.DetachFromThread();
+ thread_checker_java_.Detach();
initialized_ = false;
recording_ = false;
direct_buffer_address_ = nullptr;
@@ -196,7 +196,7 @@
void AudioRecordJni::AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) {
RTC_LOG(INFO) << "AttachAudioBuffer";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
audio_device_buffer_ = audioBuffer;
const int sample_rate_hz = audio_parameters_.sample_rate();
RTC_LOG(INFO) << "SetRecordingSampleRate(" << sample_rate_hz << ")";
@@ -213,7 +213,7 @@
int32_t AudioRecordJni::EnableBuiltInAEC(bool enable) {
RTC_LOG(INFO) << "EnableBuiltInAEC(" << enable << ")";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
return j_audio_record_->EnableBuiltInAEC(enable) ? 0 : -1;
}
@@ -225,7 +225,7 @@
int32_t AudioRecordJni::EnableBuiltInNS(bool enable) {
RTC_LOG(INFO) << "EnableBuiltInNS(" << enable << ")";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
return j_audio_record_->EnableBuiltInNS(enable) ? 0 : -1;
}
@@ -242,7 +242,7 @@
void AudioRecordJni::OnCacheDirectBufferAddress(JNIEnv* env,
jobject byte_buffer) {
RTC_LOG(INFO) << "OnCacheDirectBufferAddress";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(!direct_buffer_address_);
direct_buffer_address_ = env->GetDirectBufferAddress(byte_buffer);
jlong capacity = env->GetDirectBufferCapacity(byte_buffer);
@@ -263,7 +263,7 @@
// This method is called on a high-priority thread from Java. The name of
// the thread is 'AudioRecordThread'.
void AudioRecordJni::OnDataIsRecorded(int length) {
- RTC_DCHECK(thread_checker_java_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_java_.IsCurrent());
if (!audio_device_buffer_) {
RTC_LOG(LS_ERROR) << "AttachAudioBuffer has not been called";
return;
diff --git a/modules/audio_device/android/audio_track_jni.cc b/modules/audio_device/android/audio_track_jni.cc
index b0e5ddf..592d01b 100644
--- a/modules/audio_device/android/audio_track_jni.cc
+++ b/modules/audio_device/android/audio_track_jni.cc
@@ -88,31 +88,31 @@
"<init>", "(J)V", PointerTojlong(this))));
// Detach from this thread since we want to use the checker to verify calls
// from the Java based audio thread.
- thread_checker_java_.DetachFromThread();
+ thread_checker_java_.Detach();
}
AudioTrackJni::~AudioTrackJni() {
RTC_LOG(INFO) << "dtor";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
Terminate();
}
int32_t AudioTrackJni::Init() {
RTC_LOG(INFO) << "Init";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
return 0;
}
int32_t AudioTrackJni::Terminate() {
RTC_LOG(INFO) << "Terminate";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
StopPlayout();
return 0;
}
int32_t AudioTrackJni::InitPlayout() {
RTC_LOG(INFO) << "InitPlayout";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(!initialized_);
RTC_DCHECK(!playing_);
if (!j_audio_track_->InitPlayout(audio_parameters_.sample_rate(),
@@ -126,7 +126,7 @@
int32_t AudioTrackJni::StartPlayout() {
RTC_LOG(INFO) << "StartPlayout";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(!playing_);
if (!initialized_) {
RTC_DLOG(LS_WARNING)
@@ -143,7 +143,7 @@
int32_t AudioTrackJni::StopPlayout() {
RTC_LOG(INFO) << "StopPlayout";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (!initialized_ || !playing_) {
return 0;
}
@@ -154,7 +154,7 @@
// If we don't detach here, we will hit a RTC_DCHECK in OnDataIsRecorded()
// next time StartRecording() is called since it will create a new Java
// thread.
- thread_checker_java_.DetachFromThread();
+ thread_checker_java_.Detach();
initialized_ = false;
playing_ = false;
direct_buffer_address_ = nullptr;
@@ -168,24 +168,24 @@
int AudioTrackJni::SetSpeakerVolume(uint32_t volume) {
RTC_LOG(INFO) << "SetSpeakerVolume(" << volume << ")";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
return j_audio_track_->SetStreamVolume(volume) ? 0 : -1;
}
int AudioTrackJni::MaxSpeakerVolume(uint32_t& max_volume) const {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
max_volume = j_audio_track_->GetStreamMaxVolume();
return 0;
}
int AudioTrackJni::MinSpeakerVolume(uint32_t& min_volume) const {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
min_volume = 0;
return 0;
}
int AudioTrackJni::SpeakerVolume(uint32_t& volume) const {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
volume = j_audio_track_->GetStreamVolume();
RTC_LOG(INFO) << "SpeakerVolume: " << volume;
return 0;
@@ -194,7 +194,7 @@
// TODO(henrika): possibly add stereo support.
void AudioTrackJni::AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) {
RTC_LOG(INFO) << "AttachAudioBuffer";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
audio_device_buffer_ = audioBuffer;
const int sample_rate_hz = audio_parameters_.sample_rate();
RTC_LOG(INFO) << "SetPlayoutSampleRate(" << sample_rate_hz << ")";
@@ -217,7 +217,7 @@
void AudioTrackJni::OnCacheDirectBufferAddress(JNIEnv* env,
jobject byte_buffer) {
RTC_LOG(INFO) << "OnCacheDirectBufferAddress";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(!direct_buffer_address_);
direct_buffer_address_ = env->GetDirectBufferAddress(byte_buffer);
jlong capacity = env->GetDirectBufferCapacity(byte_buffer);
@@ -241,7 +241,7 @@
// This method is called on a high-priority thread from Java. The name of
// the thread is 'AudioRecordTrack'.
void AudioTrackJni::OnGetPlayoutData(size_t length) {
- RTC_DCHECK(thread_checker_java_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_java_.IsCurrent());
const size_t bytes_per_frame = audio_parameters_.channels() * sizeof(int16_t);
RTC_DCHECK_EQ(frames_per_buffer_, length / bytes_per_frame);
if (!audio_device_buffer_) {
diff --git a/modules/audio_device/android/opensles_player.cc b/modules/audio_device/android/opensles_player.cc
index 921ffd2..509e51a 100644
--- a/modules/audio_device/android/opensles_player.cc
+++ b/modules/audio_device/android/opensles_player.cc
@@ -61,12 +61,12 @@
audio_parameters_.bits_per_sample());
// Detach from this thread since we want to use the checker to verify calls
// from the internal audio thread.
- thread_checker_opensles_.DetachFromThread();
+ thread_checker_opensles_.Detach();
}
OpenSLESPlayer::~OpenSLESPlayer() {
ALOGD("dtor[tid=%d]", rtc::CurrentThreadId());
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
Terminate();
DestroyAudioPlayer();
DestroyMix();
@@ -80,7 +80,7 @@
int OpenSLESPlayer::Init() {
ALOGD("Init[tid=%d]", rtc::CurrentThreadId());
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (audio_parameters_.channels() == 2) {
ALOGW("Stereo mode is enabled");
}
@@ -89,14 +89,14 @@
int OpenSLESPlayer::Terminate() {
ALOGD("Terminate[tid=%d]", rtc::CurrentThreadId());
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
StopPlayout();
return 0;
}
int OpenSLESPlayer::InitPlayout() {
ALOGD("InitPlayout[tid=%d]", rtc::CurrentThreadId());
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(!initialized_);
RTC_DCHECK(!playing_);
if (!ObtainEngineInterface()) {
@@ -111,7 +111,7 @@
int OpenSLESPlayer::StartPlayout() {
ALOGD("StartPlayout[tid=%d]", rtc::CurrentThreadId());
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(initialized_);
RTC_DCHECK(!playing_);
if (fine_audio_buffer_) {
@@ -139,7 +139,7 @@
int OpenSLESPlayer::StopPlayout() {
ALOGD("StopPlayout[tid=%d]", rtc::CurrentThreadId());
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (!initialized_ || !playing_) {
return 0;
}
@@ -157,7 +157,7 @@
// The number of lower latency audio players is limited, hence we create the
// audio player in Start() and destroy it in Stop().
DestroyAudioPlayer();
- thread_checker_opensles_.DetachFromThread();
+ thread_checker_opensles_.Detach();
initialized_ = false;
playing_ = false;
return 0;
@@ -186,7 +186,7 @@
void OpenSLESPlayer::AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) {
ALOGD("AttachAudioBuffer");
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
audio_device_buffer_ = audioBuffer;
const int sample_rate_hz = audio_parameters_.sample_rate();
ALOGD("SetPlayoutSampleRate(%d)", sample_rate_hz);
@@ -200,7 +200,7 @@
void OpenSLESPlayer::AllocateDataBuffers() {
ALOGD("AllocateDataBuffers");
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(!simple_buffer_queue_);
RTC_CHECK(audio_device_buffer_);
// Create a modified audio buffer class which allows us to ask for any number
@@ -225,7 +225,7 @@
bool OpenSLESPlayer::ObtainEngineInterface() {
ALOGD("ObtainEngineInterface");
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (engine_)
return true;
// Get access to (or create if not already existing) the global OpenSL Engine
@@ -244,7 +244,7 @@
bool OpenSLESPlayer::CreateMix() {
ALOGD("CreateMix");
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(engine_);
if (output_mix_.Get())
return true;
@@ -260,7 +260,7 @@
void OpenSLESPlayer::DestroyMix() {
ALOGD("DestroyMix");
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (!output_mix_.Get())
return;
output_mix_.Reset();
@@ -268,7 +268,7 @@
bool OpenSLESPlayer::CreateAudioPlayer() {
ALOGD("CreateAudioPlayer");
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(output_mix_.Get());
if (player_object_.Get())
return true;
@@ -352,7 +352,7 @@
void OpenSLESPlayer::DestroyAudioPlayer() {
ALOGD("DestroyAudioPlayer");
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (!player_object_.Get())
return;
(*simple_buffer_queue_)
@@ -372,7 +372,7 @@
}
void OpenSLESPlayer::FillBufferQueue() {
- RTC_DCHECK(thread_checker_opensles_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_opensles_.IsCurrent());
SLuint32 state = GetPlayState();
if (state != SL_PLAYSTATE_PLAYING) {
ALOGW("Buffer callback in non-playing state!");
@@ -394,13 +394,13 @@
SLint8* audio_ptr8 =
reinterpret_cast<SLint8*>(audio_buffers_[buffer_index_].get());
if (silence) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
// Avoid acquiring real audio data from WebRTC and fill the buffer with
// zeros instead. Used to prime the buffer with silence and to avoid asking
// for audio data from two different threads.
memset(audio_ptr8, 0, audio_parameters_.GetBytesPerBuffer());
} else {
- RTC_DCHECK(thread_checker_opensles_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_opensles_.IsCurrent());
// Read audio data from the WebRTC source using the FineAudioBuffer object
// to adjust for differences in buffer size between WebRTC (10ms) and native
// OpenSL ES. Use hardcoded delay estimate since OpenSL ES does not support
diff --git a/modules/audio_device/android/opensles_recorder.cc b/modules/audio_device/android/opensles_recorder.cc
index 2d5dbb9..ed81561 100644
--- a/modules/audio_device/android/opensles_recorder.cc
+++ b/modules/audio_device/android/opensles_recorder.cc
@@ -56,7 +56,7 @@
ALOGD("ctor[tid=%d]", rtc::CurrentThreadId());
// Detach from this thread since we want to use the checker to verify calls
// from the internal audio thread.
- thread_checker_opensles_.DetachFromThread();
+ thread_checker_opensles_.Detach();
// Use native audio output parameters provided by the audio manager and
// define the PCM format structure.
pcm_format_ = CreatePCMConfiguration(audio_parameters_.channels(),
@@ -66,7 +66,7 @@
OpenSLESRecorder::~OpenSLESRecorder() {
ALOGD("dtor[tid=%d]", rtc::CurrentThreadId());
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
Terminate();
DestroyAudioRecorder();
engine_ = nullptr;
@@ -77,7 +77,7 @@
int OpenSLESRecorder::Init() {
ALOGD("Init[tid=%d]", rtc::CurrentThreadId());
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (audio_parameters_.channels() == 2) {
ALOGD("Stereo mode is enabled");
}
@@ -86,14 +86,14 @@
int OpenSLESRecorder::Terminate() {
ALOGD("Terminate[tid=%d]", rtc::CurrentThreadId());
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
StopRecording();
return 0;
}
int OpenSLESRecorder::InitRecording() {
ALOGD("InitRecording[tid=%d]", rtc::CurrentThreadId());
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(!initialized_);
RTC_DCHECK(!recording_);
if (!ObtainEngineInterface()) {
@@ -108,7 +108,7 @@
int OpenSLESRecorder::StartRecording() {
ALOGD("StartRecording[tid=%d]", rtc::CurrentThreadId());
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(initialized_);
RTC_DCHECK(!recording_);
if (fine_audio_buffer_) {
@@ -145,7 +145,7 @@
int OpenSLESRecorder::StopRecording() {
ALOGD("StopRecording[tid=%d]", rtc::CurrentThreadId());
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (!initialized_ || !recording_) {
return 0;
}
@@ -158,7 +158,7 @@
if (LOG_ON_ERROR((*simple_buffer_queue_)->Clear(simple_buffer_queue_))) {
return -1;
}
- thread_checker_opensles_.DetachFromThread();
+ thread_checker_opensles_.Detach();
initialized_ = false;
recording_ = false;
return 0;
@@ -166,7 +166,7 @@
void OpenSLESRecorder::AttachAudioBuffer(AudioDeviceBuffer* audio_buffer) {
ALOGD("AttachAudioBuffer");
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_CHECK(audio_buffer);
audio_device_buffer_ = audio_buffer;
// Ensure that the audio device buffer is informed about the native sample
@@ -185,28 +185,28 @@
int OpenSLESRecorder::EnableBuiltInAEC(bool enable) {
ALOGD("EnableBuiltInAEC(%d)", enable);
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
ALOGE("Not implemented");
return 0;
}
int OpenSLESRecorder::EnableBuiltInAGC(bool enable) {
ALOGD("EnableBuiltInAGC(%d)", enable);
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
ALOGE("Not implemented");
return 0;
}
int OpenSLESRecorder::EnableBuiltInNS(bool enable) {
ALOGD("EnableBuiltInNS(%d)", enable);
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
ALOGE("Not implemented");
return 0;
}
bool OpenSLESRecorder::ObtainEngineInterface() {
ALOGD("ObtainEngineInterface");
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (engine_)
return true;
// Get access to (or create if not already existing) the global OpenSL Engine
@@ -227,7 +227,7 @@
bool OpenSLESRecorder::CreateAudioRecorder() {
ALOGD("CreateAudioRecorder");
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (recorder_object_.Get())
return true;
RTC_DCHECK(!recorder_);
@@ -308,7 +308,7 @@
void OpenSLESRecorder::DestroyAudioRecorder() {
ALOGD("DestroyAudioRecorder");
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (!recorder_object_.Get())
return;
(*simple_buffer_queue_)
@@ -327,7 +327,7 @@
void OpenSLESRecorder::AllocateDataBuffers() {
ALOGD("AllocateDataBuffers");
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(!simple_buffer_queue_);
RTC_CHECK(audio_device_buffer_);
// Create a modified audio buffer class which allows us to deliver any number
@@ -352,7 +352,7 @@
}
void OpenSLESRecorder::ReadBufferQueue() {
- RTC_DCHECK(thread_checker_opensles_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_opensles_.IsCurrent());
SLuint32 state = GetRecordState();
if (state != SL_RECORDSTATE_RECORDING) {
ALOGW("Buffer callback in non-recording state!");
diff --git a/modules/audio_device/audio_device_unittest.cc b/modules/audio_device/audio_device_unittest.cc
index 0c842b6..7fd00c4 100644
--- a/modules/audio_device/audio_device_unittest.cc
+++ b/modules/audio_device/audio_device_unittest.cc
@@ -223,8 +223,8 @@
LatencyAudioStream() {
// Delay thread checkers from being initialized until first callback from
// respective thread.
- read_thread_checker_.DetachFromThread();
- write_thread_checker_.DetachFromThread();
+ read_thread_checker_.Detach();
+ write_thread_checker_.Detach();
}
// Insert periodic impulses in first two samples of |destination|.
diff --git a/modules/audio_device/ios/audio_device_ios.mm b/modules/audio_device/ios/audio_device_ios.mm
index 8fa34d1..2c3140a 100644
--- a/modules/audio_device/ios/audio_device_ios.mm
+++ b/modules/audio_device/ios/audio_device_ios.mm
@@ -113,7 +113,7 @@
num_playout_callbacks_(0),
last_output_volume_change_time_(0) {
LOGI() << "ctor" << ios::GetCurrentThreadDescription();
- io_thread_checker_.DetachFromThread();
+ io_thread_checker_.Detach();
thread_ = rtc::Thread::Current();
audio_session_observer_ = [[RTCAudioSessionDelegateAdapter alloc] initWithObserver:this];
}
@@ -121,14 +121,14 @@
AudioDeviceIOS::~AudioDeviceIOS() {
LOGI() << "~dtor" << ios::GetCurrentThreadDescription();
audio_session_observer_ = nil;
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
Terminate();
}
void AudioDeviceIOS::AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) {
LOGI() << "AttachAudioBuffer";
RTC_DCHECK(audioBuffer);
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
audio_device_buffer_ = audioBuffer;
}
@@ -307,7 +307,7 @@
int AudioDeviceIOS::GetPlayoutAudioParameters(AudioParameters* params) const {
LOGI() << "GetPlayoutAudioParameters";
RTC_DCHECK(playout_parameters_.is_valid());
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
*params = playout_parameters_;
return 0;
}
@@ -315,7 +315,7 @@
int AudioDeviceIOS::GetRecordAudioParameters(AudioParameters* params) const {
LOGI() << "GetRecordAudioParameters";
RTC_DCHECK(record_parameters_.is_valid());
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
*params = record_parameters_;
return 0;
}
@@ -882,7 +882,7 @@
// Detach thread checker for the AURemoteIO::IOThread to ensure that the
// next session uses a fresh thread id.
- io_thread_checker_.DetachFromThread();
+ io_thread_checker_.Detach();
// Remove audio session notification observers.
RTCAudioSession* session = [RTCAudioSession sharedInstance];
@@ -902,7 +902,7 @@
// restart. It will result in audio callbacks from a new native I/O thread
// which means that we must detach thread checkers here to be prepared for an
// upcoming new audio stream.
- io_thread_checker_.DetachFromThread();
+ io_thread_checker_.Detach();
}
} // namespace webrtc
diff --git a/modules/audio_device/linux/audio_device_pulse_linux.cc b/modules/audio_device/linux/audio_device_pulse_linux.cc
index 3706d91..c29ef8b 100644
--- a/modules/audio_device/linux/audio_device_pulse_linux.cc
+++ b/modules/audio_device/linux/audio_device_pulse_linux.cc
@@ -89,7 +89,7 @@
AudioDeviceLinuxPulse::~AudioDeviceLinuxPulse() {
RTC_LOG(LS_INFO) << __FUNCTION__ << " destroyed";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
Terminate();
if (_recBuffer) {
@@ -111,7 +111,7 @@
}
void AudioDeviceLinuxPulse::AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
_ptrAudioBuffer = audioBuffer;
@@ -135,7 +135,7 @@
}
AudioDeviceGeneric::InitStatus AudioDeviceLinuxPulse::Init() {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (_initialized) {
return InitStatus::OK;
}
@@ -177,7 +177,7 @@
}
int32_t AudioDeviceLinuxPulse::Terminate() {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (!_initialized) {
return 0;
}
@@ -223,12 +223,12 @@
}
bool AudioDeviceLinuxPulse::Initialized() const {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
return (_initialized);
}
int32_t AudioDeviceLinuxPulse::InitSpeaker() {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (_playing) {
return -1;
@@ -266,7 +266,7 @@
}
int32_t AudioDeviceLinuxPulse::InitMicrophone() {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (_recording) {
return -1;
}
@@ -303,17 +303,17 @@
}
bool AudioDeviceLinuxPulse::SpeakerIsInitialized() const {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
return (_mixerManager.SpeakerIsInitialized());
}
bool AudioDeviceLinuxPulse::MicrophoneIsInitialized() const {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
return (_mixerManager.MicrophoneIsInitialized());
}
int32_t AudioDeviceLinuxPulse::SpeakerVolumeIsAvailable(bool& available) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
bool wasInitialized = _mixerManager.SpeakerIsInitialized();
// Make an attempt to open up the
@@ -337,7 +337,7 @@
}
int32_t AudioDeviceLinuxPulse::SetSpeakerVolume(uint32_t volume) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (!_playing) {
// Only update the volume if it's been set while we weren't playing.
update_speaker_volume_at_startup_ = true;
@@ -346,7 +346,7 @@
}
int32_t AudioDeviceLinuxPulse::SpeakerVolume(uint32_t& volume) const {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
uint32_t level(0);
if (_mixerManager.SpeakerVolume(level) == -1) {
@@ -359,7 +359,7 @@
}
int32_t AudioDeviceLinuxPulse::MaxSpeakerVolume(uint32_t& maxVolume) const {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
uint32_t maxVol(0);
if (_mixerManager.MaxSpeakerVolume(maxVol) == -1) {
@@ -372,7 +372,7 @@
}
int32_t AudioDeviceLinuxPulse::MinSpeakerVolume(uint32_t& minVolume) const {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
uint32_t minVol(0);
if (_mixerManager.MinSpeakerVolume(minVol) == -1) {
@@ -385,7 +385,7 @@
}
int32_t AudioDeviceLinuxPulse::SpeakerMuteIsAvailable(bool& available) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
bool isAvailable(false);
bool wasInitialized = _mixerManager.SpeakerIsInitialized();
@@ -414,12 +414,12 @@
}
int32_t AudioDeviceLinuxPulse::SetSpeakerMute(bool enable) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
return (_mixerManager.SetSpeakerMute(enable));
}
int32_t AudioDeviceLinuxPulse::SpeakerMute(bool& enabled) const {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
bool muted(0);
if (_mixerManager.SpeakerMute(muted) == -1) {
return -1;
@@ -430,7 +430,7 @@
}
int32_t AudioDeviceLinuxPulse::MicrophoneMuteIsAvailable(bool& available) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
bool isAvailable(false);
bool wasInitialized = _mixerManager.MicrophoneIsInitialized();
@@ -460,12 +460,12 @@
}
int32_t AudioDeviceLinuxPulse::SetMicrophoneMute(bool enable) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
return (_mixerManager.SetMicrophoneMute(enable));
}
int32_t AudioDeviceLinuxPulse::MicrophoneMute(bool& enabled) const {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
bool muted(0);
if (_mixerManager.MicrophoneMute(muted) == -1) {
return -1;
@@ -476,7 +476,7 @@
}
int32_t AudioDeviceLinuxPulse::StereoRecordingIsAvailable(bool& available) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (_recChannels == 2 && _recording) {
available = true;
return 0;
@@ -507,7 +507,7 @@
}
int32_t AudioDeviceLinuxPulse::SetStereoRecording(bool enable) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (enable)
_recChannels = 2;
else
@@ -517,7 +517,7 @@
}
int32_t AudioDeviceLinuxPulse::StereoRecording(bool& enabled) const {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (_recChannels == 2)
enabled = true;
else
@@ -527,7 +527,7 @@
}
int32_t AudioDeviceLinuxPulse::StereoPlayoutIsAvailable(bool& available) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (_playChannels == 2 && _playing) {
available = true;
return 0;
@@ -557,7 +557,7 @@
}
int32_t AudioDeviceLinuxPulse::SetStereoPlayout(bool enable) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (enable)
_playChannels = 2;
else
@@ -567,7 +567,7 @@
}
int32_t AudioDeviceLinuxPulse::StereoPlayout(bool& enabled) const {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (_playChannels == 2)
enabled = true;
else
@@ -577,7 +577,7 @@
}
int32_t AudioDeviceLinuxPulse::MicrophoneVolumeIsAvailable(bool& available) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
bool wasInitialized = _mixerManager.MicrophoneIsInitialized();
// Make an attempt to open up the
@@ -660,7 +660,7 @@
}
int32_t AudioDeviceLinuxPulse::SetPlayoutDevice(uint16_t index) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (_playIsInitialized) {
return -1;
}
@@ -691,7 +691,7 @@
uint16_t index,
char name[kAdmMaxDeviceNameSize],
char guid[kAdmMaxGuidSize]) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
const uint16_t nDevices = PlayoutDevices();
if ((index > (nDevices - 1)) || (name == NULL)) {
@@ -729,7 +729,7 @@
uint16_t index,
char name[kAdmMaxDeviceNameSize],
char guid[kAdmMaxGuidSize]) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
const uint16_t nDevices(RecordingDevices());
if ((index > (nDevices - 1)) || (name == NULL)) {
@@ -781,7 +781,7 @@
}
int32_t AudioDeviceLinuxPulse::SetRecordingDevice(uint16_t index) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (_recIsInitialized) {
return -1;
}
@@ -809,7 +809,7 @@
}
int32_t AudioDeviceLinuxPulse::PlayoutIsAvailable(bool& available) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
available = false;
// Try to initialize the playout side
@@ -826,7 +826,7 @@
}
int32_t AudioDeviceLinuxPulse::RecordingIsAvailable(bool& available) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
available = false;
// Try to initialize the playout side
@@ -843,7 +843,7 @@
}
int32_t AudioDeviceLinuxPulse::InitPlayout() {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (_playing) {
return -1;
@@ -947,7 +947,7 @@
}
int32_t AudioDeviceLinuxPulse::InitRecording() {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (_recording) {
return -1;
@@ -1043,7 +1043,7 @@
}
int32_t AudioDeviceLinuxPulse::StartRecording() {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (!_recIsInitialized) {
return -1;
}
@@ -1082,7 +1082,7 @@
}
int32_t AudioDeviceLinuxPulse::StopRecording() {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
rtc::CritScope lock(&_critSect);
if (!_recIsInitialized) {
@@ -1136,22 +1136,22 @@
}
bool AudioDeviceLinuxPulse::RecordingIsInitialized() const {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
return (_recIsInitialized);
}
bool AudioDeviceLinuxPulse::Recording() const {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
return (_recording);
}
bool AudioDeviceLinuxPulse::PlayoutIsInitialized() const {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
return (_playIsInitialized);
}
int32_t AudioDeviceLinuxPulse::StartPlayout() {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (!_playIsInitialized) {
return -1;
@@ -1197,7 +1197,7 @@
}
int32_t AudioDeviceLinuxPulse::StopPlayout() {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
rtc::CritScope lock(&_critSect);
if (!_playIsInitialized) {
@@ -1259,7 +1259,7 @@
}
bool AudioDeviceLinuxPulse::Playing() const {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
return (_playing);
}
diff --git a/modules/audio_device/linux/audio_device_pulse_linux.h b/modules/audio_device/linux/audio_device_pulse_linux.h
index 367d657..c610892 100644
--- a/modules/audio_device/linux/audio_device_pulse_linux.h
+++ b/modules/audio_device/linux/audio_device_pulse_linux.h
@@ -283,9 +283,9 @@
uint8_t _playChannels;
// Stores thread ID in constructor.
- // We can then use ThreadChecker::CalledOnValidThread() to ensure that
+ // We can then use ThreadChecker::IsCurrent() to ensure that
// other methods are called from the same thread.
- // Currently only does RTC_DCHECK(thread_checker_.CalledOnValidThread()).
+ // Currently only does RTC_DCHECK(thread_checker_.IsCurrent()).
rtc::ThreadChecker thread_checker_;
bool _initialized;
diff --git a/modules/audio_device/linux/audio_mixer_manager_pulse_linux.cc b/modules/audio_device/linux/audio_mixer_manager_pulse_linux.cc
index 22e1040..45b1275 100644
--- a/modules/audio_device/linux/audio_mixer_manager_pulse_linux.cc
+++ b/modules/audio_device/linux/audio_mixer_manager_pulse_linux.cc
@@ -57,7 +57,7 @@
}
AudioMixerManagerLinuxPulse::~AudioMixerManagerLinuxPulse() {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_LOG(LS_INFO) << __FUNCTION__ << " destroyed";
Close();
@@ -70,7 +70,7 @@
int32_t AudioMixerManagerLinuxPulse::SetPulseAudioObjects(
pa_threaded_mainloop* mainloop,
pa_context* context) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_LOG(LS_VERBOSE) << __FUNCTION__;
if (!mainloop || !context) {
@@ -88,7 +88,7 @@
}
int32_t AudioMixerManagerLinuxPulse::Close() {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_LOG(LS_VERBOSE) << __FUNCTION__;
CloseSpeaker();
@@ -102,7 +102,7 @@
}
int32_t AudioMixerManagerLinuxPulse::CloseSpeaker() {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_LOG(LS_VERBOSE) << __FUNCTION__;
// Reset the index to -1
@@ -113,7 +113,7 @@
}
int32_t AudioMixerManagerLinuxPulse::CloseMicrophone() {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_LOG(LS_VERBOSE) << __FUNCTION__;
// Reset the index to -1
@@ -124,7 +124,7 @@
}
int32_t AudioMixerManagerLinuxPulse::SetPlayStream(pa_stream* playStream) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_LOG(LS_VERBOSE)
<< "AudioMixerManagerLinuxPulse::SetPlayStream(playStream)";
@@ -133,7 +133,7 @@
}
int32_t AudioMixerManagerLinuxPulse::SetRecStream(pa_stream* recStream) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_LOG(LS_VERBOSE) << "AudioMixerManagerLinuxPulse::SetRecStream(recStream)";
_paRecStream = recStream;
@@ -141,7 +141,7 @@
}
int32_t AudioMixerManagerLinuxPulse::OpenSpeaker(uint16_t deviceIndex) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_LOG(LS_VERBOSE) << "AudioMixerManagerLinuxPulse::OpenSpeaker(deviceIndex="
<< deviceIndex << ")";
@@ -162,7 +162,7 @@
}
int32_t AudioMixerManagerLinuxPulse::OpenMicrophone(uint16_t deviceIndex) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_LOG(LS_VERBOSE)
<< "AudioMixerManagerLinuxPulse::OpenMicrophone(deviceIndex="
<< deviceIndex << ")";
@@ -184,21 +184,21 @@
}
bool AudioMixerManagerLinuxPulse::SpeakerIsInitialized() const {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_LOG(LS_INFO) << __FUNCTION__;
return (_paOutputDeviceIndex != -1);
}
bool AudioMixerManagerLinuxPulse::MicrophoneIsInitialized() const {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_LOG(LS_INFO) << __FUNCTION__;
return (_paInputDeviceIndex != -1);
}
int32_t AudioMixerManagerLinuxPulse::SetSpeakerVolume(uint32_t volume) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_LOG(LS_VERBOSE) << "AudioMixerManagerLinuxPulse::SetSpeakerVolume(volume="
<< volume << ")";
@@ -303,7 +303,7 @@
}
int32_t AudioMixerManagerLinuxPulse::SpeakerVolumeIsAvailable(bool& available) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (_paOutputDeviceIndex == -1) {
RTC_LOG(LS_WARNING) << "output device index has not been set";
return -1;
@@ -316,7 +316,7 @@
}
int32_t AudioMixerManagerLinuxPulse::SpeakerMuteIsAvailable(bool& available) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (_paOutputDeviceIndex == -1) {
RTC_LOG(LS_WARNING) << "output device index has not been set";
return -1;
@@ -329,7 +329,7 @@
}
int32_t AudioMixerManagerLinuxPulse::SetSpeakerMute(bool enable) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_LOG(LS_VERBOSE) << "AudioMixerManagerLinuxPulse::SetSpeakerMute(enable="
<< enable << ")";
@@ -393,7 +393,7 @@
}
int32_t AudioMixerManagerLinuxPulse::StereoPlayoutIsAvailable(bool& available) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (_paOutputDeviceIndex == -1) {
RTC_LOG(LS_WARNING) << "output device index has not been set";
return -1;
@@ -423,7 +423,7 @@
int32_t AudioMixerManagerLinuxPulse::StereoRecordingIsAvailable(
bool& available) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (_paInputDeviceIndex == -1) {
RTC_LOG(LS_WARNING) << "input device index has not been set";
return -1;
@@ -461,7 +461,7 @@
int32_t AudioMixerManagerLinuxPulse::MicrophoneMuteIsAvailable(
bool& available) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (_paInputDeviceIndex == -1) {
RTC_LOG(LS_WARNING) << "input device index has not been set";
return -1;
@@ -474,7 +474,7 @@
}
int32_t AudioMixerManagerLinuxPulse::SetMicrophoneMute(bool enable) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_LOG(LS_VERBOSE)
<< "AudioMixerManagerLinuxPulse::SetMicrophoneMute(enable=" << enable
<< ")";
@@ -520,7 +520,7 @@
}
int32_t AudioMixerManagerLinuxPulse::MicrophoneMute(bool& enabled) const {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (_paInputDeviceIndex == -1) {
RTC_LOG(LS_WARNING) << "input device index has not been set";
return -1;
@@ -552,7 +552,7 @@
int32_t AudioMixerManagerLinuxPulse::MicrophoneVolumeIsAvailable(
bool& available) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (_paInputDeviceIndex == -1) {
RTC_LOG(LS_WARNING) << "input device index has not been set";
return -1;
diff --git a/modules/audio_device/linux/audio_mixer_manager_pulse_linux.h b/modules/audio_device/linux/audio_mixer_manager_pulse_linux.h
index 679d1b4..f2f3e48 100644
--- a/modules/audio_device/linux/audio_mixer_manager_pulse_linux.h
+++ b/modules/audio_device/linux/audio_mixer_manager_pulse_linux.h
@@ -103,9 +103,9 @@
bool _paObjectsSet;
// Stores thread ID in constructor.
- // We can then use ThreadChecker::CalledOnValidThread() to ensure that
+ // We can then use ThreadChecker::IsCurrent() to ensure that
// other methods are called from the same thread.
- // Currently only does RTC_DCHECK(thread_checker_.CalledOnValidThread()).
+ // Currently only does RTC_DCHECK(thread_checker_.IsCurrent()).
rtc::ThreadChecker thread_checker_;
};
diff --git a/modules/audio_device/win/core_audio_base_win.cc b/modules/audio_device/win/core_audio_base_win.cc
index c336c42..bd19001 100644
--- a/modules/audio_device/win/core_audio_base_win.cc
+++ b/modules/audio_device/win/core_audio_base_win.cc
@@ -591,7 +591,7 @@
// thread is not destroyed during restart attempts triggered by internal
// error callbacks.
if (!IsRestarting()) {
- thread_checker_audio_.DetachFromThread();
+ thread_checker_audio_.Detach();
}
// Release all allocated COM interfaces to allow for a restart without
diff --git a/modules/audio_device/win/core_audio_input_win.cc b/modules/audio_device/win/core_audio_input_win.cc
index e5512c1..3b523f6 100644
--- a/modules/audio_device/win/core_audio_input_win.cc
+++ b/modules/audio_device/win/core_audio_input_win.cc
@@ -32,7 +32,7 @@
[this](ErrorType err) { return OnErrorCallback(err); }) {
RTC_DLOG(INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_);
- thread_checker_audio_.DetachFromThread();
+ thread_checker_audio_.Detach();
}
CoreAudioInput::~CoreAudioInput() {
diff --git a/modules/audio_device/win/core_audio_output_win.cc b/modules/audio_device/win/core_audio_output_win.cc
index c0dc185..16cf10d 100644
--- a/modules/audio_device/win/core_audio_output_win.cc
+++ b/modules/audio_device/win/core_audio_output_win.cc
@@ -29,7 +29,7 @@
[this](ErrorType err) { return OnErrorCallback(err); }) {
RTC_DLOG(INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_);
- thread_checker_audio_.DetachFromThread();
+ thread_checker_audio_.Detach();
}
CoreAudioOutput::~CoreAudioOutput() {
diff --git a/modules/desktop_capture/fallback_desktop_capturer_wrapper.cc b/modules/desktop_capture/fallback_desktop_capturer_wrapper.cc
index 48ee6e2..3b21fdf 100644
--- a/modules/desktop_capture/fallback_desktop_capturer_wrapper.cc
+++ b/modules/desktop_capture/fallback_desktop_capturer_wrapper.cc
@@ -63,7 +63,7 @@
std::unique_ptr<SharedMemory> SharedMemoryFactoryProxy::CreateSharedMemory(
size_t size) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
return factory_->CreateSharedMemory(size);
}
diff --git a/modules/desktop_capture/mac/desktop_frame_provider.mm b/modules/desktop_capture/mac/desktop_frame_provider.mm
index 8ffce43..009504a 100644
--- a/modules/desktop_capture/mac/desktop_frame_provider.mm
+++ b/modules/desktop_capture/mac/desktop_frame_provider.mm
@@ -19,18 +19,18 @@
DesktopFrameProvider::DesktopFrameProvider(bool allow_iosurface)
: allow_iosurface_(allow_iosurface) {
- thread_checker_.DetachFromThread();
+ thread_checker_.Detach();
}
DesktopFrameProvider::~DesktopFrameProvider() {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
Release();
}
std::unique_ptr<DesktopFrame> DesktopFrameProvider::TakeLatestFrameForDisplay(
CGDirectDisplayID display_id) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (!allow_iosurface_ || !io_surfaces_[display_id]) {
// Regenerate a snapshot. If iosurface is on it will be empty until the
@@ -43,7 +43,7 @@
void DesktopFrameProvider::InvalidateIOSurface(CGDirectDisplayID display_id,
rtc::ScopedCFTypeRef<IOSurfaceRef> io_surface) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (!allow_iosurface_) {
return;
@@ -58,7 +58,7 @@
}
void DesktopFrameProvider::Release() {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (!allow_iosurface_) {
return;
diff --git a/modules/desktop_capture/mac/screen_capturer_mac.mm b/modules/desktop_capture/mac/screen_capturer_mac.mm
index 41d19cd..a79384c 100644
--- a/modules/desktop_capture/mac/screen_capturer_mac.mm
+++ b/modules/desktop_capture/mac/screen_capturer_mac.mm
@@ -153,11 +153,11 @@
desktop_config_monitor_(desktop_config_monitor),
desktop_frame_provider_(allow_iosurface) {
RTC_LOG(LS_INFO) << "Allow IOSurface: " << allow_iosurface;
- thread_checker_.DetachFromThread();
+ thread_checker_.Detach();
}
ScreenCapturerMac::~ScreenCapturerMac() {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
ReleaseBuffers();
UnregisterRefreshAndMoveHandlers();
}
@@ -176,7 +176,7 @@
}
void ScreenCapturerMac::Start(Callback* callback) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(!callback_);
RTC_DCHECK(callback);
TRACE_EVENT_INSTANT1(
@@ -193,7 +193,7 @@
}
void ScreenCapturerMac::CaptureFrame() {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
TRACE_EVENT0("webrtc", "creenCapturerMac::CaptureFrame");
int64_t capture_start_time_nanos = rtc::TimeNanos();
@@ -437,7 +437,7 @@
}
bool ScreenCapturerMac::RegisterRefreshAndMoveHandlers() {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
desktop_config_ = desktop_config_monitor_->desktop_configuration();
for (const auto& config : desktop_config_.displays) {
size_t pixel_width = config.pixel_bounds.width();
@@ -450,7 +450,7 @@
uint64_t display_time,
IOSurfaceRef frame_surface,
CGDisplayStreamUpdateRef updateRef) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (status == kCGDisplayStreamFrameStatusStopped) return;
// Only pay attention to frame updates.
@@ -491,7 +491,7 @@
}
void ScreenCapturerMac::UnregisterRefreshAndMoveHandlers() {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
for (CGDisplayStreamRef stream : display_streams_) {
CFRunLoopSourceRef source = CGDisplayStreamGetRunLoopSource(stream);
diff --git a/modules/utility/source/jvm_android.cc b/modules/utility/source/jvm_android.cc
index c861c43..a1e966f 100644
--- a/modules/utility/source/jvm_android.cc
+++ b/modules/utility/source/jvm_android.cc
@@ -83,7 +83,7 @@
JvmThreadConnector::~JvmThreadConnector() {
RTC_LOG(INFO) << "JvmThreadConnector::dtor";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (attached_) {
RTC_LOG(INFO) << "Detaching thread from JVM";
jint res = JVM::GetInstance()->jvm()->DetachCurrentThread();
@@ -186,7 +186,7 @@
JNIEnvironment::~JNIEnvironment() {
RTC_LOG(INFO) << "JNIEnvironment::dtor";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
}
std::unique_ptr<NativeRegistration> JNIEnvironment::RegisterNatives(
@@ -194,7 +194,7 @@
const JNINativeMethod* methods,
int num_methods) {
RTC_LOG(INFO) << "JNIEnvironment::RegisterNatives: " << name;
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
jclass clazz = LookUpClass(name);
jni_->RegisterNatives(clazz, methods, num_methods);
CHECK_EXCEPTION(jni_) << "Error during RegisterNatives";
@@ -203,7 +203,7 @@
}
std::string JNIEnvironment::JavaToStdString(const jstring& j_string) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
const char* jchars = jni_->GetStringUTFChars(j_string, nullptr);
CHECK_EXCEPTION(jni_);
const int size = jni_->GetStringUTFLength(j_string);
@@ -254,7 +254,7 @@
JVM::~JVM() {
RTC_LOG(INFO) << "JVM::~JVM";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
FreeClassReferences(jni());
}
@@ -277,7 +277,7 @@
JavaClass JVM::GetClass(const char* name) {
RTC_LOG(INFO) << "JVM::GetClass: " << name;
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
return JavaClass(jni(), LookUpClass(name));
}
diff --git a/modules/utility/source/process_thread_impl.cc b/modules/utility/source/process_thread_impl.cc
index 5c2f0ab..b3fbaef 100644
--- a/modules/utility/source/process_thread_impl.cc
+++ b/modules/utility/source/process_thread_impl.cc
@@ -46,7 +46,7 @@
: stop_(false), thread_name_(thread_name) {}
ProcessThreadImpl::~ProcessThreadImpl() {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(!thread_.get());
RTC_DCHECK(!stop_);
@@ -57,7 +57,7 @@
}
void ProcessThreadImpl::Start() {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(!thread_.get());
if (thread_.get())
return;
@@ -73,7 +73,7 @@
}
void ProcessThreadImpl::Stop() {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (!thread_.get())
return;
@@ -115,7 +115,7 @@
void ProcessThreadImpl::RegisterModule(Module* module,
const rtc::Location& from) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(module) << from.ToString();
#if RTC_DCHECK_IS_ON
@@ -148,7 +148,7 @@
}
void ProcessThreadImpl::DeRegisterModule(Module* module) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(module);
{
diff --git a/modules/video_capture/windows/sink_filter_ds.cc b/modules/video_capture/windows/sink_filter_ds.cc
index 9cd6360..c33a8f3 100644
--- a/modules/video_capture/windows/sink_filter_ds.cc
+++ b/modules/video_capture/windows/sink_filter_ds.cc
@@ -380,7 +380,7 @@
} // namespace
CaptureInputPin::CaptureInputPin(CaptureSinkFilter* filter) {
- capture_checker_.DetachFromThread();
+ capture_checker_.Detach();
// No reference held to avoid circular references.
info_.pFilter = filter;
info_.dir = PINDIR_INPUT;
@@ -404,7 +404,7 @@
RTC_DCHECK_RUN_ON(&main_checker_);
runtime_error_ = false;
flushing_ = false;
- capture_checker_.DetachFromThread();
+ capture_checker_.Detach();
capture_thread_id_ = 0;
}
diff --git a/modules/video_coding/generic_decoder.cc b/modules/video_coding/generic_decoder.cc
index dd23066..6561f0b 100644
--- a/modules/video_coding/generic_decoder.cc
+++ b/modules/video_coding/generic_decoder.cc
@@ -37,7 +37,7 @@
void VCMDecodedFrameCallback::SetUserReceiveCallback(
VCMReceiveCallback* receiveCallback) {
- RTC_DCHECK(construction_thread_.CalledOnValidThread());
+ RTC_DCHECK(construction_thread_.IsCurrent());
RTC_DCHECK((!_receiveCallback && receiveCallback) ||
(_receiveCallback && !receiveCallback));
_receiveCallback = receiveCallback;
diff --git a/modules/video_coding/video_coding_impl.cc b/modules/video_coding/video_coding_impl.cc
index 4e04306..dc60541 100644
--- a/modules/video_coding/video_coding_impl.cc
+++ b/modules/video_coding/video_coding_impl.cc
@@ -71,7 +71,7 @@
int32_t RegisterReceiveCallback(
VCMReceiveCallback* receiveCallback) override {
- RTC_DCHECK(construction_thread_.CalledOnValidThread());
+ RTC_DCHECK(construction_thread_.IsCurrent());
return receiver_.RegisterReceiveCallback(receiveCallback);
}
@@ -82,7 +82,7 @@
int32_t RegisterPacketRequestCallback(
VCMPacketRequestCallback* callback) override {
- RTC_DCHECK(construction_thread_.CalledOnValidThread());
+ RTC_DCHECK(construction_thread_.IsCurrent());
return receiver_.RegisterPacketRequestCallback(callback);
}
diff --git a/modules/video_coding/video_receiver.cc b/modules/video_coding/video_receiver.cc
index d2bc029..36b7f0a 100644
--- a/modules/video_coding/video_receiver.cc
+++ b/modules/video_coding/video_receiver.cc
@@ -55,8 +55,8 @@
_receiveStatsTimer(1000, clock_),
_retransmissionTimer(10, clock_),
_keyRequestTimer(500, clock_) {
- decoder_thread_checker_.DetachFromThread();
- module_thread_checker_.DetachFromThread();
+ decoder_thread_checker_.Detach();
+ module_thread_checker_.Detach();
}
VideoReceiver::~VideoReceiver() {
@@ -244,7 +244,7 @@
}
#if RTC_DCHECK_IS_ON
decoder_thread_is_running_ = false;
- decoder_thread_checker_.DetachFromThread();
+ decoder_thread_checker_.Detach();
#endif
}
diff --git a/p2p/base/port_allocator.cc b/p2p/base/port_allocator.cc
index c6ea6fd..4dee0fa 100644
--- a/p2p/base/port_allocator.cc
+++ b/p2p/base/port_allocator.cc
@@ -121,11 +121,11 @@
allow_tcp_listen_(true),
candidate_filter_(CF_ALL) {
// The allocator will be attached to a thread in Initialize.
- thread_checker_.DetachFromThread();
+ thread_checker_.Detach();
}
void PortAllocator::Initialize() {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
initialized_ = true;
}
@@ -148,7 +148,7 @@
// A positive candidate pool size would lead to the creation of a pooled
// allocator session and starting getting ports, which we should only do on
// the network thread.
- RTC_DCHECK(candidate_pool_size == 0 || thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(candidate_pool_size == 0 || thread_checker_.IsCurrent());
bool ice_servers_changed =
(stun_servers != stun_servers_ || turn_servers != turn_servers_);
stun_servers_ = stun_servers;
diff --git a/p2p/base/port_allocator.h b/p2p/base/port_allocator.h
index 33745ea..e0cc775 100644
--- a/p2p/base/port_allocator.h
+++ b/p2p/base/port_allocator.h
@@ -579,11 +579,11 @@
// The following thread checks are only done in DCHECK for the consistency
// with the exsiting thread checks.
void CheckRunOnValidThreadIfInitialized() const {
- RTC_DCHECK(!initialized_ || thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(!initialized_ || thread_checker_.IsCurrent());
}
void CheckRunOnValidThreadAndInitialized() const {
- RTC_DCHECK(initialized_ && thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(initialized_ && thread_checker_.IsCurrent());
}
bool initialized_ = false;
diff --git a/p2p/base/test_turn_server.h b/p2p/base/test_turn_server.h
index 2bbe573..3a4067b 100644
--- a/p2p/base/test_turn_server.h
+++ b/p2p/base/test_turn_server.h
@@ -65,25 +65,25 @@
server_.set_auth_hook(this);
}
- ~TestTurnServer() { RTC_DCHECK(thread_checker_.CalledOnValidThread()); }
+ ~TestTurnServer() { RTC_DCHECK(thread_checker_.IsCurrent()); }
void set_enable_otu_nonce(bool enable) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
server_.set_enable_otu_nonce(enable);
}
TurnServer* server() {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
return &server_;
}
void set_redirect_hook(TurnRedirectInterface* redirect_hook) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
server_.set_redirect_hook(redirect_hook);
}
void set_enable_permission_checks(bool enable) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
server_.set_enable_permission_checks(enable);
}
@@ -91,7 +91,7 @@
ProtocolType proto,
bool ignore_bad_cert = true,
const std::string& common_name = "test turn server") {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (proto == cricket::PROTO_UDP) {
server_.AddInternalSocket(
rtc::AsyncUDPSocket::Create(thread_->socketserver(), int_addr),
@@ -124,7 +124,7 @@
// Finds the first allocation in the server allocation map with a source
// ip and port matching the socket address provided.
TurnServerAllocation* FindAllocation(const rtc::SocketAddress& src) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
const TurnServer::AllocationMap& map = server_.allocations();
for (TurnServer::AllocationMap::const_iterator it = map.begin();
it != map.end(); ++it) {
@@ -141,7 +141,7 @@
virtual bool GetKey(const std::string& username,
const std::string& realm,
std::string* key) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
return ComputeStunCredentialHash(username, realm, username, key);
}
diff --git a/p2p/base/turn_server.cc b/p2p/base/turn_server.cc
index 1b2903d..8f482a3 100644
--- a/p2p/base/turn_server.cc
+++ b/p2p/base/turn_server.cc
@@ -130,7 +130,7 @@
}
TurnServer::~TurnServer() {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
for (InternalSocketMap::iterator it = server_sockets_.begin();
it != server_sockets_.end(); ++it) {
rtc::AsyncPacketSocket* socket = it->first;
@@ -146,7 +146,7 @@
void TurnServer::AddInternalSocket(rtc::AsyncPacketSocket* socket,
ProtocolType proto) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(server_sockets_.end() == server_sockets_.find(socket));
server_sockets_[socket] = proto;
socket->SignalReadPacket.connect(this, &TurnServer::OnInternalPacket);
@@ -154,7 +154,7 @@
void TurnServer::AddInternalServerSocket(rtc::AsyncSocket* socket,
ProtocolType proto) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(server_listen_sockets_.end() ==
server_listen_sockets_.find(socket));
server_listen_sockets_[socket] = proto;
@@ -164,20 +164,20 @@
void TurnServer::SetExternalSocketFactory(
rtc::PacketSocketFactory* factory,
const rtc::SocketAddress& external_addr) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
external_socket_factory_.reset(factory);
external_addr_ = external_addr;
}
void TurnServer::OnNewInternalConnection(rtc::AsyncSocket* socket) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(server_listen_sockets_.find(socket) !=
server_listen_sockets_.end());
AcceptConnection(socket);
}
void TurnServer::AcceptConnection(rtc::AsyncSocket* server_socket) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
// Check if someone is trying to connect to us.
rtc::SocketAddress accept_addr;
rtc::AsyncSocket* accepted_socket = server_socket->Accept(&accept_addr);
@@ -194,7 +194,7 @@
void TurnServer::OnInternalSocketClose(rtc::AsyncPacketSocket* socket,
int err) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
DestroyInternalSocket(socket);
}
@@ -203,7 +203,7 @@
size_t size,
const rtc::SocketAddress& addr,
const int64_t& /* packet_time_us */) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
// Fail if the packet is too small to even contain a channel header.
if (size < TURN_CHANNEL_HEADER_SIZE) {
return;
@@ -229,7 +229,7 @@
void TurnServer::HandleStunMessage(TurnServerConnection* conn, const char* data,
size_t size) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
TurnMessage msg;
rtc::ByteBufferReader buf(data, size);
if (!msg.Read(&buf) || (buf.Length() > 0)) {
@@ -296,7 +296,7 @@
}
bool TurnServer::GetKey(const StunMessage* msg, std::string* key) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
const StunByteStringAttribute* username_attr =
msg->GetByteString(STUN_ATTR_USERNAME);
if (!username_attr) {
@@ -311,7 +311,7 @@
const StunMessage* msg,
const char* data, size_t size,
const std::string& key) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
// RFC 5389, 10.2.2.
RTC_DCHECK(IsStunRequestType(msg->type()));
const StunByteStringAttribute* mi_attr =
@@ -370,7 +370,7 @@
void TurnServer::HandleBindingRequest(TurnServerConnection* conn,
const StunMessage* req) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
StunMessage response;
InitResponse(req, &response);
@@ -385,7 +385,7 @@
void TurnServer::HandleAllocateRequest(TurnServerConnection* conn,
const TurnMessage* msg,
const std::string& key) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
// Check the parameters in the request.
const StunUInt32Attribute* transport_attr =
msg->GetUInt32(STUN_ATTR_REQUESTED_TRANSPORT);
@@ -415,7 +415,7 @@
}
std::string TurnServer::GenerateNonce(int64_t now) const {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
// Generate a nonce of the form hex(now + HMAC-MD5(nonce_key_, now))
std::string input(reinterpret_cast<const char*>(&now), sizeof(now));
std::string nonce = rtc::hex_encode(input.c_str(), input.size());
@@ -426,7 +426,7 @@
}
bool TurnServer::ValidateNonce(const std::string& nonce) const {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
// Check the size.
if (nonce.size() != kNonceSize) {
return false;
@@ -452,7 +452,7 @@
}
TurnServerAllocation* TurnServer::FindAllocation(TurnServerConnection* conn) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
AllocationMap::const_iterator it = allocations_.find(*conn);
return (it != allocations_.end()) ? it->second.get() : nullptr;
}
@@ -460,7 +460,7 @@
TurnServerAllocation* TurnServer::CreateAllocation(TurnServerConnection* conn,
int proto,
const std::string& key) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
rtc::AsyncPacketSocket* external_socket = (external_socket_factory_) ?
external_socket_factory_->CreateUdpSocket(external_addr_, 0, 0) : NULL;
if (!external_socket) {
@@ -478,7 +478,7 @@
void TurnServer::SendErrorResponse(TurnServerConnection* conn,
const StunMessage* req,
int code, const std::string& reason) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
TurnMessage resp;
InitErrorResponse(req, code, reason, &resp);
RTC_LOG(LS_INFO) << "Sending error response, type=" << resp.type()
@@ -489,7 +489,7 @@
void TurnServer::SendErrorResponseWithRealmAndNonce(
TurnServerConnection* conn, const StunMessage* msg,
int code, const std::string& reason) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
TurnMessage resp;
InitErrorResponse(msg, code, reason, &resp);
@@ -508,7 +508,7 @@
void TurnServer::SendErrorResponseWithAlternateServer(
TurnServerConnection* conn, const StunMessage* msg,
const rtc::SocketAddress& addr) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
TurnMessage resp;
InitErrorResponse(msg, STUN_ERROR_TRY_ALTERNATE,
STUN_ERROR_REASON_TRY_ALTERNATE_SERVER, &resp);
@@ -518,7 +518,7 @@
}
void TurnServer::SendStun(TurnServerConnection* conn, StunMessage* msg) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
rtc::ByteBufferWriter buf;
// Add a SOFTWARE attribute if one is set.
if (!software_.empty()) {
@@ -531,13 +531,13 @@
void TurnServer::Send(TurnServerConnection* conn,
const rtc::ByteBufferWriter& buf) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
rtc::PacketOptions options;
conn->socket()->SendTo(buf.Data(), buf.Length(), conn->src(), options);
}
void TurnServer::OnAllocationDestroyed(TurnServerAllocation* allocation) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
// Removing the internal socket if the connection is not udp.
rtc::AsyncPacketSocket* socket = allocation->conn()->socket();
InternalSocketMap::iterator iter = server_sockets_.find(socket);
@@ -557,7 +557,7 @@
}
void TurnServer::DestroyInternalSocket(rtc::AsyncPacketSocket* socket) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
InternalSocketMap::iterator iter = server_sockets_.find(socket);
if (iter != server_sockets_.end()) {
rtc::AsyncPacketSocket* socket = iter->first;
@@ -574,7 +574,7 @@
}
void TurnServer::FreeSockets() {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
sockets_to_delete_.clear();
}
diff --git a/p2p/base/turn_server.h b/p2p/base/turn_server.h
index 690d6a9..1665055 100644
--- a/p2p/base/turn_server.h
+++ b/p2p/base/turn_server.h
@@ -181,53 +181,53 @@
// Gets/sets the realm value to use for the server.
const std::string& realm() const {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
return realm_;
}
void set_realm(const std::string& realm) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
realm_ = realm;
}
// Gets/sets the value for the SOFTWARE attribute for TURN messages.
const std::string& software() const {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
return software_;
}
void set_software(const std::string& software) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
software_ = software;
}
const AllocationMap& allocations() const {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
return allocations_;
}
// Sets the authentication callback; does not take ownership.
void set_auth_hook(TurnAuthInterface* auth_hook) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
auth_hook_ = auth_hook;
}
void set_redirect_hook(TurnRedirectInterface* redirect_hook) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
redirect_hook_ = redirect_hook;
}
void set_enable_otu_nonce(bool enable) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
enable_otu_nonce_ = enable;
}
// If set to true, reject CreatePermission requests to RFC1918 addresses.
void set_reject_private_addresses(bool filter) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
reject_private_addresses_ = filter;
}
void set_enable_permission_checks(bool enable) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
enable_permission_checks_ = enable;
}
@@ -244,14 +244,14 @@
const rtc::SocketAddress& address);
// For testing only.
std::string SetTimestampForNextNonce(int64_t timestamp) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
ts_for_next_nonce_ = timestamp;
return GenerateNonce(timestamp);
}
void SetStunMessageObserver(
std::unique_ptr<StunMessageObserver> observer) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
stun_message_observer_ = std::move(observer);
}
diff --git a/p2p/stunprober/stun_prober.cc b/p2p/stunprober/stun_prober.cc
index 4fe572f..4cbb5ed 100644
--- a/p2p/stunprober/stun_prober.cc
+++ b/p2p/stunprober/stun_prober.cc
@@ -133,7 +133,7 @@
}
void StunProber::Requester::SendStunRequest() {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
requests_.push_back(new Request());
Request& request = *(requests_.back());
cricket::StunMessage message;
@@ -205,7 +205,7 @@
size_t size,
const rtc::SocketAddress& addr,
const int64_t& /* packet_time_us */) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(socket_);
Request* request = GetRequestByAddress(addr.ipaddr());
if (!request) {
@@ -220,7 +220,7 @@
StunProber::Requester::Request* StunProber::Requester::GetRequestByAddress(
const rtc::IPAddress& ipaddr) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
for (auto* request : requests_) {
if (request->server_addr == ipaddr) {
return request;
@@ -290,7 +290,7 @@
int num_request_per_ip,
int timeout_ms,
StunProber::Observer* observer) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
interval_ms_ = interval_ms;
shared_socket_mode_ = shared_socket_mode;
@@ -347,7 +347,7 @@
}
void StunProber::OnServerResolved(rtc::AsyncResolverInterface* resolver) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (resolver->GetError() == 0) {
rtc::SocketAddress addr(resolver->address().ipaddr(),
@@ -404,7 +404,7 @@
}
StunProber::Requester* StunProber::CreateRequester() {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (!sockets_.size()) {
return nullptr;
}
@@ -452,7 +452,7 @@
}
void StunProber::MaybeScheduleStunRequests() {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
int64_t now = rtc::TimeMillis();
if (Done()) {
diff --git a/pc/audio_track.cc b/pc/audio_track.cc
index f3bc3ff..ff68065 100644
--- a/pc/audio_track.cc
+++ b/pc/audio_track.cc
@@ -32,36 +32,36 @@
}
AudioTrack::~AudioTrack() {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
set_state(MediaStreamTrackInterface::kEnded);
if (audio_source_)
audio_source_->UnregisterObserver(this);
}
std::string AudioTrack::kind() const {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
return kAudioKind;
}
AudioSourceInterface* AudioTrack::GetSource() const {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
return audio_source_.get();
}
void AudioTrack::AddSink(AudioTrackSinkInterface* sink) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (audio_source_)
audio_source_->AddSink(sink);
}
void AudioTrack::RemoveSink(AudioTrackSinkInterface* sink) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (audio_source_)
audio_source_->RemoveSink(sink);
}
void AudioTrack::OnChanged() {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (audio_source_->state() == MediaSourceInterface::kEnded) {
set_state(kEnded);
} else {
diff --git a/pc/srtp_session.cc b/pc/srtp_session.cc
index fccf7da..9d67669 100644
--- a/pc/srtp_session.cc
+++ b/pc/srtp_session.cc
@@ -67,7 +67,7 @@
}
bool SrtpSession::ProtectRtp(void* p, int in_len, int max_len, int* out_len) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (!session_) {
RTC_LOG(LS_WARNING) << "Failed to protect SRTP packet: no SRTP Session";
return false;
@@ -106,7 +106,7 @@
}
bool SrtpSession::ProtectRtcp(void* p, int in_len, int max_len, int* out_len) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (!session_) {
RTC_LOG(LS_WARNING) << "Failed to protect SRTCP packet: no SRTP Session";
return false;
@@ -129,7 +129,7 @@
}
bool SrtpSession::UnprotectRtp(void* p, int in_len, int* out_len) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (!session_) {
RTC_LOG(LS_WARNING) << "Failed to unprotect SRTP packet: no SRTP Session";
return false;
@@ -155,7 +155,7 @@
}
bool SrtpSession::UnprotectRtcp(void* p, int in_len, int* out_len) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (!session_) {
RTC_LOG(LS_WARNING) << "Failed to unprotect SRTCP packet: no SRTP Session";
return false;
@@ -173,7 +173,7 @@
}
bool SrtpSession::GetRtpAuthParams(uint8_t** key, int* key_len, int* tag_len) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(IsExternalAuthActive());
if (!IsExternalAuthActive()) {
return false;
@@ -220,7 +220,7 @@
bool SrtpSession::GetSendStreamPacketIndex(void* p,
int in_len,
int64_t* index) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
srtp_hdr_t* hdr = reinterpret_cast<srtp_hdr_t*>(p);
srtp_stream_ctx_t* stream = srtp_get_stream(session_, hdr->ssrc);
if (!stream) {
@@ -238,7 +238,7 @@
const uint8_t* key,
size_t len,
const std::vector<int>& extension_ids) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
srtp_policy_t policy;
memset(&policy, 0, sizeof(policy));
@@ -330,7 +330,7 @@
const uint8_t* key,
size_t len,
const std::vector<int>& extension_ids) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (session_) {
RTC_LOG(LS_ERROR) << "Failed to create SRTP session: "
"SRTP session already created";
@@ -353,7 +353,7 @@
const uint8_t* key,
size_t len,
const std::vector<int>& extension_ids) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (!session_) {
RTC_LOG(LS_ERROR) << "Failed to update non-existing SRTP session";
return false;
@@ -408,7 +408,7 @@
}
void SrtpSession::HandleEvent(const srtp_event_data_t* ev) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
switch (ev->event) {
case event_ssrc_collision:
RTC_LOG(LS_INFO) << "SRTP event: SSRC collision";
diff --git a/pc/test/fake_periodic_video_source.h b/pc/test/fake_periodic_video_source.h
index 1fcb0f6..7575f97 100644
--- a/pc/test/fake_periodic_video_source.h
+++ b/pc/test/fake_periodic_video_source.h
@@ -46,7 +46,7 @@
config.timestamp_offset_ms * rtc::kNumMicrosecsPerMillisec),
task_queue_(absl::make_unique<TaskQueueForTest>(
"FakePeriodicVideoTrackSource")) {
- thread_checker_.DetachFromThread();
+ thread_checker_.Detach();
frame_source_.SetRotation(config.rotation);
TimeDelta frame_interval = TimeDelta::ms(config.frame_interval_ms);
@@ -61,13 +61,13 @@
}
void RemoveSink(rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) override {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
broadcaster_.RemoveSink(sink);
}
void AddOrUpdateSink(rtc::VideoSinkInterface<webrtc::VideoFrame>* sink,
const rtc::VideoSinkWants& wants) override {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
broadcaster_.AddOrUpdateSink(sink, wants);
}
diff --git a/pc/test/peer_connection_test_wrapper.cc b/pc/test/peer_connection_test_wrapper.cc
index d05022f..c2fd338 100644
--- a/pc/test/peer_connection_test_wrapper.cc
+++ b/pc/test/peer_connection_test_wrapper.cc
@@ -79,7 +79,7 @@
: name_(name),
network_thread_(network_thread),
worker_thread_(worker_thread) {
- pc_thread_checker_.DetachFromThread();
+ pc_thread_checker_.Detach();
}
PeerConnectionTestWrapper::~PeerConnectionTestWrapper() {
diff --git a/pc/test/rtc_stats_obtainer.h b/pc/test/rtc_stats_obtainer.h
index f0ec3eb..95201f6 100644
--- a/pc/test/rtc_stats_obtainer.h
+++ b/pc/test/rtc_stats_obtainer.h
@@ -26,14 +26,14 @@
void OnStatsDelivered(
const rtc::scoped_refptr<const RTCStatsReport>& report) override {
- EXPECT_TRUE(thread_checker_.CalledOnValidThread());
+ EXPECT_TRUE(thread_checker_.IsCurrent());
report_ = report;
if (report_ptr_)
*report_ptr_ = report_;
}
rtc::scoped_refptr<const RTCStatsReport> report() const {
- EXPECT_TRUE(thread_checker_.CalledOnValidThread());
+ EXPECT_TRUE(thread_checker_.IsCurrent());
return report_;
}
diff --git a/pc/video_track.cc b/pc/video_track.cc
index f93e3d5..16e1e70 100644
--- a/pc/video_track.cc
+++ b/pc/video_track.cc
@@ -68,7 +68,7 @@
}
bool VideoTrack::set_enabled(bool enable) {
- RTC_DCHECK(signaling_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(signaling_thread_checker_.IsCurrent());
worker_thread_->Invoke<void>(RTC_FROM_HERE, [enable, this] {
RTC_DCHECK(worker_thread_->IsCurrent());
for (auto& sink_pair : sink_pairs()) {
@@ -81,7 +81,7 @@
}
void VideoTrack::OnChanged() {
- RTC_DCHECK(signaling_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(signaling_thread_checker_.IsCurrent());
if (video_source_->state() == MediaSourceInterface::kEnded) {
set_state(kEnded);
} else {
diff --git a/pc/video_track_source.cc b/pc/video_track_source.cc
index 408c8d7..c806ec1 100644
--- a/pc/video_track_source.cc
+++ b/pc/video_track_source.cc
@@ -17,7 +17,7 @@
VideoTrackSource::VideoTrackSource(
bool remote)
: state_(kInitializing), remote_(remote) {
- worker_thread_checker_.DetachFromThread();
+ worker_thread_checker_.Detach();
}
void VideoTrackSource::SetState(SourceState new_state) {
@@ -30,12 +30,12 @@
void VideoTrackSource::AddOrUpdateSink(
rtc::VideoSinkInterface<VideoFrame>* sink,
const rtc::VideoSinkWants& wants) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
source()->AddOrUpdateSink(sink, wants);
}
void VideoTrackSource::RemoveSink(rtc::VideoSinkInterface<VideoFrame>* sink) {
- RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(worker_thread_checker_.IsCurrent());
source()->RemoveSink(sink);
}
diff --git a/rtc_base/BUILD.gn b/rtc_base/BUILD.gn
index 2bae52c..273ad0f 100644
--- a/rtc_base/BUILD.gn
+++ b/rtc_base/BUILD.gn
@@ -319,6 +319,7 @@
"thread_checker.h",
]
deps = [
+ ":deprecation",
"synchronization:sequence_checker",
]
}
diff --git a/rtc_base/event_tracer.cc b/rtc_base/event_tracer.cc
index bcc8252..d3f6ebf 100644
--- a/rtc_base/event_tracer.cc
+++ b/rtc_base/event_tracer.cc
@@ -91,7 +91,7 @@
this,
"EventTracingThread",
kLowPriority) {}
- ~EventLogger() { RTC_DCHECK(thread_checker_.CalledOnValidThread()); }
+ ~EventLogger() { RTC_DCHECK(thread_checker_.IsCurrent()); }
void AddTraceEvent(const char* name,
const unsigned char* category_enabled,
@@ -189,7 +189,7 @@
}
void Start(FILE* file, bool owned) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(file);
RTC_DCHECK(!output_file_);
output_file_ = file;
@@ -213,7 +213,7 @@
}
void Stop() {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
TRACE_EVENT_INSTANT0("webrtc", "EventLogger::Stop");
// Try to stop. Abort if we're not currently logging.
if (rtc::AtomicOps::CompareAndSwap(&g_event_logging_active, 1, 0) == 0)
diff --git a/rtc_base/platform_thread.cc b/rtc_base/platform_thread.cc
index 63c8f65..16cf1cc 100644
--- a/rtc_base/platform_thread.cc
+++ b/rtc_base/platform_thread.cc
@@ -43,7 +43,7 @@
: run_function_deprecated_(func), obj_(obj), name_(thread_name) {
RTC_DCHECK(func);
RTC_DCHECK(name_.length() < 64);
- spawned_thread_checker_.DetachFromThread();
+ spawned_thread_checker_.Detach();
}
PlatformThread::PlatformThread(ThreadRunFunction func,
@@ -55,11 +55,11 @@
RTC_DCHECK(!name_.empty());
// TODO(tommi): Consider lowering the limit to 15 (limit on Linux).
RTC_DCHECK(name_.length() < 64);
- spawned_thread_checker_.DetachFromThread();
+ spawned_thread_checker_.Detach();
}
PlatformThread::~PlatformThread() {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
#if defined(WEBRTC_WIN)
RTC_DCHECK(!thread_);
RTC_DCHECK(!thread_id_);
@@ -84,7 +84,7 @@
#endif // defined(WEBRTC_WIN)
void PlatformThread::Start() {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(!thread_) << "Thread already started?";
#if defined(WEBRTC_WIN)
stop_ = false;
@@ -105,7 +105,7 @@
}
bool PlatformThread::IsRunning() const {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
#if defined(WEBRTC_WIN)
return thread_ != nullptr;
#else
@@ -122,7 +122,7 @@
}
void PlatformThread::Stop() {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (!IsRunning())
return;
@@ -150,7 +150,7 @@
AtomicOps::ReleaseStore(&stop_flag_, 0);
thread_ = 0;
#endif // defined(WEBRTC_WIN)
- spawned_thread_checker_.DetachFromThread();
+ spawned_thread_checker_.Detach();
}
// TODO(tommi): Deprecate the loop behavior in PlatformThread.
@@ -162,7 +162,7 @@
// and encouraging a busy polling loop, can be costly in terms of power and cpu.
void PlatformThread::Run() {
// Attach the worker thread checker to this thread.
- RTC_DCHECK(spawned_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(spawned_thread_checker_.IsCurrent());
rtc::SetCurrentThreadName(name_.c_str());
if (run_function_) {
@@ -225,11 +225,11 @@
if (run_function_) {
// The non-deprecated way of how this function gets called, is that it must
// be called on the worker thread itself.
- RTC_DCHECK(spawned_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(spawned_thread_checker_.IsCurrent());
} else {
// In the case of deprecated use of this method, it must be called on the
// same thread as the PlatformThread object is constructed on.
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(IsRunning());
}
#endif
@@ -283,7 +283,7 @@
#if defined(WEBRTC_WIN)
bool PlatformThread::QueueAPC(PAPCFUNC function, ULONG_PTR data) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(IsRunning());
return QueueUserAPC(function, thread_, data) != FALSE;
diff --git a/rtc_base/sequenced_task_checker_unittest.cc b/rtc_base/sequenced_task_checker_unittest.cc
index 74cba8a..bbba290 100644
--- a/rtc_base/sequenced_task_checker_unittest.cc
+++ b/rtc_base/sequenced_task_checker_unittest.cc
@@ -77,7 +77,7 @@
});
}
-TEST(SequencedTaskCheckerTest, DetachFromThread) {
+TEST(SequencedTaskCheckerTest, Detach) {
SequencedTaskChecker sequenced_task_checker;
sequenced_task_checker.Detach();
RunOnDifferentThread(
diff --git a/rtc_base/thread_checker.h b/rtc_base/thread_checker.h
index d3daa6f..876a08e 100644
--- a/rtc_base/thread_checker.h
+++ b/rtc_base/thread_checker.h
@@ -13,14 +13,15 @@
#ifndef RTC_BASE_THREAD_CHECKER_H_
#define RTC_BASE_THREAD_CHECKER_H_
+#include "rtc_base/deprecation.h"
#include "rtc_base/synchronization/sequence_checker.h"
namespace rtc {
// TODO(srte): Replace usages of this with SequenceChecker.
class ThreadChecker : public webrtc::SequenceChecker {
public:
- bool CalledOnValidThread() const { return IsCurrent(); }
- void DetachFromThread() { Detach(); }
+ RTC_DEPRECATED bool CalledOnValidThread() const { return IsCurrent(); }
+ RTC_DEPRECATED void DetachFromThread() { Detach(); }
};
} // namespace rtc
#endif // RTC_BASE_THREAD_CHECKER_H_
diff --git a/rtc_base/thread_checker_unittest.cc b/rtc_base/thread_checker_unittest.cc
index a40196f..c3a64ac 100644
--- a/rtc_base/thread_checker_unittest.cc
+++ b/rtc_base/thread_checker_unittest.cc
@@ -38,9 +38,9 @@
ThreadCheckerClass() {}
// Verifies that it was called on the same thread as the constructor.
- void DoStuff() { RTC_DCHECK(CalledOnValidThread()); }
+ void DoStuff() { RTC_DCHECK(IsCurrent()); }
- void DetachFromThread() { ThreadChecker::DetachFromThread(); }
+ void Detach() { ThreadChecker::Detach(); }
static void MethodOnDifferentThreadImpl();
static void DetachThenCallFromDifferentThreadImpl();
@@ -124,13 +124,13 @@
EXPECT_TRUE(delete_on_thread.has_been_deleted());
}
-TEST(ThreadCheckerTest, DetachFromThread) {
+TEST(ThreadCheckerTest, Detach) {
std::unique_ptr<ThreadCheckerClass> thread_checker_class(
new ThreadCheckerClass);
// Verify that DoStuff doesn't assert when called on a different thread after
- // a call to DetachFromThread.
- thread_checker_class->DetachFromThread();
+ // a call to Detach.
+ thread_checker_class->Detach();
CallDoStuffOnThread call_on_thread(thread_checker_class.get());
call_on_thread.Start();
@@ -166,8 +166,8 @@
new ThreadCheckerClass);
// DoStuff doesn't assert when called on a different thread
- // after a call to DetachFromThread.
- thread_checker_class->DetachFromThread();
+ // after a call to Detach.
+ thread_checker_class->Detach();
CallDoStuffOnThread call_on_thread(thread_checker_class.get());
call_on_thread.Start();
diff --git a/sdk/android/native_api/jni/java_types.cc b/sdk/android/native_api/jni/java_types.cc
index 107e4e0..d726b49 100644
--- a/sdk/android/native_api/jni/java_types.cc
+++ b/sdk/android/native_api/jni/java_types.cc
@@ -58,7 +58,7 @@
// Advances the iterator one step.
Iterable::Iterator& Iterable::Iterator::operator++() {
- RTC_CHECK(thread_checker_.CalledOnValidThread());
+ RTC_CHECK(thread_checker_.IsCurrent());
if (AtEnd()) {
// Can't move past the end.
return *this;
@@ -93,7 +93,7 @@
}
bool Iterable::Iterator::AtEnd() const {
- RTC_CHECK(thread_checker_.CalledOnValidThread());
+ RTC_CHECK(thread_checker_.IsCurrent());
return jni_ == nullptr || IsNull(jni_, iterator_);
}
diff --git a/sdk/android/src/jni/android_network_monitor.cc b/sdk/android/src/jni/android_network_monitor.cc
index 31369a1..4b3256c 100644
--- a/sdk/android/src/jni/android_network_monitor.cc
+++ b/sdk/android/src/jni/android_network_monitor.cc
@@ -174,7 +174,7 @@
AndroidNetworkMonitor::~AndroidNetworkMonitor() = default;
void AndroidNetworkMonitor::Start() {
- RTC_CHECK(thread_checker_.CalledOnValidThread());
+ RTC_CHECK(thread_checker_.IsCurrent());
if (started_) {
return;
}
@@ -191,7 +191,7 @@
}
void AndroidNetworkMonitor::Stop() {
- RTC_CHECK(thread_checker_.CalledOnValidThread());
+ RTC_CHECK(thread_checker_.IsCurrent());
if (!started_) {
return;
}
@@ -216,7 +216,7 @@
rtc::NetworkBindingResult AndroidNetworkMonitor::BindSocketToNetwork(
int socket_fd,
const rtc::IPAddress& address) {
- RTC_CHECK(thread_checker_.CalledOnValidThread());
+ RTC_CHECK(thread_checker_.IsCurrent());
// Android prior to Lollipop didn't have support for binding sockets to
// networks. This may also occur if there is no connectivity manager service.
@@ -354,7 +354,7 @@
void AndroidNetworkMonitor::SetNetworkInfos(
const std::vector<NetworkInformation>& network_infos) {
- RTC_CHECK(thread_checker_.CalledOnValidThread());
+ RTC_CHECK(thread_checker_.IsCurrent());
network_handle_by_address_.clear();
network_info_by_handle_.clear();
RTC_LOG(LS_INFO) << "Android network monitor found " << network_infos.size()
diff --git a/sdk/android/src/jni/audio_device/aaudio_player.cc b/sdk/android/src/jni/audio_device/aaudio_player.cc
index 18e7691..5969706 100644
--- a/sdk/android/src/jni/audio_device/aaudio_player.cc
+++ b/sdk/android/src/jni/audio_device/aaudio_player.cc
@@ -28,7 +28,7 @@
: main_thread_(rtc::Thread::Current()),
aaudio_(audio_parameters, AAUDIO_DIRECTION_OUTPUT, this) {
RTC_LOG(INFO) << "ctor";
- thread_checker_aaudio_.DetachFromThread();
+ thread_checker_aaudio_.Detach();
}
AAudioPlayer::~AAudioPlayer() {
@@ -102,7 +102,7 @@
RTC_LOG(LS_ERROR) << "StopPlayout failed";
return -1;
}
- thread_checker_aaudio_.DetachFromThread();
+ thread_checker_aaudio_.Detach();
initialized_ = false;
playing_ = false;
return 0;
diff --git a/sdk/android/src/jni/audio_device/aaudio_recorder.cc b/sdk/android/src/jni/audio_device/aaudio_recorder.cc
index 7393275..8daafcd 100644
--- a/sdk/android/src/jni/audio_device/aaudio_recorder.cc
+++ b/sdk/android/src/jni/audio_device/aaudio_recorder.cc
@@ -31,19 +31,19 @@
: main_thread_(rtc::Thread::Current()),
aaudio_(audio_parameters, AAUDIO_DIRECTION_INPUT, this) {
RTC_LOG(INFO) << "ctor";
- thread_checker_aaudio_.DetachFromThread();
+ thread_checker_aaudio_.Detach();
}
AAudioRecorder::~AAudioRecorder() {
RTC_LOG(INFO) << "dtor";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
Terminate();
RTC_LOG(INFO) << "detected owerflows: " << overflow_count_;
}
int AAudioRecorder::Init() {
RTC_LOG(INFO) << "Init";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (aaudio_.audio_parameters().channels() == 2) {
RTC_DLOG(LS_WARNING) << "Stereo mode is enabled";
}
@@ -52,14 +52,14 @@
int AAudioRecorder::Terminate() {
RTC_LOG(INFO) << "Terminate";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
StopRecording();
return 0;
}
int AAudioRecorder::InitRecording() {
RTC_LOG(INFO) << "InitRecording";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(!initialized_);
RTC_DCHECK(!recording_);
if (!aaudio_.Init()) {
@@ -75,7 +75,7 @@
int AAudioRecorder::StartRecording() {
RTC_LOG(INFO) << "StartRecording";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(initialized_);
RTC_DCHECK(!recording_);
if (fine_audio_buffer_) {
@@ -92,14 +92,14 @@
int AAudioRecorder::StopRecording() {
RTC_LOG(INFO) << "StopRecording";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (!initialized_ || !recording_) {
return 0;
}
if (!aaudio_.Stop()) {
return -1;
}
- thread_checker_aaudio_.DetachFromThread();
+ thread_checker_aaudio_.Detach();
initialized_ = false;
recording_ = false;
return 0;
@@ -111,7 +111,7 @@
void AAudioRecorder::AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) {
RTC_LOG(INFO) << "AttachAudioBuffer";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
audio_device_buffer_ = audioBuffer;
const AudioParameters audio_parameters = aaudio_.audio_parameters();
audio_device_buffer_->SetRecordingSampleRate(audio_parameters.sample_rate());
@@ -145,7 +145,7 @@
void AAudioRecorder::OnErrorCallback(aaudio_result_t error) {
RTC_LOG(LS_ERROR) << "OnErrorCallback: " << AAudio_convertResultToText(error);
- // RTC_DCHECK(thread_checker_aaudio_.CalledOnValidThread());
+ // RTC_DCHECK(thread_checker_aaudio_.IsCurrent());
if (aaudio_.stream_state() == AAUDIO_STREAM_STATE_DISCONNECTED) {
// The stream is disconnected and any attempt to use it will return
// AAUDIO_ERROR_DISCONNECTED..
@@ -165,7 +165,7 @@
void* audio_data,
int32_t num_frames) {
// TODO(henrika): figure out why we sometimes hit this one.
- // RTC_DCHECK(thread_checker_aaudio_.CalledOnValidThread());
+ // RTC_DCHECK(thread_checker_aaudio_.IsCurrent());
// RTC_LOG(INFO) << "OnDataCallback: " << num_frames;
// Drain the input buffer at first callback to ensure that it does not
// contain any old data. Will also ensure that the lowest possible latency
diff --git a/sdk/android/src/jni/audio_device/aaudio_wrapper.cc b/sdk/android/src/jni/audio_device/aaudio_wrapper.cc
index 99a2a7f..8ce720f 100644
--- a/sdk/android/src/jni/audio_device/aaudio_wrapper.cc
+++ b/sdk/android/src/jni/audio_device/aaudio_wrapper.cc
@@ -139,19 +139,19 @@
observer_(observer) {
RTC_LOG(INFO) << "ctor";
RTC_DCHECK(observer_);
- aaudio_thread_checker_.DetachFromThread();
+ aaudio_thread_checker_.Detach();
RTC_LOG(INFO) << audio_parameters_.ToString();
}
AAudioWrapper::~AAudioWrapper() {
RTC_LOG(INFO) << "dtor";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(!stream_);
}
bool AAudioWrapper::Init() {
RTC_LOG(INFO) << "Init";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
// Creates a stream builder which can be used to open an audio stream.
ScopedStreamBuilder builder;
// Configures the stream builder using audio parameters given at construction.
@@ -175,7 +175,7 @@
bool AAudioWrapper::Start() {
RTC_LOG(INFO) << "Start";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
// TODO(henrika): this state check might not be needed.
aaudio_stream_state_t current_state = AAudioStream_getState(stream_);
if (current_state != AAUDIO_STREAM_STATE_OPEN) {
@@ -191,11 +191,11 @@
bool AAudioWrapper::Stop() {
RTC_LOG(INFO) << "Stop: " << DirectionToString(direction());
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
// Asynchronous request for the stream to stop.
RETURN_ON_ERROR(AAudioStream_requestStop(stream_), false);
CloseStream();
- aaudio_thread_checker_.DetachFromThread();
+ aaudio_thread_checker_.Detach();
return true;
}
@@ -242,7 +242,7 @@
bool AAudioWrapper::IncreaseOutputBufferSize() {
RTC_LOG(INFO) << "IncreaseBufferSize";
RTC_DCHECK(stream_);
- RTC_DCHECK(aaudio_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(aaudio_thread_checker_.IsCurrent());
RTC_DCHECK_EQ(direction(), AAUDIO_DIRECTION_OUTPUT);
aaudio_result_t buffer_size = AAudioStream_getBufferSizeInFrames(stream_);
// Try to increase size of buffer with one burst to reduce risk of underrun.
@@ -270,7 +270,7 @@
void AAudioWrapper::ClearInputStream(void* audio_data, int32_t num_frames) {
RTC_LOG(INFO) << "ClearInputStream";
RTC_DCHECK(stream_);
- RTC_DCHECK(aaudio_thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(aaudio_thread_checker_.IsCurrent());
RTC_DCHECK_EQ(direction(), AAUDIO_DIRECTION_INPUT);
aaudio_result_t cleared_frames = 0;
do {
@@ -359,7 +359,7 @@
void AAudioWrapper::SetStreamConfiguration(AAudioStreamBuilder* builder) {
RTC_LOG(INFO) << "SetStreamConfiguration";
RTC_DCHECK(builder);
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
// Request usage of default primary output/input device.
// TODO(henrika): verify that default device follows Java APIs.
// https://developer.android.com/reference/android/media/AudioDeviceInfo.html.
diff --git a/sdk/android/src/jni/audio_device/audio_device_module.cc b/sdk/android/src/jni/audio_device/audio_device_module.cc
index 4e69dd5..c0803ff 100644
--- a/sdk/android/src/jni/audio_device/audio_device_module.cc
+++ b/sdk/android/src/jni/audio_device/audio_device_module.cc
@@ -69,7 +69,7 @@
RTC_CHECK(input_);
RTC_CHECK(output_);
RTC_LOG(INFO) << __FUNCTION__;
- thread_checker_.DetachFromThread();
+ thread_checker_.Detach();
}
~AndroidAudioDeviceModule() override { RTC_LOG(INFO) << __FUNCTION__; }
@@ -88,7 +88,7 @@
int32_t Init() override {
RTC_LOG(INFO) << __FUNCTION__;
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
audio_device_buffer_ =
absl::make_unique<AudioDeviceBuffer>(&GlobalTaskQueueFactory());
AttachAudioBuffer();
@@ -119,11 +119,11 @@
RTC_LOG(INFO) << __FUNCTION__;
if (!initialized_)
return 0;
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
int32_t err = input_->Terminate();
err |= output_->Terminate();
initialized_ = false;
- thread_checker_.DetachFromThread();
+ thread_checker_.Detach();
audio_device_buffer_.reset(nullptr);
RTC_DCHECK_EQ(err, 0);
return err;
diff --git a/sdk/android/src/jni/audio_device/audio_record_jni.cc b/sdk/android/src/jni/audio_device/audio_record_jni.cc
index 74c0f36..b27377e 100644
--- a/sdk/android/src/jni/audio_device/audio_record_jni.cc
+++ b/sdk/android/src/jni/audio_device/audio_record_jni.cc
@@ -74,34 +74,34 @@
jni::jlongFromPointer(this));
// Detach from this thread since construction is allowed to happen on a
// different thread.
- thread_checker_.DetachFromThread();
- thread_checker_java_.DetachFromThread();
+ thread_checker_.Detach();
+ thread_checker_java_.Detach();
}
AudioRecordJni::~AudioRecordJni() {
RTC_LOG(INFO) << "dtor";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
Terminate();
}
int32_t AudioRecordJni::Init() {
RTC_LOG(INFO) << "Init";
env_ = AttachCurrentThreadIfNeeded();
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
return 0;
}
int32_t AudioRecordJni::Terminate() {
RTC_LOG(INFO) << "Terminate";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
StopRecording();
- thread_checker_.DetachFromThread();
+ thread_checker_.Detach();
return 0;
}
int32_t AudioRecordJni::InitRecording() {
RTC_LOG(INFO) << "InitRecording";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (initialized_) {
// Already initialized.
return 0;
@@ -133,7 +133,7 @@
int32_t AudioRecordJni::StartRecording() {
RTC_LOG(INFO) << "StartRecording";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (recording_) {
// Already recording.
return 0;
@@ -154,7 +154,7 @@
int32_t AudioRecordJni::StopRecording() {
RTC_LOG(INFO) << "StopRecording";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (!initialized_ || !recording_) {
return 0;
}
@@ -165,7 +165,7 @@
// If we don't detach here, we will hit a RTC_DCHECK in OnDataIsRecorded()
// next time StartRecording() is called since it will create a new Java
// thread.
- thread_checker_java_.DetachFromThread();
+ thread_checker_java_.Detach();
initialized_ = false;
recording_ = false;
direct_buffer_address_ = nullptr;
@@ -178,7 +178,7 @@
void AudioRecordJni::AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) {
RTC_LOG(INFO) << "AttachAudioBuffer";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
audio_device_buffer_ = audioBuffer;
const int sample_rate_hz = audio_parameters_.sample_rate();
RTC_LOG(INFO) << "SetRecordingSampleRate(" << sample_rate_hz << ")";
@@ -189,20 +189,20 @@
}
bool AudioRecordJni::IsAcousticEchoCancelerSupported() const {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
return Java_WebRtcAudioRecord_isAcousticEchoCancelerSupported(
env_, j_audio_record_);
}
bool AudioRecordJni::IsNoiseSuppressorSupported() const {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
return Java_WebRtcAudioRecord_isNoiseSuppressorSupported(env_,
j_audio_record_);
}
int32_t AudioRecordJni::EnableBuiltInAEC(bool enable) {
RTC_LOG(INFO) << "EnableBuiltInAEC(" << enable << ")";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
return Java_WebRtcAudioRecord_enableBuiltInAEC(env_, j_audio_record_, enable)
? 0
: -1;
@@ -210,7 +210,7 @@
int32_t AudioRecordJni::EnableBuiltInNS(bool enable) {
RTC_LOG(INFO) << "EnableBuiltInNS(" << enable << ")";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
return Java_WebRtcAudioRecord_enableBuiltInNS(env_, j_audio_record_, enable)
? 0
: -1;
@@ -221,7 +221,7 @@
const JavaParamRef<jobject>& j_caller,
const JavaParamRef<jobject>& byte_buffer) {
RTC_LOG(INFO) << "OnCacheDirectBufferAddress";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(!direct_buffer_address_);
direct_buffer_address_ = env->GetDirectBufferAddress(byte_buffer.obj());
jlong capacity = env->GetDirectBufferCapacity(byte_buffer.obj());
@@ -234,7 +234,7 @@
void AudioRecordJni::DataIsRecorded(JNIEnv* env,
const JavaParamRef<jobject>& j_caller,
int length) {
- RTC_DCHECK(thread_checker_java_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_java_.IsCurrent());
if (!audio_device_buffer_) {
RTC_LOG(LS_ERROR) << "AttachAudioBuffer has not been called";
return;
diff --git a/sdk/android/src/jni/audio_device/audio_track_jni.cc b/sdk/android/src/jni/audio_device/audio_track_jni.cc
index f48673f..70acb5b 100644
--- a/sdk/android/src/jni/audio_device/audio_track_jni.cc
+++ b/sdk/android/src/jni/audio_device/audio_track_jni.cc
@@ -48,34 +48,34 @@
jni::jlongFromPointer(this));
// Detach from this thread since construction is allowed to happen on a
// different thread.
- thread_checker_.DetachFromThread();
- thread_checker_java_.DetachFromThread();
+ thread_checker_.Detach();
+ thread_checker_java_.Detach();
}
AudioTrackJni::~AudioTrackJni() {
RTC_LOG(INFO) << "dtor";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
Terminate();
}
int32_t AudioTrackJni::Init() {
RTC_LOG(INFO) << "Init";
env_ = AttachCurrentThreadIfNeeded();
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
return 0;
}
int32_t AudioTrackJni::Terminate() {
RTC_LOG(INFO) << "Terminate";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
StopPlayout();
- thread_checker_.DetachFromThread();
+ thread_checker_.Detach();
return 0;
}
int32_t AudioTrackJni::InitPlayout() {
RTC_LOG(INFO) << "InitPlayout";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (initialized_) {
// Already initialized.
return 0;
@@ -97,7 +97,7 @@
int32_t AudioTrackJni::StartPlayout() {
RTC_LOG(INFO) << "StartPlayout";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (playing_) {
// Already playing.
return 0;
@@ -117,7 +117,7 @@
int32_t AudioTrackJni::StopPlayout() {
RTC_LOG(INFO) << "StopPlayout";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (!initialized_ || !playing_) {
return 0;
}
@@ -127,7 +127,7 @@
}
// If we don't detach here, we will hit a RTC_DCHECK next time StartPlayout()
// is called since it will create a new Java thread.
- thread_checker_java_.DetachFromThread();
+ thread_checker_java_.Detach();
initialized_ = false;
playing_ = false;
direct_buffer_address_ = nullptr;
@@ -144,7 +144,7 @@
int AudioTrackJni::SetSpeakerVolume(uint32_t volume) {
RTC_LOG(INFO) << "SetSpeakerVolume(" << volume << ")";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
return Java_WebRtcAudioTrack_setStreamVolume(env_, j_audio_track_,
static_cast<int>(volume))
? 0
@@ -152,17 +152,17 @@
}
absl::optional<uint32_t> AudioTrackJni::MaxSpeakerVolume() const {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
return Java_WebRtcAudioTrack_getStreamMaxVolume(env_, j_audio_track_);
}
absl::optional<uint32_t> AudioTrackJni::MinSpeakerVolume() const {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
return 0;
}
absl::optional<uint32_t> AudioTrackJni::SpeakerVolume() const {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
const uint32_t volume =
Java_WebRtcAudioTrack_getStreamVolume(env_, j_audio_track_);
RTC_LOG(INFO) << "SpeakerVolume: " << volume;
@@ -172,7 +172,7 @@
// TODO(henrika): possibly add stereo support.
void AudioTrackJni::AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) {
RTC_LOG(INFO) << "AttachAudioBuffer";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
audio_device_buffer_ = audioBuffer;
const int sample_rate_hz = audio_parameters_.sample_rate();
RTC_LOG(INFO) << "SetPlayoutSampleRate(" << sample_rate_hz << ")";
@@ -187,7 +187,7 @@
const JavaParamRef<jobject>&,
const JavaParamRef<jobject>& byte_buffer) {
RTC_LOG(INFO) << "OnCacheDirectBufferAddress";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(!direct_buffer_address_);
direct_buffer_address_ = env->GetDirectBufferAddress(byte_buffer.obj());
jlong capacity = env->GetDirectBufferCapacity(byte_buffer.obj());
@@ -203,7 +203,7 @@
void AudioTrackJni::GetPlayoutData(JNIEnv* env,
const JavaParamRef<jobject>&,
size_t length) {
- RTC_DCHECK(thread_checker_java_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_java_.IsCurrent());
const size_t bytes_per_frame = audio_parameters_.channels() * sizeof(int16_t);
RTC_DCHECK_EQ(frames_per_buffer_, length / bytes_per_frame);
if (!audio_device_buffer_) {
diff --git a/sdk/android/src/jni/audio_device/opensles_common.cc b/sdk/android/src/jni/audio_device/opensles_common.cc
index ba07131..04c3ae9 100644
--- a/sdk/android/src/jni/audio_device/opensles_common.cc
+++ b/sdk/android/src/jni/audio_device/opensles_common.cc
@@ -103,14 +103,14 @@
}
OpenSLEngineManager::OpenSLEngineManager() {
- thread_checker_.DetachFromThread();
+ thread_checker_.Detach();
}
OpenSLEngineManager::~OpenSLEngineManager() = default;
SLObjectItf OpenSLEngineManager::GetOpenSLEngine() {
RTC_LOG(INFO) << "GetOpenSLEngine";
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
// OpenSL ES for Android only supports a single engine per application.
// If one already has been created, return existing object instead of
// creating a new.
diff --git a/sdk/android/src/jni/audio_device/opensles_player.cc b/sdk/android/src/jni/audio_device/opensles_player.cc
index ea6bbc6..ce43d1a 100644
--- a/sdk/android/src/jni/audio_device/opensles_player.cc
+++ b/sdk/android/src/jni/audio_device/opensles_player.cc
@@ -64,12 +64,12 @@
audio_parameters_.bits_per_sample());
// Detach from this thread since we want to use the checker to verify calls
// from the internal audio thread.
- thread_checker_opensles_.DetachFromThread();
+ thread_checker_opensles_.Detach();
}
OpenSLESPlayer::~OpenSLESPlayer() {
ALOGD("dtor[tid=%d]", rtc::CurrentThreadId());
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
Terminate();
DestroyAudioPlayer();
DestroyMix();
@@ -83,7 +83,7 @@
int OpenSLESPlayer::Init() {
ALOGD("Init[tid=%d]", rtc::CurrentThreadId());
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (audio_parameters_.channels() == 2) {
ALOGW("Stereo mode is enabled");
}
@@ -92,14 +92,14 @@
int OpenSLESPlayer::Terminate() {
ALOGD("Terminate[tid=%d]", rtc::CurrentThreadId());
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
StopPlayout();
return 0;
}
int OpenSLESPlayer::InitPlayout() {
ALOGD("InitPlayout[tid=%d]", rtc::CurrentThreadId());
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(!initialized_);
RTC_DCHECK(!playing_);
if (!ObtainEngineInterface()) {
@@ -118,7 +118,7 @@
int OpenSLESPlayer::StartPlayout() {
ALOGD("StartPlayout[tid=%d]", rtc::CurrentThreadId());
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(initialized_);
RTC_DCHECK(!playing_);
if (fine_audio_buffer_) {
@@ -146,7 +146,7 @@
int OpenSLESPlayer::StopPlayout() {
ALOGD("StopPlayout[tid=%d]", rtc::CurrentThreadId());
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (!initialized_ || !playing_) {
return 0;
}
@@ -164,7 +164,7 @@
// The number of lower latency audio players is limited, hence we create the
// audio player in Start() and destroy it in Stop().
DestroyAudioPlayer();
- thread_checker_opensles_.DetachFromThread();
+ thread_checker_opensles_.Detach();
initialized_ = false;
playing_ = false;
return 0;
@@ -196,7 +196,7 @@
void OpenSLESPlayer::AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) {
ALOGD("AttachAudioBuffer");
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
audio_device_buffer_ = audioBuffer;
const int sample_rate_hz = audio_parameters_.sample_rate();
ALOGD("SetPlayoutSampleRate(%d)", sample_rate_hz);
@@ -210,7 +210,7 @@
void OpenSLESPlayer::AllocateDataBuffers() {
ALOGD("AllocateDataBuffers");
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(!simple_buffer_queue_);
RTC_CHECK(audio_device_buffer_);
// Create a modified audio buffer class which allows us to ask for any number
@@ -235,7 +235,7 @@
bool OpenSLESPlayer::ObtainEngineInterface() {
ALOGD("ObtainEngineInterface");
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (engine_)
return true;
// Get access to (or create if not already existing) the global OpenSL Engine
@@ -254,7 +254,7 @@
bool OpenSLESPlayer::CreateMix() {
ALOGD("CreateMix");
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(engine_);
if (output_mix_.Get())
return true;
@@ -270,7 +270,7 @@
void OpenSLESPlayer::DestroyMix() {
ALOGD("DestroyMix");
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (!output_mix_.Get())
return;
output_mix_.Reset();
@@ -278,7 +278,7 @@
bool OpenSLESPlayer::CreateAudioPlayer() {
ALOGD("CreateAudioPlayer");
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(output_mix_.Get());
if (player_object_.Get())
return true;
@@ -362,7 +362,7 @@
void OpenSLESPlayer::DestroyAudioPlayer() {
ALOGD("DestroyAudioPlayer");
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (!player_object_.Get())
return;
(*simple_buffer_queue_)
@@ -382,7 +382,7 @@
}
void OpenSLESPlayer::FillBufferQueue() {
- RTC_DCHECK(thread_checker_opensles_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_opensles_.IsCurrent());
SLuint32 state = GetPlayState();
if (state != SL_PLAYSTATE_PLAYING) {
ALOGW("Buffer callback in non-playing state!");
@@ -404,13 +404,13 @@
SLint8* audio_ptr8 =
reinterpret_cast<SLint8*>(audio_buffers_[buffer_index_].get());
if (silence) {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
// Avoid acquiring real audio data from WebRTC and fill the buffer with
// zeros instead. Used to prime the buffer with silence and to avoid asking
// for audio data from two different threads.
memset(audio_ptr8, 0, audio_parameters_.GetBytesPerBuffer());
} else {
- RTC_DCHECK(thread_checker_opensles_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_opensles_.IsCurrent());
// Read audio data from the WebRTC source using the FineAudioBuffer object
// to adjust for differences in buffer size between WebRTC (10ms) and native
// OpenSL ES. Use hardcoded delay estimate since OpenSL ES does not support
diff --git a/sdk/android/src/jni/audio_device/opensles_recorder.cc b/sdk/android/src/jni/audio_device/opensles_recorder.cc
index 1ac2d83..f244690 100644
--- a/sdk/android/src/jni/audio_device/opensles_recorder.cc
+++ b/sdk/android/src/jni/audio_device/opensles_recorder.cc
@@ -59,7 +59,7 @@
ALOGD("ctor[tid=%d]", rtc::CurrentThreadId());
// Detach from this thread since we want to use the checker to verify calls
// from the internal audio thread.
- thread_checker_opensles_.DetachFromThread();
+ thread_checker_opensles_.Detach();
// Use native audio output parameters provided by the audio manager and
// define the PCM format structure.
pcm_format_ = CreatePCMConfiguration(audio_parameters_.channels(),
@@ -69,7 +69,7 @@
OpenSLESRecorder::~OpenSLESRecorder() {
ALOGD("dtor[tid=%d]", rtc::CurrentThreadId());
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
Terminate();
DestroyAudioRecorder();
engine_ = nullptr;
@@ -80,7 +80,7 @@
int OpenSLESRecorder::Init() {
ALOGD("Init[tid=%d]", rtc::CurrentThreadId());
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (audio_parameters_.channels() == 2) {
ALOGD("Stereo mode is enabled");
}
@@ -89,14 +89,14 @@
int OpenSLESRecorder::Terminate() {
ALOGD("Terminate[tid=%d]", rtc::CurrentThreadId());
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
StopRecording();
return 0;
}
int OpenSLESRecorder::InitRecording() {
ALOGD("InitRecording[tid=%d]", rtc::CurrentThreadId());
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(!initialized_);
RTC_DCHECK(!recording_);
if (!ObtainEngineInterface()) {
@@ -115,7 +115,7 @@
int OpenSLESRecorder::StartRecording() {
ALOGD("StartRecording[tid=%d]", rtc::CurrentThreadId());
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(initialized_);
RTC_DCHECK(!recording_);
if (fine_audio_buffer_) {
@@ -152,7 +152,7 @@
int OpenSLESRecorder::StopRecording() {
ALOGD("StopRecording[tid=%d]", rtc::CurrentThreadId());
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (!initialized_ || !recording_) {
return 0;
}
@@ -165,7 +165,7 @@
if (LOG_ON_ERROR((*simple_buffer_queue_)->Clear(simple_buffer_queue_))) {
return -1;
}
- thread_checker_opensles_.DetachFromThread();
+ thread_checker_opensles_.Detach();
initialized_ = false;
recording_ = false;
return 0;
@@ -177,7 +177,7 @@
void OpenSLESRecorder::AttachAudioBuffer(AudioDeviceBuffer* audio_buffer) {
ALOGD("AttachAudioBuffer");
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_CHECK(audio_buffer);
audio_device_buffer_ = audio_buffer;
// Ensure that the audio device buffer is informed about the native sample
@@ -204,21 +204,21 @@
int OpenSLESRecorder::EnableBuiltInAEC(bool enable) {
ALOGD("EnableBuiltInAEC(%d)", enable);
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
ALOGE("Not implemented");
return 0;
}
int OpenSLESRecorder::EnableBuiltInNS(bool enable) {
ALOGD("EnableBuiltInNS(%d)", enable);
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
ALOGE("Not implemented");
return 0;
}
bool OpenSLESRecorder::ObtainEngineInterface() {
ALOGD("ObtainEngineInterface");
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (engine_)
return true;
// Get access to (or create if not already existing) the global OpenSL Engine
@@ -239,7 +239,7 @@
bool OpenSLESRecorder::CreateAudioRecorder() {
ALOGD("CreateAudioRecorder");
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (recorder_object_.Get())
return true;
RTC_DCHECK(!recorder_);
@@ -320,7 +320,7 @@
void OpenSLESRecorder::DestroyAudioRecorder() {
ALOGD("DestroyAudioRecorder");
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
if (!recorder_object_.Get())
return;
(*simple_buffer_queue_)
@@ -339,7 +339,7 @@
void OpenSLESRecorder::AllocateDataBuffers() {
ALOGD("AllocateDataBuffers");
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(!simple_buffer_queue_);
RTC_CHECK(audio_device_buffer_);
// Create a modified audio buffer class which allows us to deliver any number
@@ -364,7 +364,7 @@
}
void OpenSLESRecorder::ReadBufferQueue() {
- RTC_DCHECK(thread_checker_opensles_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_opensles_.IsCurrent());
SLuint32 state = GetRecordState();
if (state != SL_RECORDSTATE_RECORDING) {
ALOGW("Buffer callback in non-recording state!");
diff --git a/sdk/android/src/jni/video_decoder_wrapper.cc b/sdk/android/src/jni/video_decoder_wrapper.cc
index 0bdfe35..e314074 100644
--- a/sdk/android/src/jni/video_decoder_wrapper.cc
+++ b/sdk/android/src/jni/video_decoder_wrapper.cc
@@ -49,7 +49,7 @@
// if the decoder provides frames.
{
- decoder_thread_checker_.DetachFromThread();
+ decoder_thread_checker_.Detach();
}
VideoDecoderWrapper::~VideoDecoderWrapper() = default;
@@ -141,7 +141,7 @@
}
initialized_ = false;
// It is allowed to reinitialize the codec on a different thread.
- decoder_thread_checker_.DetachFromThread();
+ decoder_thread_checker_.Detach();
return status;
}
diff --git a/sdk/objc/native/src/audio/audio_device_ios.mm b/sdk/objc/native/src/audio/audio_device_ios.mm
index 5df7b8f..e8b3725 100644
--- a/sdk/objc/native/src/audio/audio_device_ios.mm
+++ b/sdk/objc/native/src/audio/audio_device_ios.mm
@@ -115,15 +115,15 @@
num_playout_callbacks_(0),
last_output_volume_change_time_(0) {
LOGI() << "ctor" << ios::GetCurrentThreadDescription();
- io_thread_checker_.DetachFromThread();
- thread_checker_.DetachFromThread();
+ io_thread_checker_.Detach();
+ thread_checker_.Detach();
thread_ = rtc::Thread::Current();
audio_session_observer_ = [[RTCNativeAudioSessionDelegateAdapter alloc] initWithObserver:this];
}
AudioDeviceIOS::~AudioDeviceIOS() {
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
LOGI() << "~dtor" << ios::GetCurrentThreadDescription();
Terminate();
audio_session_observer_ = nil;
@@ -132,14 +132,14 @@
void AudioDeviceIOS::AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) {
LOGI() << "AttachAudioBuffer";
RTC_DCHECK(audioBuffer);
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
audio_device_buffer_ = audioBuffer;
}
AudioDeviceGeneric::InitStatus AudioDeviceIOS::Init() {
LOGI() << "Init";
- io_thread_checker_.DetachFromThread();
- thread_checker_.DetachFromThread();
+ io_thread_checker_.Detach();
+ thread_checker_.Detach();
RTC_DCHECK_RUN_ON(&thread_checker_);
if (initialized_) {
@@ -322,7 +322,7 @@
int AudioDeviceIOS::GetPlayoutAudioParameters(AudioParameters* params) const {
LOGI() << "GetPlayoutAudioParameters";
RTC_DCHECK(playout_parameters_.is_valid());
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
*params = playout_parameters_;
return 0;
}
@@ -330,7 +330,7 @@
int AudioDeviceIOS::GetRecordAudioParameters(AudioParameters* params) const {
LOGI() << "GetRecordAudioParameters";
RTC_DCHECK(record_parameters_.is_valid());
- RTC_DCHECK(thread_checker_.CalledOnValidThread());
+ RTC_DCHECK(thread_checker_.IsCurrent());
*params = record_parameters_;
return 0;
}
@@ -911,7 +911,7 @@
// Detach thread checker for the AURemoteIO::IOThread to ensure that the
// next session uses a fresh thread id.
- io_thread_checker_.DetachFromThread();
+ io_thread_checker_.Detach();
// Remove audio session notification observers.
RTCAudioSession* session = [RTCAudioSession sharedInstance];
@@ -928,7 +928,7 @@
// restart. It will result in audio callbacks from a new native I/O thread
// which means that we must detach thread checkers here to be prepared for an
// upcoming new audio stream.
- io_thread_checker_.DetachFromThread();
+ io_thread_checker_.Detach();
}
bool AudioDeviceIOS::IsInterrupted() {
diff --git a/test/scenario/network/network_emulation.cc b/test/scenario/network/network_emulation.cc
index 7296439..323e79c 100644
--- a/test/scenario/network/network_emulation.cc
+++ b/test/scenario/network/network_emulation.cc
@@ -185,7 +185,7 @@
prefix_length, rtc::AdapterType::ADAPTER_TYPE_UNKNOWN);
network_->AddIP(ip);
- enabled_state_checker_.DetachFromThread();
+ enabled_state_checker_.Detach();
}
EmulatedEndpoint::~EmulatedEndpoint() = default;
diff --git a/video/call_stats.cc b/video/call_stats.cc
index 034bf08..ce93d04 100644
--- a/video/call_stats.cc
+++ b/video/call_stats.cc
@@ -101,7 +101,7 @@
process_thread_(process_thread),
process_thread_running_(false) {
RTC_DCHECK(process_thread_);
- process_thread_checker_.DetachFromThread();
+ process_thread_checker_.Detach();
}
CallStats::~CallStats() {
@@ -151,7 +151,7 @@
// |process_thread_checker_| so that it can be used to protect variables
// in either the process thread when it starts again, or UpdateHistograms()
// (mutually exclusive).
- process_thread_checker_.DetachFromThread();
+ process_thread_checker_.Detach();
}
void CallStats::RegisterStatsObserver(CallStatsObserver* observer) {
diff --git a/video/receive_statistics_proxy.cc b/video/receive_statistics_proxy.cc
index 538bd78..ba327cc 100644
--- a/video/receive_statistics_proxy.cc
+++ b/video/receive_statistics_proxy.cc
@@ -117,8 +117,8 @@
num_delayed_frames_rendered_(0),
sum_missed_render_deadline_ms_(0),
timing_frame_info_counter_(kMovingMaxWindowMs) {
- decode_thread_.DetachFromThread();
- network_thread_.DetachFromThread();
+ decode_thread_.Detach();
+ network_thread_.Detach();
stats_.ssrc = config_.rtp.remote_ssrc;
// TODO(brandtr): Replace |rtx_stats_| with a single instance of
// StreamDataCounters.
@@ -880,7 +880,7 @@
void ReceiveStatisticsProxy::DecoderThreadStopped() {
RTC_DCHECK_RUN_ON(&main_thread_);
- decode_thread_.DetachFromThread();
+ decode_thread_.Detach();
}
ReceiveStatisticsProxy::ContentSpecificStats::ContentSpecificStats()
diff --git a/video/rtp_streams_synchronizer.cc b/video/rtp_streams_synchronizer.cc
index 9646f9d..8d0d4ac 100644
--- a/video/rtp_streams_synchronizer.cc
+++ b/video/rtp_streams_synchronizer.cc
@@ -40,7 +40,7 @@
sync_(),
last_sync_time_(rtc::TimeNanos()) {
RTC_DCHECK(syncable_video);
- process_thread_checker_.DetachFromThread();
+ process_thread_checker_.Detach();
}
RtpStreamsSynchronizer::~RtpStreamsSynchronizer() = default;