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

talk/media/webrtc/webrtcvideoframe.cc

 /*
  * libjingle
  * Copyright 2011 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 159 matching lines @@
 
 VideoFrame* WebRtcVideoFrame::Copy() const {
   WebRtcVideoFrame* new_frame = new WebRtcVideoFrame(
       video_frame_buffer_, elapsed_time_ns_, time_stamp_ns_, rotation_);
   new_frame->pixel_width_ = pixel_width_;
   new_frame->pixel_height_ = pixel_height_;
   return new_frame;
 }
 
 bool WebRtcVideoFrame::MakeExclusive() {
-  DCHECK(video_frame_buffer_->native_handle() == nullptr);
+  RTC_DCHECK(video_frame_buffer_->native_handle() == nullptr);
   if (IsExclusive())
     return true;
 
   // Not exclusive already, need to copy buffer.
   rtc::scoped_refptr<webrtc::VideoFrameBuffer> new_buffer =
       new rtc::RefCountedObject<webrtc::I420Buffer>(
           video_frame_buffer_->width(), video_frame_buffer_->height(),
           video_frame_buffer_->stride(kYPlane),
           video_frame_buffer_->stride(kUPlane),
           video_frame_buffer_->stride(kVPlane));
 
   if (!CopyToPlanes(
           new_buffer->MutableData(kYPlane), new_buffer->MutableData(kUPlane),
           new_buffer->MutableData(kVPlane), new_buffer->stride(kYPlane),
           new_buffer->stride(kUPlane), new_buffer->stride(kVPlane))) {
     return false;
   }
 
   video_frame_buffer_ = new_buffer;
   return true;
 }
 
 size_t WebRtcVideoFrame::ConvertToRgbBuffer(uint32 to_fourcc, uint8* buffer,
                                             size_t size, int stride_rgb) const {
-  CHECK(video_frame_buffer_);
-  CHECK(video_frame_buffer_->native_handle() == nullptr);
+  RTC_CHECK(video_frame_buffer_);
+  RTC_CHECK(video_frame_buffer_->native_handle() == nullptr);
   return VideoFrame::ConvertToRgbBuffer(to_fourcc, buffer, size, stride_rgb);
 }
 
 bool WebRtcVideoFrame::Reset(uint32 format,
                              int w,
                              int h,
                              int dw,
                              int dh,
                              uint8* sample,
                              size_t sample_size,
@@ skipping 72 matching lines @@
 const VideoFrame* WebRtcVideoFrame::GetCopyWithRotationApplied() const {
   // If the frame is not rotated, the caller should reuse this frame instead of
   // making a redundant copy.
   if (GetVideoRotation() == webrtc::kVideoRotation_0) {
     return this;
   }
 
   // If the video frame is backed up by a native handle, it resides in the GPU
   // memory which we can't rotate here. The assumption is that the renderers
   // which uses GPU to render should be able to rotate themselves.
-  DCHECK(!GetNativeHandle());
+  RTC_DCHECK(!GetNativeHandle());
 
   if (rotated_frame_) {
     return rotated_frame_.get();
   }
 
   int width = static_cast<int>(GetWidth());
   int height = static_cast<int>(GetHeight());
 
   int rotated_width = width;
   int rotated_height = height;
@@ skipping 15 matching lines @@
       rotated_frame_->GetUPlane(), rotated_frame_->GetUPitch(),
       rotated_frame_->GetVPlane(), rotated_frame_->GetVPitch(), width, height,
       static_cast<libyuv::RotationMode>(GetVideoRotation()));
   if (ret == 0) {
     return rotated_frame_.get();
   }
   return nullptr;
 }
 
 }  // namespace cricket