Replace use of ASSERT in test code.

webrtc/api/test/fakeaudiocapturemodule.cc

 /*
  *  Copyright 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 621 matching lines @@
   } else {
     if (process_thread_) {
       process_thread_->Stop();
       process_thread_.reset(nullptr);
     }
     started_ = false;
   }
 }
 
 void FakeAudioCaptureModule::StartProcessP() {
-  ASSERT(process_thread_->IsCurrent());
+  RTC_CHECK(process_thread_->IsCurrent());
   if (started_) {
     // Already started.
     return;
   }
   ProcessFrameP();
 }
 
 void FakeAudioCaptureModule::ProcessFrameP() {
-  ASSERT(process_thread_->IsCurrent());
+  RTC_CHECK(process_thread_->IsCurrent());
   if (!started_) {
     next_frame_time_ = rtc::TimeMillis();
     started_ = true;
   }
 
   {
     rtc::CritScope cs(&crit_);
     // Receive and send frames every kTimePerFrameMs.
     if (playing_) {
       ReceiveFrameP();
     }
     if (recording_) {
       SendFrameP();
     }
   }
 
   next_frame_time_ += kTimePerFrameMs;
   const int64_t current_time = rtc::TimeMillis();
   const int64_t wait_time =
       (next_frame_time_ > current_time) ? next_frame_time_ - current_time : 0;
   process_thread_->PostDelayed(RTC_FROM_HERE, wait_time, this, MSG_RUN_PROCESS);
 }
 
 void FakeAudioCaptureModule::ReceiveFrameP() {
-  ASSERT(process_thread_->IsCurrent());
+  RTC_CHECK(process_thread_->IsCurrent());
   {
     rtc::CritScope cs(&crit_callback_);
     if (!audio_callback_) {
       return;
     }
     ResetRecBuffer();
     size_t nSamplesOut = 0;
     int64_t elapsed_time_ms = 0;
     int64_t ntp_time_ms = 0;
     if (audio_callback_->NeedMorePlayData(kNumberSamples, kNumberBytesPerSample,
                                          kNumberOfChannels, kSamplesPerSecond,
                                          rec_buffer_, nSamplesOut,
                                          &elapsed_time_ms, &ntp_time_ms) != 0) {
       RTC_NOTREACHED();
     }
-    ASSERT(nSamplesOut == kNumberSamples);
+    RTC_CHECK(nSamplesOut == kNumberSamples);
   }
   // The SetBuffer() function ensures that after decoding, the audio buffer
   // should contain samples of similar magnitude (there is likely to be some
   // distortion due to the audio pipeline). If one sample is detected to
   // have the same or greater magnitude somewhere in the frame, an actual frame
   // has been received from the remote side (i.e. faked frames are not being
   // pulled).
   if (CheckRecBuffer(kHighSampleValue)) {
     rtc::CritScope cs(&crit_);
     ++frames_received_;
   }
 }
 
 void FakeAudioCaptureModule::SendFrameP() {
-  ASSERT(process_thread_->IsCurrent());
+  RTC_CHECK(process_thread_->IsCurrent());
   rtc::CritScope cs(&crit_callback_);
   if (!audio_callback_) {
     return;
   }
   bool key_pressed = false;
   uint32_t current_mic_level = 0;
   MicrophoneVolume(&current_mic_level);
   if (audio_callback_->RecordedDataIsAvailable(send_buffer_, kNumberSamples,
                                               kNumberBytesPerSample,
                                               kNumberOfChannels,
                                               kSamplesPerSecond, kTotalDelayMs,
                                               kClockDriftMs, current_mic_level,
                                               key_pressed,
                                               current_mic_level) != 0) {
     RTC_NOTREACHED();
   }
   SetMicrophoneVolume(current_mic_level);
 }