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

webrtc/modules/video_coding/codecs/h264/h264_video_toolbox_decoder.cc

 /*
  *  Copyright (c) 2015 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 29 matching lines @@
   int64_t timestamp;
 };
 
 // On decode we receive a CVPixelBuffer, which we need to convert to a frame
 // buffer for use in the rest of WebRTC. Unfortunately this involves a frame
 // copy.
 // TODO(tkchin): Stuff CVPixelBuffer into a TextureBuffer and pass that along
 // instead once the pipeline supports it.
 rtc::scoped_refptr<webrtc::VideoFrameBuffer> VideoFrameBufferForPixelBuffer(
     CVPixelBufferRef pixel_buffer) {
-  DCHECK(pixel_buffer);
-  DCHECK(CVPixelBufferGetPixelFormatType(pixel_buffer) ==
-         kCVPixelFormatType_420YpCbCr8BiPlanarFullRange);
+  RTC_DCHECK(pixel_buffer);
+  RTC_DCHECK(CVPixelBufferGetPixelFormatType(pixel_buffer) ==
+             kCVPixelFormatType_420YpCbCr8BiPlanarFullRange);
   size_t width = CVPixelBufferGetWidthOfPlane(pixel_buffer, 0);
   size_t height = CVPixelBufferGetHeightOfPlane(pixel_buffer, 0);
   // TODO(tkchin): Use a frame buffer pool.
   rtc::scoped_refptr<webrtc::VideoFrameBuffer> buffer =
       new rtc::RefCountedObject<webrtc::I420Buffer>(width, height);
   CVPixelBufferLockBaseAddress(pixel_buffer, kCVPixelBufferLock_ReadOnly);
   const uint8* src_y = reinterpret_cast<const uint8*>(
       CVPixelBufferGetBaseAddressOfPlane(pixel_buffer, 0));
   int src_y_stride = CVPixelBufferGetBytesPerRowOfPlane(pixel_buffer, 0);
   const uint8* src_uv = reinterpret_cast<const uint8*>(
@@ skipping 55 matching lines @@
                                         int number_of_cores) {
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 int H264VideoToolboxDecoder::Decode(
     const EncodedImage& input_image,
     bool missing_frames,
     const RTPFragmentationHeader* fragmentation,
     const CodecSpecificInfo* codec_specific_info,
     int64_t render_time_ms) {
-  DCHECK(input_image._buffer);
+  RTC_DCHECK(input_image._buffer);
 
   CMSampleBufferRef sample_buffer = nullptr;
   if (!H264AnnexBBufferToCMSampleBuffer(input_image._buffer,
                                         input_image._length,
                                         video_format_,
                                         &sample_buffer)) {
     return WEBRTC_VIDEO_CODEC_ERROR;
   }
-  DCHECK(sample_buffer);
+  RTC_DCHECK(sample_buffer);
   // Check if the video format has changed, and reinitialize decoder if needed.
   CMVideoFormatDescriptionRef description =
       CMSampleBufferGetFormatDescription(sample_buffer);
   if (!CMFormatDescriptionEqual(description, video_format_)) {
     SetVideoFormat(description);
     ResetDecompressionSession();
   }
   VTDecodeFrameFlags decode_flags =
       kVTDecodeFrame_EnableAsynchronousDecompression;
   rtc::scoped_ptr<internal::FrameDecodeParams> frame_decode_params;
   frame_decode_params.reset(
       new internal::FrameDecodeParams(callback_, input_image._timeStamp));
   OSStatus status = VTDecompressionSessionDecodeFrame(
       decompression_session_, sample_buffer, decode_flags,
       frame_decode_params.release(), nullptr);
   CFRelease(sample_buffer);
   if (status != noErr) {
     LOG(LS_ERROR) << "Failed to decode frame with code: " << status;
     return WEBRTC_VIDEO_CODEC_ERROR;
   }
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 int H264VideoToolboxDecoder::RegisterDecodeCompleteCallback(
     DecodedImageCallback* callback) {
-  DCHECK(!callback_);
+  RTC_DCHECK(!callback_);
   callback_ = callback;
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 int H264VideoToolboxDecoder::Release() {
   callback_ = nullptr;
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 int H264VideoToolboxDecoder::Reset() {
@@ skipping 57 matching lines @@
   if (status != noErr) {
     DestroyDecompressionSession();
     return WEBRTC_VIDEO_CODEC_ERROR;
   }
   ConfigureDecompressionSession();
 
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 void H264VideoToolboxDecoder::ConfigureDecompressionSession() {
-  DCHECK(decompression_session_);
+  RTC_DCHECK(decompression_session_);
 #if defined(WEBRTC_IOS)
   VTSessionSetProperty(decompression_session_,
                        kVTDecompressionPropertyKey_RealTime, kCFBooleanTrue);
 #endif
 }
 
 void H264VideoToolboxDecoder::DestroyDecompressionSession() {
   if (decompression_session_) {
     VTDecompressionSessionInvalidate(decompression_session_);
     decompression_session_ = nullptr;
@@ skipping 10 matching lines @@
   }
   video_format_ = video_format;
   if (video_format_) {
     CFRetain(video_format_);
   }
 }
 
 }  // namespace webrtc
 
 #endif  // defined(WEBRTC_VIDEO_TOOLBOX_SUPPORTED)