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

webrtc/modules/audio_processing/beamformer/matrix.h

 /*
  *  Copyright (c) 2014 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 103 matching lines @@
     }
   }
 
   // Accessors and mutators.
   int num_rows() const { return num_rows_; }
   int num_columns() const { return num_columns_; }
   T* const* elements() { return &elements_[0]; }
   const T* const* elements() const { return &elements_[0]; }
 
   T Trace() {
-    CHECK_EQ(num_rows_, num_columns_);
+    RTC_CHECK_EQ(num_rows_, num_columns_);
 
     T trace = 0;
     for (int i = 0; i < num_rows_; ++i) {
       trace += elements_[i][i];
     }
     return trace;
   }
 
   // Matrix Operations. Returns *this to support method chaining.
   Matrix& Transpose() {
     CopyDataToScratch();
     Resize(num_columns_, num_rows_);
     return Transpose(scratch_elements());
   }
 
   Matrix& Transpose(const Matrix& operand) {
-    CHECK_EQ(operand.num_rows_, num_columns_);
-    CHECK_EQ(operand.num_columns_, num_rows_);
+    RTC_CHECK_EQ(operand.num_rows_, num_columns_);
+    RTC_CHECK_EQ(operand.num_columns_, num_rows_);
 
     return Transpose(operand.elements());
   }
 
   template <typename S>
   Matrix& Scale(const S& scalar) {
     for (size_t i = 0; i < data_.size(); ++i) {
       data_[i] *= scalar;
     }
 
     return *this;
   }
 
   template <typename S>
   Matrix& Scale(const Matrix& operand, const S& scalar) {
     CopyFrom(operand);
     return Scale(scalar);
   }
 
   Matrix& Add(const Matrix& operand) {
-    CHECK_EQ(num_rows_, operand.num_rows_);
-    CHECK_EQ(num_columns_, operand.num_columns_);
+    RTC_CHECK_EQ(num_rows_, operand.num_rows_);
+    RTC_CHECK_EQ(num_columns_, operand.num_columns_);
 
     for (size_t i = 0; i < data_.size(); ++i) {
       data_[i] += operand.data_[i];
     }
 
     return *this;
   }
 
   Matrix& Add(const Matrix& lhs, const Matrix& rhs) {
     CopyFrom(lhs);
     return Add(rhs);
   }
 
   Matrix& Subtract(const Matrix& operand) {
-    CHECK_EQ(num_rows_, operand.num_rows_);
-    CHECK_EQ(num_columns_, operand.num_columns_);
+    RTC_CHECK_EQ(num_rows_, operand.num_rows_);
+    RTC_CHECK_EQ(num_columns_, operand.num_columns_);
 
     for (size_t i = 0; i < data_.size(); ++i) {
       data_[i] -= operand.data_[i];
     }
 
     return *this;
   }
 
   Matrix& Subtract(const Matrix& lhs, const Matrix& rhs) {
     CopyFrom(lhs);
     return Subtract(rhs);
   }
 
   Matrix& PointwiseMultiply(const Matrix& operand) {
-    CHECK_EQ(num_rows_, operand.num_rows_);
-    CHECK_EQ(num_columns_, operand.num_columns_);
+    RTC_CHECK_EQ(num_rows_, operand.num_rows_);
+    RTC_CHECK_EQ(num_columns_, operand.num_columns_);
 
     for (size_t i = 0; i < data_.size(); ++i) {
       data_[i] *= operand.data_[i];
     }
 
     return *this;
   }
 
   Matrix& PointwiseMultiply(const Matrix& lhs, const Matrix& rhs) {
     CopyFrom(lhs);
     return PointwiseMultiply(rhs);
   }
 
   Matrix& PointwiseDivide(const Matrix& operand) {
-    CHECK_EQ(num_rows_, operand.num_rows_);
-    CHECK_EQ(num_columns_, operand.num_columns_);
+    RTC_CHECK_EQ(num_rows_, operand.num_rows_);
+    RTC_CHECK_EQ(num_columns_, operand.num_columns_);
 
     for (size_t i = 0; i < data_.size(); ++i) {
       data_[i] /= operand.data_[i];
     }
 
     return *this;
   }
 
   Matrix& PointwiseDivide(const Matrix& lhs, const Matrix& rhs) {
     CopyFrom(lhs);
@@ skipping 33 matching lines @@
 
     return *this;
   }
 
   Matrix& PointwiseSquare(const Matrix& operand) {
     CopyFrom(operand);
     return PointwiseSquare();
   }
 
   Matrix& Multiply(const Matrix& lhs, const Matrix& rhs) {
-    CHECK_EQ(lhs.num_columns_, rhs.num_rows_);
-    CHECK_EQ(num_rows_, lhs.num_rows_);
-    CHECK_EQ(num_columns_, rhs.num_columns_);
+    RTC_CHECK_EQ(lhs.num_columns_, rhs.num_rows_);
+    RTC_CHECK_EQ(num_rows_, lhs.num_rows_);
+    RTC_CHECK_EQ(num_columns_, rhs.num_columns_);
 
     return Multiply(lhs.elements(), rhs.num_rows_, rhs.elements());
   }
 
   Matrix& Multiply(const Matrix& rhs) {
-    CHECK_EQ(num_columns_, rhs.num_rows_);
+    RTC_CHECK_EQ(num_columns_, rhs.num_rows_);
 
     CopyDataToScratch();
     Resize(num_rows_, rhs.num_columns_);
     return Multiply(scratch_elements(), rhs.num_rows_, rhs.elements());
   }
 
   std::string ToString() const {
     std::ostringstream ss;
     ss << std::endl << "Matrix" << std::endl;
 
@@ skipping 74 matching lines @@
 
     return *this;
   }
 
   RTC_DISALLOW_COPY_AND_ASSIGN(Matrix);
 };
 
 }  // namespace webrtc
 
 #endif  // WEBRTC_MODULES_AUDIO_PROCESSING_BEAMFORMER_MATRIX_H_