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

talk/app/webrtc/java/jni/androidmediadecoder_jni.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 165 matching lines @@
         FindClass(jni, "org/webrtc/MediaCodecVideoDecoder")),
           j_media_codec_video_decoder_(
               jni,
               jni->NewObject(*j_media_codec_video_decoder_class_,
                    GetMethodID(jni,
                               *j_media_codec_video_decoder_class_,
                               "<init>",
                               "()V"))) {
   ScopedLocalRefFrame local_ref_frame(jni);
   codec_thread_->SetName("MediaCodecVideoDecoder", NULL);
-  CHECK(codec_thread_->Start()) << "Failed to start MediaCodecVideoDecoder";
+  RTC_CHECK(codec_thread_->Start()) << "Failed to start MediaCodecVideoDecoder";
 
   j_init_decode_method_ = GetMethodID(
       jni, *j_media_codec_video_decoder_class_, "initDecode",
       "(Lorg/webrtc/MediaCodecVideoDecoder$VideoCodecType;"
       "IILandroid/opengl/EGLContext;)Z");
   j_release_method_ =
       GetMethodID(jni, *j_media_codec_video_decoder_class_, "release", "()V");
   j_dequeue_input_buffer_method_ = GetMethodID(
       jni, *j_media_codec_video_decoder_class_, "dequeueInputBuffer", "()I");
   j_queue_input_buffer_method_ = GetMethodID(
@@ skipping 58 matching lines @@
 }
 
 int32_t MediaCodecVideoDecoder::InitDecode(const VideoCodec* inst,
     int32_t numberOfCores) {
   ALOGD("InitDecode.");
   if (inst == NULL) {
     ALOGE("NULL VideoCodec instance");
     return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
   }
   // Factory should guard against other codecs being used with us.
-  CHECK(inst->codecType == codecType_) << "Unsupported codec " <<
-      inst->codecType << " for " << codecType_;
+  RTC_CHECK(inst->codecType == codecType_)
+      << "Unsupported codec " << inst->codecType << " for " << codecType_;
 
   if (sw_fallback_required_) {
     ALOGE("InitDecode() - fallback to SW decoder");
     return WEBRTC_VIDEO_CODEC_OK;
   }
   // Save VideoCodec instance for later.
   if (&codec_ != inst) {
     codec_ = *inst;
   }
   codec_.maxFramerate = (codec_.maxFramerate >= 1) ? codec_.maxFramerate : 1;
@@ skipping 110 matching lines @@
   inited_ = false;
   rtc::MessageQueueManager::Clear(this);
   if (CheckException(jni)) {
     ALOGE("Decoder release exception");
     return WEBRTC_VIDEO_CODEC_ERROR;
   }
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 void MediaCodecVideoDecoder::CheckOnCodecThread() {
-  CHECK(codec_thread_ == ThreadManager::Instance()->CurrentThread())
+  RTC_CHECK(codec_thread_ == ThreadManager::Instance()->CurrentThread())
       << "Running on wrong thread!";
 }
 
 int32_t MediaCodecVideoDecoder::ProcessHWErrorOnCodecThread() {
   CheckOnCodecThread();
   int ret_val = ReleaseOnCodecThread();
   if (ret_val < 0) {
     ALOGE("ProcessHWError: Release failure");
   }
   if (codecType_ == kVideoCodecH264) {
@@ skipping 99 matching lines @@
                                                 j_dequeue_input_buffer_method_);
   if (CheckException(jni) || j_input_buffer_index < 0) {
     ALOGE("dequeueInputBuffer error");
     return ProcessHWErrorOnCodecThread();
   }
 
   // Copy encoded data to Java ByteBuffer.
   jobject j_input_buffer = input_buffers_[j_input_buffer_index];
   uint8* buffer =
       reinterpret_cast<uint8*>(jni->GetDirectBufferAddress(j_input_buffer));
-  CHECK(buffer) << "Indirect buffer??";
+  RTC_CHECK(buffer) << "Indirect buffer??";
   int64 buffer_capacity = jni->GetDirectBufferCapacity(j_input_buffer);
   if (CheckException(jni) || buffer_capacity < inputImage._length) {
     ALOGE("Input frame size %d is bigger than buffer size %d.",
         inputImage._length, buffer_capacity);
     return ProcessHWErrorOnCodecThread();
   }
   jlong timestamp_us = (frames_received_ * 1000000) / codec_.maxFramerate;
   ALOGV("Decoder frame in # %d. Type: %d. Buffer # %d. TS: %lld. Size: %d",
       frames_received_, inputImage._frameType, j_input_buffer_index,
       timestamp_us / 1000, inputImage._length);
@@ skipping 196 matching lines @@
 }
 
 void MediaCodecVideoDecoder::OnMessage(rtc::Message* msg) {
   JNIEnv* jni = AttachCurrentThreadIfNeeded();
   ScopedLocalRefFrame local_ref_frame(jni);
   if (!inited_) {
     return;
   }
   // We only ever send one message to |this| directly (not through a Bind()'d
   // functor), so expect no ID/data.
-  CHECK(!msg->message_id) << "Unexpected message!";
-  CHECK(!msg->pdata) << "Unexpected message!";
+  RTC_CHECK(!msg->message_id) << "Unexpected message!";
+  RTC_CHECK(!msg->pdata) << "Unexpected message!";
   CheckOnCodecThread();
 
   if (!DeliverPendingOutputs(jni, 0)) {
     ALOGE("OnMessage: DeliverPendingOutputs error");
     ProcessHWErrorOnCodecThread();
     return;
   }
   codec_thread_->PostDelayed(kMediaCodecPollMs, this);
 }
 
@@ skipping 80 matching lines @@
   return NULL;
 }
 
 void MediaCodecVideoDecoderFactory::DestroyVideoDecoder(
     webrtc::VideoDecoder* decoder) {
   delete decoder;
 }
 
 }  // namespace webrtc_jni