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

webrtc/video/video_send_stream_tests.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.
  */
 #include <algorithm>  // max
@@ skipping 493 matching lines @@
           test_generic_packetization_(test_generic_packetization),
           use_fec_(use_fec),
           packet_count_(0),
           accumulated_size_(0),
           accumulated_payload_(0),
           fec_packet_received_(false),
           current_size_rtp_(start_size),
           current_size_frame_(static_cast<int32_t>(start_size)) {
       // Fragmentation required, this test doesn't make sense without it.
       encoder_.SetFrameSize(start_size);
-      DCHECK_GT(stop_size, max_packet_size);
+      RTC_DCHECK_GT(stop_size, max_packet_size);
       transport_adapter_.Enable();
     }
 
    private:
     Action OnSendRtp(const uint8_t* packet, size_t size) override {
       size_t length = size;
       RTPHeader header;
       EXPECT_TRUE(parser_->Parse(packet, length, &header));
 
       EXPECT_LE(length, max_packet_size_);
@@ skipping 437 matching lines @@
                                  size_t length,
                                  const PacketTime& packet_time) override {
       EXPECT_TRUE(media_type == MediaType::ANY ||
                   media_type == MediaType::VIDEO);
       if (RtpHeaderParser::IsRtcp(packet, length))
         return DELIVERY_OK;
 
       RTPHeader header;
       if (!parser_->Parse(packet, length, &header))
         return DELIVERY_PACKET_ERROR;
-      DCHECK(stream_ != nullptr);
+      RTC_DCHECK(stream_ != nullptr);
       VideoSendStream::Stats stats = stream_->GetStats();
       if (!stats.substreams.empty()) {
         EXPECT_EQ(1u, stats.substreams.size());
         int total_bitrate_bps =
             stats.substreams.begin()->second.total_bitrate_bps;
         test::PrintResult("bitrate_stats_",
                           "min_transmit_bitrate_low_remb",
                           "bitrate_bps",
                           static_cast<size_t>(total_bitrate_bps),
                           "bps",
@@ skipping 764 matching lines @@
       uint8_t buffer[16] = {0};
       EncodedImage encoded(buffer, sizeof(buffer), sizeof(buffer));
       encoded._timeStamp = input_image.timestamp();
       encoded.capture_time_ms_ = input_image.render_time_ms();
 
       for (size_t i = 0; i < kNumStreams; ++i) {
         specifics.codecSpecific.generic.simulcast_idx = static_cast<uint8_t>(i);
         encoded._frameType = (*frame_types)[i];
         encoded._encodedWidth = kEncodedResolution[i].width;
         encoded._encodedHeight = kEncodedResolution[i].height;
-        DCHECK(callback_ != nullptr);
+        RTC_DCHECK(callback_ != nullptr);
         if (callback_->Encoded(encoded, &specifics, nullptr) != 0)
           return -1;
       }
 
       observation_complete_->Set();
       return 0;
     }
     void ModifyConfigs(VideoSendStream::Config* send_config,
                        std::vector<VideoReceiveStream::Config>* receive_configs,
                        VideoEncoderConfig* encoder_config) override {
@@ skipping 123 matching lines @@
       EXPECT_TRUE(vp9videoHeader->flexible_mode);
       observation_complete_->Set();
     }
 
   } test;
 
   RunBaseTest(&test);
 }
 
 }  // namespace webrtc