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

talk/app/webrtc/androidvideocapturer.cc

 /*
  * libjingle
  * Copyright 2015 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 64 matching lines @@
 
   const cricket::CapturedFrame* GetCapturedFrame() const {
     return &captured_frame_;
   }
 
   cricket::VideoFrame* CreateAliasedFrame(
       const cricket::CapturedFrame* captured_frame,
       int dst_width,
       int dst_height) const override {
     // Check that captured_frame is actually our frame.
-    CHECK(captured_frame == &captured_frame_);
+    RTC_CHECK(captured_frame == &captured_frame_);
     rtc::scoped_ptr<cricket::VideoFrame> frame(new cricket::WebRtcVideoFrame(
         ShallowCenterCrop(buffer_, dst_width, dst_height),
         captured_frame->elapsed_time, captured_frame->time_stamp,
         captured_frame->GetRotation()));
     // Caller takes ownership.
     // TODO(magjed): Change CreateAliasedFrame() to return a rtc::scoped_ptr.
     return apply_rotation_ ? frame->GetCopyWithRotationApplied()->Copy()
                            : frame.release();
   }
 
@@ skipping 16 matching lines @@
 
   Json::Value json_values;
   Json::Reader reader(Json::Features::strictMode());
   if (!reader.parse(json_string, json_values)) {
     LOG(LS_ERROR) << "Failed to parse formats.";
   }
 
   std::vector<cricket::VideoFormat> formats;
   for (Json::ArrayIndex i = 0; i < json_values.size(); ++i) {
       const Json::Value& json_value = json_values[i];
-      CHECK(!json_value["width"].isNull() && !json_value["height"].isNull() &&
-             !json_value["framerate"].isNull());
+      RTC_CHECK(!json_value["width"].isNull() &&
+                !json_value["height"].isNull() &&
+                !json_value["framerate"].isNull());
       cricket::VideoFormat format(
           json_value["width"].asInt(),
           json_value["height"].asInt(),
           cricket::VideoFormat::FpsToInterval(json_value["framerate"].asInt()),
           cricket::FOURCC_YV12);
       formats.push_back(format);
   }
   SetSupportedFormats(formats);
   // Do not apply frame rotation by default.
   SetApplyRotation(false);
 }
 
 AndroidVideoCapturer::~AndroidVideoCapturer() {
-  CHECK(!running_);
+  RTC_CHECK(!running_);
 }
 
 cricket::CaptureState AndroidVideoCapturer::Start(
     const cricket::VideoFormat& capture_format) {
-  CHECK(thread_checker_.CalledOnValidThread());
-  CHECK(!running_);
+  RTC_CHECK(thread_checker_.CalledOnValidThread());
+  RTC_CHECK(!running_);
   const int fps = cricket::VideoFormat::IntervalToFps(capture_format.interval);
   LOG(LS_INFO) << " AndroidVideoCapturer::Start " << capture_format.width << "x"
                << capture_format.height << "@" << fps;
 
   frame_factory_ = new AndroidVideoCapturer::FrameFactory(delegate_.get());
   set_frame_factory(frame_factory_);
 
   running_ = true;
   delegate_->Start(capture_format.width, capture_format.height, fps, this);
   SetCaptureFormat(&capture_format);
   current_state_ = cricket::CS_STARTING;
   return current_state_;
 }
 
 void AndroidVideoCapturer::Stop() {
   LOG(LS_INFO) << " AndroidVideoCapturer::Stop ";
-  CHECK(thread_checker_.CalledOnValidThread());
-  CHECK(running_);
+  RTC_CHECK(thread_checker_.CalledOnValidThread());
+  RTC_CHECK(running_);
   running_ = false;
   SetCaptureFormat(NULL);
 
   delegate_->Stop();
   current_state_ = cricket::CS_STOPPED;
   SignalStateChange(this, current_state_);
 }
 
 bool AndroidVideoCapturer::IsRunning() {
-  CHECK(thread_checker_.CalledOnValidThread());
+  RTC_CHECK(thread_checker_.CalledOnValidThread());
   return running_;
 }
 
 bool AndroidVideoCapturer::GetPreferredFourccs(std::vector<uint32>* fourccs) {
-  CHECK(thread_checker_.CalledOnValidThread());
+  RTC_CHECK(thread_checker_.CalledOnValidThread());
   fourccs->push_back(cricket::FOURCC_YV12);
   return true;
 }
 
 void AndroidVideoCapturer::OnCapturerStarted(bool success) {
-  CHECK(thread_checker_.CalledOnValidThread());
+  RTC_CHECK(thread_checker_.CalledOnValidThread());
   cricket::CaptureState new_state =
       success ? cricket::CS_RUNNING : cricket::CS_FAILED;
   if (new_state == current_state_)
     return;
   current_state_ = new_state;
 
   // TODO(perkj): SetCaptureState can not be used since it posts to |thread_|.
   // But |thread_ | is currently just the thread that happened to create the
   // cricket::VideoCapturer.
   SignalStateChange(this, new_state);
 }
 
 void AndroidVideoCapturer::OnIncomingFrame(
     rtc::scoped_refptr<webrtc::VideoFrameBuffer> buffer,
     int rotation,
     int64 time_stamp) {
-  CHECK(thread_checker_.CalledOnValidThread());
+  RTC_CHECK(thread_checker_.CalledOnValidThread());
   frame_factory_->UpdateCapturedFrame(buffer, rotation, time_stamp);
   SignalFrameCaptured(this, frame_factory_->GetCapturedFrame());
   frame_factory_->ClearCapturedFrame();
 }
 
 void AndroidVideoCapturer::OnOutputFormatRequest(
     int width, int height, int fps) {
-  CHECK(thread_checker_.CalledOnValidThread());
+  RTC_CHECK(thread_checker_.CalledOnValidThread());
   const cricket::VideoFormat& current = video_adapter()->output_format();
   cricket::VideoFormat format(
       width, height, cricket::VideoFormat::FpsToInterval(fps), current.fourcc);
   video_adapter()->OnOutputFormatRequest(format);
 }
 
 bool AndroidVideoCapturer::GetBestCaptureFormat(
     const cricket::VideoFormat& desired,
     cricket::VideoFormat* best_format) {
   // Delegate this choice to VideoCapturerAndroid.startCapture().
   *best_format = desired;
   return true;
 }
 
 }  // namespace webrtc