Add RTC_ prefix to (D)CHECKs and related macros.

webrtc/modules/audio_device/fine_audio_buffer.cc

 /*
  *  Copyright (c) 2013 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 52 matching lines @@
   record_write_pos_ = 0;
   memset(record_cache_buffer_.get(), 0, required_record_buffer_size_bytes_);
 }
 
 void FineAudioBuffer::GetPlayoutData(int8_t* buffer) {
   if (desired_frame_size_bytes_ <= playout_cached_bytes_) {
     memcpy(buffer, &playout_cache_buffer_.get()[playout_cached_buffer_start_],
            desired_frame_size_bytes_);
     playout_cached_buffer_start_ += desired_frame_size_bytes_;
     playout_cached_bytes_ -= desired_frame_size_bytes_;
-    CHECK_LT(playout_cached_buffer_start_ + playout_cached_bytes_,
-             bytes_per_10_ms_);
+    RTC_CHECK_LT(playout_cached_buffer_start_ + playout_cached_bytes_,
+                 bytes_per_10_ms_);
     return;
   }
   memcpy(buffer, &playout_cache_buffer_.get()[playout_cached_buffer_start_],
          playout_cached_bytes_);
   // Push another n*10ms of audio to |buffer|. n > 1 if
   // |desired_frame_size_bytes_| is greater than 10ms of audio. Note that we
   // write the audio after the cached bytes copied earlier.
   int8_t* unwritten_buffer = &buffer[playout_cached_bytes_];
   int bytes_left =
       static_cast<int>(desired_frame_size_bytes_ - playout_cached_bytes_);
   // Ceiling of integer division: 1 + ((x - 1) / y)
   size_t number_of_requests = 1 + (bytes_left - 1) / (bytes_per_10_ms_);
   for (size_t i = 0; i < number_of_requests; ++i) {
     device_buffer_->RequestPlayoutData(samples_per_10_ms_);
     int num_out = device_buffer_->GetPlayoutData(unwritten_buffer);
     if (static_cast<size_t>(num_out) != samples_per_10_ms_) {
-      CHECK_EQ(num_out, 0);
+      RTC_CHECK_EQ(num_out, 0);
       playout_cached_bytes_ = 0;
       return;
     }
     unwritten_buffer += bytes_per_10_ms_;
-    CHECK_GE(bytes_left, 0);
+    RTC_CHECK_GE(bytes_left, 0);
     bytes_left -= static_cast<int>(bytes_per_10_ms_);
   }
-  CHECK_LE(bytes_left, 0);
+  RTC_CHECK_LE(bytes_left, 0);
   // Put the samples that were written to |buffer| but are not used in the
   // cache.
   size_t cache_location = desired_frame_size_bytes_;
   int8_t* cache_ptr = &buffer[cache_location];
   playout_cached_bytes_ = number_of_requests * bytes_per_10_ms_ -
                           (desired_frame_size_bytes_ - playout_cached_bytes_);
   // If playout_cached_bytes_ is larger than the cache buffer, uninitialized
   // memory will be read.
-  CHECK_LE(playout_cached_bytes_, bytes_per_10_ms_);
-  CHECK_EQ(static_cast<size_t>(-bytes_left), playout_cached_bytes_);
+  RTC_CHECK_LE(playout_cached_bytes_, bytes_per_10_ms_);
+  RTC_CHECK_EQ(static_cast<size_t>(-bytes_left), playout_cached_bytes_);
   playout_cached_buffer_start_ = 0;
   memcpy(playout_cache_buffer_.get(), cache_ptr, playout_cached_bytes_);
 }
 
 void FineAudioBuffer::DeliverRecordedData(const int8_t* buffer,
                                           size_t size_in_bytes,
                                           int playout_delay_ms,
                                           int record_delay_ms) {
-  CHECK_EQ(size_in_bytes, desired_frame_size_bytes_);
+  RTC_CHECK_EQ(size_in_bytes, desired_frame_size_bytes_);
   // Check if the temporary buffer can store the incoming buffer. If not,
   // move the remaining (old) bytes to the beginning of the temporary buffer
   // and start adding new samples after the old samples.
   if (record_write_pos_ + size_in_bytes > required_record_buffer_size_bytes_) {
     if (record_cached_bytes_ > 0) {
       memmove(record_cache_buffer_.get(),
               record_cache_buffer_.get() + record_read_pos_,
               record_cached_bytes_);
     }
     record_write_pos_ = record_cached_bytes_;
@@ skipping 12 matching lines @@
     device_buffer_->SetVQEData(playout_delay_ms, record_delay_ms, 0);
     device_buffer_->DeliverRecordedData();
     // Read next chunk of 10ms data.
     record_read_pos_ += bytes_per_10_ms_;
     // Reduce number of cached bytes with the consumed amount.
     record_cached_bytes_ -= bytes_per_10_ms_;
   }
 }
 
 }  // namespace webrtc