Replaced thread checker with race checker in AudioMixer.

webrtc/modules/audio_mixer/audio_mixer_impl.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 125 matching lines @@
 }
 
 }  // namespace
 
 AudioMixerImpl::AudioMixerImpl(std::unique_ptr<AudioProcessing> limiter)
     : audio_source_list_(),
       use_limiter_(true),
       time_stamp_(0),
       limiter_(std::move(limiter)) {
   SetOutputFrequency(kDefaultFrequency);
-  thread_checker_.DetachFromThread();
 }
 
 AudioMixerImpl::~AudioMixerImpl() {}
 
 rtc::scoped_refptr<AudioMixerImpl> AudioMixerImpl::Create() {
   Config config;
   config.Set<ExperimentalAgc>(new ExperimentalAgc(false));
   std::unique_ptr<AudioProcessing> limiter(AudioProcessing::Create(config));
   if (!limiter.get()) {
     return nullptr;
@@ skipping 25 matching lines @@
   }
 
   return rtc::scoped_refptr<AudioMixerImpl>(
       new rtc::RefCountedObject<AudioMixerImpl>(std::move(limiter)));
 }
 
 void AudioMixerImpl::Mix(int sample_rate,
                          size_t number_of_channels,
                          AudioFrame* audio_frame_for_mixing) {
   RTC_DCHECK(number_of_channels == 1 || number_of_channels == 2);
-  RTC_DCHECK_RUN_ON(&thread_checker_);
+  RTC_DCHECK_RUNS_SERIALIZED(&race_checker_);
 
   if (OutputFrequency() != sample_rate) {
     SetOutputFrequency(sample_rate);
   }
 
   AudioFrameList mix_list;
   {
     rtc::CritScope lock(&crit_);
     mix_list = GetAudioFromSources();
   }
@@ skipping 19 matching lines @@
     audio_frame_for_mixing->Mute();
   } else {
     // Only call the limiter if we have something to mix.
     LimitMixedAudio(audio_frame_for_mixing);
   }
 
   return;
 }
 
 void AudioMixerImpl::SetOutputFrequency(int frequency) {
-  RTC_DCHECK_RUN_ON(&thread_checker_);
+  RTC_DCHECK_RUNS_SERIALIZED(&race_checker_);
   output_frequency_ = frequency;
   sample_size_ = (output_frequency_ * kFrameDurationInMs) / 1000;
 }
 
 int AudioMixerImpl::OutputFrequency() const {
-  RTC_DCHECK_RUN_ON(&thread_checker_);
+  RTC_DCHECK_RUNS_SERIALIZED(&race_checker_);
   return output_frequency_;
 }
 
 bool AudioMixerImpl::AddSource(Source* audio_source) {
   RTC_DCHECK(audio_source);
   rtc::CritScope lock(&crit_);
   RTC_DCHECK(FindSourceInList(audio_source, &audio_source_list_) ==
              audio_source_list_.end())
       << "Source already added to mixer";
   audio_source_list_.emplace_back(audio_source, false, 0);
   return true;
 }
 
 bool AudioMixerImpl::RemoveSource(Source* audio_source) {
   RTC_DCHECK(audio_source);
   rtc::CritScope lock(&crit_);
   const auto iter = FindSourceInList(audio_source, &audio_source_list_);
   RTC_DCHECK(iter != audio_source_list_.end()) << "Source not present in mixer";
   audio_source_list_.erase(iter);
   return true;
 }
 
 AudioFrameList AudioMixerImpl::GetAudioFromSources() {
-  RTC_DCHECK_RUN_ON(&thread_checker_);
+  RTC_DCHECK_RUNS_SERIALIZED(&race_checker_);
   AudioFrameList result;
   std::vector<SourceFrame> audio_source_mixing_data_list;
   std::vector<SourceFrame> ramp_list;
 
   // Get audio source audio and put it in the struct vector.
   for (auto& source_and_status : audio_source_list_) {
     auto audio_frame_with_info =
         source_and_status.audio_source->GetAudioFrameWithInfo(
             static_cast<int>(OutputFrequency()));
 
@@ skipping 32 matching lines @@
       is_mixed = true;
     }
     p.source_status->is_mixed = is_mixed;
   }
   RampAndUpdateGain(ramp_list);
   return result;
 }
 
 
 bool AudioMixerImpl::LimitMixedAudio(AudioFrame* mixed_audio) const {
-  RTC_DCHECK_RUN_ON(&thread_checker_);
+  RTC_DCHECK_RUNS_SERIALIZED(&race_checker_);
   if (!use_limiter_) {
     return true;
   }
 
   // Smoothly limit the mixed frame.
   const int error = limiter_->ProcessStream(mixed_audio);
 
   // And now we can safely restore the level. This procedure results in
   // some loss of resolution, deemed acceptable.
   //
   // It's possible to apply the gain in the AGC (with a target level of 0 dbFS
   // and compression gain of 6 dB). However, in the transition frame when this
   // is enabled (moving from one to two audio sources) it has the potential to
   // create discontinuities in the mixed frame.
   //
   // Instead we double the frame (with addition since left-shifting a
   // negative value is undefined).
   *mixed_audio += *mixed_audio;
 
   if (error != limiter_->kNoError) {
     LOG_F(LS_ERROR) << "Error from AudioProcessing: " << error;
     RTC_NOTREACHED();
     return false;
   }
   return true;
 }
 
 bool AudioMixerImpl::GetAudioSourceMixabilityStatusForTest(
     AudioMixerImpl::Source* audio_source) const {
-  RTC_DCHECK_RUN_ON(&thread_checker_);
+  RTC_DCHECK_RUNS_SERIALIZED(&race_checker_);
   rtc::CritScope lock(&crit_);
 
   const auto non_anonymous_iter =
       FindSourceInList(audio_source, &audio_source_list_);
   if (non_anonymous_iter != audio_source_list_.end()) {
     return non_anonymous_iter->is_mixed;
   }
 
   LOG(LS_ERROR) << "Audio source unknown";
   return false;
 }
 }  // namespace webrtc