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

talk/media/webrtc/webrtcvideocapturer.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 134 matching lines @@
   set_frame_factory(new WebRtcVideoFrameFactory());
 }
 
 WebRtcVideoCapturer::~WebRtcVideoCapturer() {
   if (module_) {
     module_->Release();
   }
 }
 
 bool WebRtcVideoCapturer::Init(const Device& device) {
-  DCHECK(!start_thread_);
+  RTC_DCHECK(!start_thread_);
   if (module_) {
     LOG(LS_ERROR) << "The capturer is already initialized";
     return false;
   }
 
   webrtc::VideoCaptureModule::DeviceInfo* info = factory_->CreateDeviceInfo(0);
   if (!info) {
     return false;
   }
 
@@ skipping 53 matching lines @@
   SetId(device.id);
   SetSupportedFormats(supported);
 
   // Ensure these 2 have the same value.
   SetApplyRotation(module_->GetApplyRotation());
 
   return true;
 }
 
 bool WebRtcVideoCapturer::Init(webrtc::VideoCaptureModule* module) {
-  DCHECK(!start_thread_);
+  RTC_DCHECK(!start_thread_);
   if (module_) {
     LOG(LS_ERROR) << "The capturer is already initialized";
     return false;
   }
   if (!module) {
     LOG(LS_ERROR) << "Invalid VCM supplied";
     return false;
   }
   // TODO(juberti): Set id and formats.
   (module_ = module)->AddRef();
@@ skipping 16 matching lines @@
     LOG(LS_INFO) << "Failed to find best capture format,"
                  << " fall back to the requested format "
                  << best_format->ToString();
   }
   return true;
 }
 bool WebRtcVideoCapturer::SetApplyRotation(bool enable) {
   // Can't take lock here as this will cause deadlock with
   // OnIncomingCapturedFrame. In fact, the whole method, including methods it
   // calls, can't take lock.
-  DCHECK(module_);
+  RTC_DCHECK(module_);
 
   const std::string group_name =
       webrtc::field_trial::FindFullName("WebRTC-CVO");
 
   if (group_name == "Disabled") {
     return true;
   }
 
   if (!VideoCapturer::SetApplyRotation(enable)) {
     return false;
   }
   return module_->SetApplyRotation(enable);
 }
 
 CaptureState WebRtcVideoCapturer::Start(const VideoFormat& capture_format) {
   if (!module_) {
     LOG(LS_ERROR) << "The capturer has not been initialized";
     return CS_NO_DEVICE;
   }
   if (start_thread_) {
     LOG(LS_ERROR) << "The capturer is already running";
-    DCHECK(start_thread_->IsCurrent())
+    RTC_DCHECK(start_thread_->IsCurrent())
         << "Trying to start capturer on different threads";
     return CS_FAILED;
   }
 
   start_thread_ = rtc::Thread::Current();
-  DCHECK(!async_invoker_);
+  RTC_DCHECK(!async_invoker_);
   async_invoker_.reset(new rtc::AsyncInvoker());
   captured_frames_ = 0;
 
   SetCaptureFormat(&capture_format);
 
   webrtc::VideoCaptureCapability cap;
   if (!FormatToCapability(capture_format, &cap)) {
     LOG(LS_ERROR) << "Invalid capture format specified";
     return CS_FAILED;
   }
@@ skipping 15 matching lines @@
 
   SetCaptureState(CS_RUNNING);
   return CS_STARTING;
 }
 
 void WebRtcVideoCapturer::Stop() {
   if (!start_thread_) {
     LOG(LS_ERROR) << "The capturer is already stopped";
     return;
   }
-  DCHECK(start_thread_);
-  DCHECK(start_thread_->IsCurrent());
-  DCHECK(async_invoker_);
+  RTC_DCHECK(start_thread_);
+  RTC_DCHECK(start_thread_->IsCurrent());
+  RTC_DCHECK(async_invoker_);
   if (IsRunning()) {
     // The module is responsible for OnIncomingCapturedFrame being called, if
     // we stop it we will get no further callbacks.
     module_->StopCapture();
   }
   module_->DeRegisterCaptureDataCallback();
 
   // TODO(juberti): Determine if the VCM exposes any drop stats we can use.
   double drop_ratio = 0.0;
   LOG(LS_INFO) << "Camera '" << GetId() << "' stopped after capturing "
@@ skipping 22 matching lines @@
   for (size_t i = 0; i < ARRAY_SIZE(kSupportedFourCCs); ++i) {
     fourccs->push_back(kSupportedFourCCs[i].fourcc);
   }
   return true;
 }
 
 void WebRtcVideoCapturer::OnIncomingCapturedFrame(
     const int32_t id,
     const webrtc::VideoFrame& sample) {
   // This can only happen between Start() and Stop().
-  DCHECK(start_thread_);
-  DCHECK(async_invoker_);
+  RTC_DCHECK(start_thread_);
+  RTC_DCHECK(async_invoker_);
   if (start_thread_->IsCurrent()) {
     SignalFrameCapturedOnStartThread(sample);
   } else {
     // This currently happens on with at least VideoCaptureModuleV4L2 and
     // possibly other implementations of WebRTC's VideoCaptureModule.
     // In order to maintain the threading contract with the upper layers and
     // consistency with other capturers such as in Chrome, we need to do a
     // thread hop.
     // Note that Stop() can cause the async invoke call to be cancelled.
     async_invoker_->AsyncInvoke<void>(start_thread_,
         // Note that this results in a shallow copying of the frame.
         rtc::Bind(&WebRtcVideoCapturer::SignalFrameCapturedOnStartThread,
                   this, sample));
   }
 }
 
 void WebRtcVideoCapturer::OnCaptureDelayChanged(const int32_t id,
                                                 const int32_t delay) {
   LOG(LS_INFO) << "Capture delay changed to " << delay << " ms";
 }
 
 void WebRtcVideoCapturer::SignalFrameCapturedOnStartThread(
     const webrtc::VideoFrame frame) {
   // This can only happen between Start() and Stop().
-  DCHECK(start_thread_);
-  DCHECK(start_thread_->IsCurrent());
-  DCHECK(async_invoker_);
+  RTC_DCHECK(start_thread_);
+  RTC_DCHECK(start_thread_->IsCurrent());
+  RTC_DCHECK(async_invoker_);
 
   ++captured_frames_;
   // Log the size and pixel aspect ratio of the first captured frame.
   if (1 == captured_frames_) {
     LOG(LS_INFO) << "Captured frame size "
                  << frame.width() << "x" << frame.height()
                  << ". Expected format " << GetCaptureFormat()->ToString();
   }
 
   // Signal down stream components on captured frame.
@@ skipping 23 matching lines @@
   elapsed_time = sample.render_time_ms() * rtc::kNumNanosecsPerMillisec;
   time_stamp = elapsed_time;
   data_size = rtc::checked_cast<uint32>(length);
   data = buffer;
   rotation = sample.rotation();
 }
 
 }  // namespace cricket
 
 #endif  // HAVE_WEBRTC_VIDEO