Preparational work for an upcoming addition of a threadchecking scheme for APM

webrtc/modules/audio_processing/echo_control_mobile_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 48 matching lines @@
 }  // namespace
 
 const size_t EchoControlMobileImpl::kAllowedValuesOfSamplesPerFrame1;
 const size_t EchoControlMobileImpl::kAllowedValuesOfSamplesPerFrame2;
 
 size_t EchoControlMobile::echo_path_size_bytes() {
     return WebRtcAecm_echo_path_size_bytes();
 }
 
 EchoControlMobileImpl::EchoControlMobileImpl(const AudioProcessing* apm,
-                                             CriticalSectionWrapper* crit)
+                                             CriticalSectionWrapper* crit,
+                                             rtc::ThreadChecker* render_thread,
+                                             rtc::ThreadChecker* capture_thread)
     : ProcessingComponent(),
       apm_(apm),
       crit_(crit),
+      render_thread_(render_thread),
+      capture_thread_(capture_thread),
       routing_mode_(kSpeakerphone),
       comfort_noise_enabled_(true),
       external_echo_path_(NULL),
       render_queue_element_max_size_(0) {
   AllocateRenderQueue();
 }
 
 EchoControlMobileImpl::~EchoControlMobileImpl() {
     if (external_echo_path_ != NULL) {
       delete [] external_echo_path_;
       external_echo_path_ = NULL;
     }
 }
 
 int EchoControlMobileImpl::ProcessRenderAudio(const AudioBuffer* audio) {
+  RTC_DCHECK(render_thread_->CalledOnValidThread());
   if (!is_component_enabled()) {
     return apm_->kNoError;
   }
 
   assert(audio->num_frames_per_band() <= 160);
   assert(audio->num_channels() == apm_->num_reverse_channels());
 
   int err = apm_->kNoError;
 
   // The ordering convention must be followed to pass to the correct AECM.
@@ skipping 26 matching lines @@
 
   render_queue_buffer_.resize(buffer_index);
   render_signal_queue_->Insert(&render_queue_buffer_);
 
   return apm_->kNoError;
 }
 
 // Read chunks of data that were received and queued on the render side from
 // a queue. All the data chunks are buffered into the farend signal of the AEC.
 void EchoControlMobileImpl::ReadQueuedRenderData() {
+  RTC_DCHECK(capture_thread_->CalledOnValidThread());
   if (!is_component_enabled()) {
     return;
   }
 
   bool samples_read = render_signal_queue_->Remove(&capture_queue_buffer_);
   while (samples_read) {
     size_t handle_index = 0;
     int buffer_index = 0;
     const int num_frames_per_band =
         capture_queue_buffer_.size() /
         (apm_->num_output_channels() * apm_->num_reverse_channels());
     for (int i = 0; i < apm_->num_output_channels(); i++) {
       for (int j = 0; j < apm_->num_reverse_channels(); j++) {
         Handle* my_handle = static_cast<Handle*>(handle(handle_index));
         (void)WebRtcAecm_BufferFarend(my_handle,
                                       &capture_queue_buffer_[buffer_index],
                                       num_frames_per_band);
 
         buffer_index += num_frames_per_band;
         handle_index++;
       }
     }
   }
 }
 
 int EchoControlMobileImpl::ProcessCaptureAudio(AudioBuffer* audio) {
+  RTC_DCHECK(capture_thread_->CalledOnValidThread());
   if (!is_component_enabled()) {
     return apm_->kNoError;
   }
 
   if (!apm_->was_stream_delay_set()) {
     return apm_->kStreamParameterNotSetError;
   }
 
   assert(audio->num_frames_per_band() <= 160);
   assert(audio->num_channels() == apm_->num_output_channels());
@@ skipping 194 matching lines @@
   return apm_->num_output_channels() *
          apm_->num_reverse_channels();
 }
 
 int EchoControlMobileImpl::GetHandleError(void* handle) const {
   assert(handle != NULL);
   return AudioProcessing::kUnspecifiedError;
 }
 
 }  // namespace webrtc