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

talk/app/webrtc/java/jni/peerconnection_jni.cc

 /*
  * libjingle
  * Copyright 2013 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 122 matching lines @@
 // Set in PeerConnectionFactory_initializeAndroidGlobals().
 static bool factory_static_initialized = false;
 static bool video_hw_acceleration_enabled = true;
 #endif
 
 extern "C" jint JNIEXPORT JNICALL JNI_OnLoad(JavaVM *jvm, void *reserved) {
   jint ret = InitGlobalJniVariables(jvm);
   if (ret < 0)
     return -1;
 
-  CHECK(rtc::InitializeSSL()) << "Failed to InitializeSSL()";
+  RTC_CHECK(rtc::InitializeSSL()) << "Failed to InitializeSSL()";
   LoadGlobalClassReferenceHolder();
 
   return ret;
 }
 
 extern "C" void JNIEXPORT JNICALL JNI_OnUnLoad(JavaVM *jvm, void *reserved) {
   FreeGlobalClassReferenceHolder();
-  CHECK(rtc::CleanupSSL()) << "Failed to CleanupSSL()";
+  RTC_CHECK(rtc::CleanupSSL()) << "Failed to CleanupSSL()";
 }
 
 // Return the (singleton) Java Enum object corresponding to |index|;
 // |state_class_fragment| is something like "MediaSource$State".
 static jobject JavaEnumFromIndex(
     JNIEnv* jni, const std::string& state_class_fragment, int index) {
   const std::string state_class = "org/webrtc/" + state_class_fragment;
   return JavaEnumFromIndex(jni, FindClass(jni, state_class.c_str()),
                            state_class, index);
 }
@@ skipping 50 matching lines @@
 
   virtual ~PCOJava() {
     ScopedLocalRefFrame local_ref_frame(jni());
     while (!remote_streams_.empty())
       DisposeRemoteStream(remote_streams_.begin());
   }
 
   void OnIceCandidate(const IceCandidateInterface* candidate) override {
     ScopedLocalRefFrame local_ref_frame(jni());
     std::string sdp;
-    CHECK(candidate->ToString(&sdp)) << "got so far: " << sdp;
+    RTC_CHECK(candidate->ToString(&sdp)) << "got so far: " << sdp;
     jclass candidate_class = FindClass(jni(), "org/webrtc/IceCandidate");
     jmethodID ctor = GetMethodID(jni(), candidate_class,
         "<init>", "(Ljava/lang/String;ILjava/lang/String;)V");
     jstring j_mid = JavaStringFromStdString(jni(), candidate->sdp_mid());
     jstring j_sdp = JavaStringFromStdString(jni(), sdp);
     jobject j_candidate = jni()->NewObject(
         candidate_class, ctor, j_mid, candidate->sdp_mline_index(), j_sdp);
     CHECK_EXCEPTION(jni()) << "error during NewObject";
     jmethodID m = GetMethodID(jni(), *j_observer_class_,
                               "onIceCandidate", "(Lorg/webrtc/IceCandidate;)V");
@@ skipping 68 matching lines @@
                                             *j_media_stream_class_,
                                             "audioTracks",
                                             "Ljava/util/LinkedList;");
       jobject audio_tracks = GetObjectField(jni(), j_stream, audio_tracks_id);
       jmethodID add = GetMethodID(jni(),
                                   GetObjectClass(jni(), audio_tracks),
                                   "add",
                                   "(Ljava/lang/Object;)Z");
       jboolean added = jni()->CallBooleanMethod(audio_tracks, add, j_track);
       CHECK_EXCEPTION(jni()) << "error during CallBooleanMethod";
-      CHECK(added);
+      RTC_CHECK(added);
     }
 
     for (const auto& track : stream->GetVideoTracks()) {
       jstring id = JavaStringFromStdString(jni(), track->id());
       // Java VideoTrack holds one reference. Corresponding Release() is in
       // MediaStreamTrack_free, triggered by VideoTrack.dispose().
       track->AddRef();
       jobject j_track =
           jni()->NewObject(*j_video_track_class_, j_video_track_ctor_,
                            reinterpret_cast<jlong>(track.get()), id);
       CHECK_EXCEPTION(jni()) << "error during NewObject";
       jfieldID video_tracks_id = GetFieldID(jni(),
                                             *j_media_stream_class_,
                                             "videoTracks",
                                             "Ljava/util/LinkedList;");
       jobject video_tracks = GetObjectField(jni(), j_stream, video_tracks_id);
       jmethodID add = GetMethodID(jni(),
                                   GetObjectClass(jni(), video_tracks),
                                   "add",
                                   "(Ljava/lang/Object;)Z");
       jboolean added = jni()->CallBooleanMethod(video_tracks, add, j_track);
       CHECK_EXCEPTION(jni()) << "error during CallBooleanMethod";
-      CHECK(added);
+      RTC_CHECK(added);
     }
     remote_streams_[stream] = NewGlobalRef(jni(), j_stream);
 
     jmethodID m = GetMethodID(jni(), *j_observer_class_, "onAddStream",
                               "(Lorg/webrtc/MediaStream;)V");
     jni()->CallVoidMethod(*j_observer_global_, m, j_stream);
     CHECK_EXCEPTION(jni()) << "error during CallVoidMethod";
   }
 
   void OnRemoveStream(MediaStreamInterface* stream) override {
     ScopedLocalRefFrame local_ref_frame(jni());
     NativeToJavaStreamsMap::iterator it = remote_streams_.find(stream);
-    CHECK(it != remote_streams_.end()) << "unexpected stream: " << std::hex
-                                       << stream;
+    RTC_CHECK(it != remote_streams_.end()) << "unexpected stream: " << std::hex
+                                           << stream;
     jobject j_stream = it->second;
     jmethodID m = GetMethodID(jni(), *j_observer_class_, "onRemoveStream",
                               "(Lorg/webrtc/MediaStream;)V");
     jni()->CallVoidMethod(*j_observer_global_, m, j_stream);
     CHECK_EXCEPTION(jni()) << "error during CallVoidMethod";
     DisposeRemoteStream(it);
   }
 
   void OnDataChannel(DataChannelInterface* channel) override {
     ScopedLocalRefFrame local_ref_frame(jni());
     jobject j_channel = jni()->NewObject(
         *j_data_channel_class_, j_data_channel_ctor_, (jlong)channel);
     CHECK_EXCEPTION(jni()) << "error during NewObject";
 
     jmethodID m = GetMethodID(jni(), *j_observer_class_, "onDataChannel",
                               "(Lorg/webrtc/DataChannel;)V");
     jni()->CallVoidMethod(*j_observer_global_, m, j_channel);
 
     // Channel is now owned by Java object, and will be freed from
     // DataChannel.dispose().  Important that this be done _after_ the
     // CallVoidMethod above as Java code might call back into native code and be
     // surprised to see a refcount of 2.
     int bumped_count = channel->AddRef();
-    CHECK(bumped_count == 2) << "Unexpected refcount OnDataChannel";
+    RTC_CHECK(bumped_count == 2) << "Unexpected refcount OnDataChannel";
 
     CHECK_EXCEPTION(jni()) << "error during CallVoidMethod";
   }
 
   void OnRenegotiationNeeded() override {
     ScopedLocalRefFrame local_ref_frame(jni());
     jmethodID m =
         GetMethodID(jni(), *j_observer_class_, "onRenegotiationNeeded", "()V");
     jni()->CallVoidMethod(*j_observer_global_, m);
     CHECK_EXCEPTION(jni()) << "error during CallVoidMethod";
   }
 
   void SetConstraints(ConstraintsWrapper* constraints) {
-    CHECK(!constraints_.get()) << "constraints already set!";
+    RTC_CHECK(!constraints_.get()) << "constraints already set!";
     constraints_.reset(constraints);
   }
 
   const ConstraintsWrapper* constraints() { return constraints_.get(); }
 
  private:
   typedef std::map<MediaStreamInterface*, jobject> NativeToJavaStreamsMap;
 
   void DisposeRemoteStream(const NativeToJavaStreamsMap::iterator& it) {
     jobject j_stream = it->second;
@@ skipping 78 matching lines @@
     CHECK_EXCEPTION(jni) << "error during CallBooleanMethod";
   }
 
   Constraints mandatory_;
   Constraints optional_;
 };
 
 static jobject JavaSdpFromNativeSdp(
     JNIEnv* jni, const SessionDescriptionInterface* desc) {
   std::string sdp;
-  CHECK(desc->ToString(&sdp)) << "got so far: " << sdp;
+  RTC_CHECK(desc->ToString(&sdp)) << "got so far: " << sdp;
   jstring j_description = JavaStringFromStdString(jni, sdp);
 
   jclass j_type_class = FindClass(
       jni, "org/webrtc/SessionDescription$Type");
   jmethodID j_type_from_canonical = GetStaticMethodID(
       jni, j_type_class, "fromCanonicalForm",
       "(Ljava/lang/String;)Lorg/webrtc/SessionDescription$Type;");
   jstring j_type_string = JavaStringFromStdString(jni, desc->type());
   jobject j_type = jni->CallStaticObjectMethod(
       j_type_class, j_type_from_canonical, j_type_string);
@@ skipping 368 matching lines @@
   return JavaStringFromStdString(jni, ExtractNativeDC(jni, j_dc)->label());
 }
 
 JOW(jobject, DataChannel_state)(JNIEnv* jni, jobject j_dc) {
   return JavaEnumFromIndex(
       jni, "DataChannel$State", ExtractNativeDC(jni, j_dc)->state());
 }
 
 JOW(jlong, DataChannel_bufferedAmount)(JNIEnv* jni, jobject j_dc) {
   uint64 buffered_amount = ExtractNativeDC(jni, j_dc)->buffered_amount();
-  CHECK_LE(buffered_amount, std::numeric_limits<int64>::max())
+  RTC_CHECK_LE(buffered_amount, std::numeric_limits<int64>::max())
       << "buffered_amount overflowed jlong!";
   return static_cast<jlong>(buffered_amount);
 }
 
 JOW(void, DataChannel_close)(JNIEnv* jni, jobject j_dc) {
   ExtractNativeDC(jni, j_dc)->Close();
 }
 
 JOW(jboolean, DataChannel_sendNative)(JNIEnv* jni, jobject j_dc,
                                       jbyteArray data, jboolean binary) {
@@ skipping 11 matching lines @@
 
 JOW(void, Logging_nativeEnableTracing)(
     JNIEnv* jni, jclass, jstring j_path, jint nativeLevels,
     jint nativeSeverity) {
   std::string path = JavaToStdString(jni, j_path);
   if (nativeLevels != webrtc::kTraceNone) {
     webrtc::Trace::set_level_filter(nativeLevels);
 #if defined(ANDROID) && !defined(WEBRTC_CHROMIUM_BUILD)
     if (path != "logcat:") {
 #endif
-      CHECK_EQ(0, webrtc::Trace::SetTraceFile(path.c_str(), false))
+      RTC_CHECK_EQ(0, webrtc::Trace::SetTraceFile(path.c_str(), false))
           << "SetTraceFile failed";
 #if defined(ANDROID) && !defined(WEBRTC_CHROMIUM_BUILD)
     } else {
       // Intentionally leak this to avoid needing to reason about its lifecycle.
       // It keeps no state and functions only as a dispatch point.
       static LogcatTraceContext* g_trace_callback = new LogcatTraceContext();
     }
 #endif
   }
   if (nativeSeverity >= rtc::LS_SENSITIVE && nativeSeverity <= rtc::LS_ERROR) {
@@ skipping 163 matching lines @@
   // ThreadManager only WrapCurrentThread()s the thread where it is first
   // created.  Since the semantics around when auto-wrapping happens in
   // webrtc/base/ are convoluted, we simply wrap here to avoid having to think
   // about ramifications of auto-wrapping there.
   rtc::ThreadManager::Instance()->WrapCurrentThread();
   webrtc::Trace::CreateTrace();
   Thread* worker_thread = new Thread();
   worker_thread->SetName("worker_thread", NULL);
   Thread* signaling_thread = new Thread();
   signaling_thread->SetName("signaling_thread", NULL);
-  CHECK(worker_thread->Start() && signaling_thread->Start())
+  RTC_CHECK(worker_thread->Start() && signaling_thread->Start())
       << "Failed to start threads";
   WebRtcVideoEncoderFactory* encoder_factory = nullptr;
   WebRtcVideoDecoderFactory* decoder_factory = nullptr;
 #if defined(ANDROID) && !defined(WEBRTC_CHROMIUM_BUILD)
   if (video_hw_acceleration_enabled) {
     encoder_factory = new MediaCodecVideoEncoderFactory();
     decoder_factory = new MediaCodecVideoDecoderFactory();
   }
 #endif
   rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
@@ skipping 143 matching lines @@
 
   if (enum_name == "RELAY")
     return PeerConnectionInterface::kRelay;
 
   if (enum_name == "NOHOST")
     return PeerConnectionInterface::kNoHost;
 
   if (enum_name == "NONE")
     return PeerConnectionInterface::kNone;
 
-  CHECK(false) << "Unexpected IceTransportsType enum_name " << enum_name;
+  RTC_CHECK(false) << "Unexpected IceTransportsType enum_name " << enum_name;
   return PeerConnectionInterface::kAll;
 }
 
 static PeerConnectionInterface::BundlePolicy
 JavaBundlePolicyToNativeType(JNIEnv* jni, jobject j_bundle_policy) {
   std::string enum_name = GetJavaEnumName(
       jni, "org/webrtc/PeerConnection$BundlePolicy",
       j_bundle_policy);
 
   if (enum_name == "BALANCED")
     return PeerConnectionInterface::kBundlePolicyBalanced;
 
   if (enum_name == "MAXBUNDLE")
     return PeerConnectionInterface::kBundlePolicyMaxBundle;
 
   if (enum_name == "MAXCOMPAT")
     return PeerConnectionInterface::kBundlePolicyMaxCompat;
 
-  CHECK(false) << "Unexpected BundlePolicy enum_name " << enum_name;
+  RTC_CHECK(false) << "Unexpected BundlePolicy enum_name " << enum_name;
   return PeerConnectionInterface::kBundlePolicyBalanced;
 }
 
 static PeerConnectionInterface::RtcpMuxPolicy
 JavaRtcpMuxPolicyToNativeType(JNIEnv* jni, jobject j_rtcp_mux_policy) {
   std::string enum_name = GetJavaEnumName(
       jni, "org/webrtc/PeerConnection$RtcpMuxPolicy",
       j_rtcp_mux_policy);
 
   if (enum_name == "NEGOTIATE")
     return PeerConnectionInterface::kRtcpMuxPolicyNegotiate;
 
   if (enum_name == "REQUIRE")
     return PeerConnectionInterface::kRtcpMuxPolicyRequire;
 
-  CHECK(false) << "Unexpected RtcpMuxPolicy enum_name " << enum_name;
+  RTC_CHECK(false) << "Unexpected RtcpMuxPolicy enum_name " << enum_name;
   return PeerConnectionInterface::kRtcpMuxPolicyNegotiate;
 }
 
 static PeerConnectionInterface::TcpCandidatePolicy
 JavaTcpCandidatePolicyToNativeType(
     JNIEnv* jni, jobject j_tcp_candidate_policy) {
   std::string enum_name = GetJavaEnumName(
       jni, "org/webrtc/PeerConnection$TcpCandidatePolicy",
       j_tcp_candidate_policy);
 
   if (enum_name == "ENABLED")
     return PeerConnectionInterface::kTcpCandidatePolicyEnabled;
 
   if (enum_name == "DISABLED")
     return PeerConnectionInterface::kTcpCandidatePolicyDisabled;
 
-  CHECK(false) << "Unexpected TcpCandidatePolicy enum_name " << enum_name;
+  RTC_CHECK(false) << "Unexpected TcpCandidatePolicy enum_name " << enum_name;
   return PeerConnectionInterface::kTcpCandidatePolicyEnabled;
 }
 
 static rtc::KeyType JavaKeyTypeToNativeType(JNIEnv* jni, jobject j_key_type) {
   std::string enum_name = GetJavaEnumName(
       jni, "org/webrtc/PeerConnection$KeyType", j_key_type);
 
   if (enum_name == "RSA")
     return rtc::KT_RSA;
   if (enum_name == "ECDSA")
     return rtc::KT_ECDSA;
 
-  CHECK(false) << "Unexpected KeyType enum_name " << enum_name;
+  RTC_CHECK(false) << "Unexpected KeyType enum_name " << enum_name;
   return rtc::KT_ECDSA;
 }
 
 static void JavaIceServersToJsepIceServers(
     JNIEnv* jni, jobject j_ice_servers,
     PeerConnectionInterface::IceServers* ice_servers) {
   jclass list_class = GetObjectClass(jni, j_ice_servers);
   jmethodID iterator_id = GetMethodID(
       jni, list_class, "iterator", "()Ljava/util/Iterator;");
   jobject iterator = jni->CallObjectMethod(j_ice_servers, iterator_id);
@@ skipping 140 matching lines @@
 JOW(jobject, PeerConnection_createDataChannel)(
     JNIEnv* jni, jobject j_pc, jstring j_label, jobject j_init) {
   DataChannelInit init = JavaDataChannelInitToNative(jni, j_init);
   rtc::scoped_refptr<DataChannelInterface> channel(
       ExtractNativePC(jni, j_pc)->CreateDataChannel(
           JavaToStdString(jni, j_label), &init));
   // Mustn't pass channel.get() directly through NewObject to avoid reading its
   // vararg parameter as 64-bit and reading memory that doesn't belong to the
   // 32-bit parameter.
   jlong nativeChannelPtr = jlongFromPointer(channel.get());
-  CHECK(nativeChannelPtr) << "Failed to create DataChannel";
+  RTC_CHECK(nativeChannelPtr) << "Failed to create DataChannel";
   jclass j_data_channel_class = FindClass(jni, "org/webrtc/DataChannel");
   jmethodID j_data_channel_ctor = GetMethodID(
       jni, j_data_channel_class, "<init>", "(J)V");
   jobject j_channel = jni->NewObject(
       j_data_channel_class, j_data_channel_ctor, nativeChannelPtr);
   CHECK_EXCEPTION(jni) << "error during NewObject";
   // Channel is now owned by Java object, and will be freed from there.
   int bumped_count = channel->AddRef();
-  CHECK(bumped_count == 2) << "Unexpected refcount";
+  RTC_CHECK(bumped_count == 2) << "Unexpected refcount";
   return j_channel;
 }
 
 JOW(void, PeerConnection_createOffer)(
     JNIEnv* jni, jobject j_pc, jobject j_observer, jobject j_constraints) {
   ConstraintsWrapper* constraints =
       new ConstraintsWrapper(jni, j_constraints);
   rtc::scoped_refptr<CreateSdpObserverWrapper> observer(
       new rtc::RefCountedObject<CreateSdpObserverWrapper>(
           jni, j_observer, constraints));
@@ skipping 141 matching lines @@
       AndroidVideoCapturerJni::Create(jni, j_video_capturer, j_device_name);
   if (!delegate.get())
     return nullptr;
   rtc::scoped_ptr<webrtc::AndroidVideoCapturer> capturer(
       new webrtc::AndroidVideoCapturer(delegate));
 
 #else
   std::string device_name = JavaToStdString(jni, j_device_name);
   scoped_ptr<cricket::DeviceManagerInterface> device_manager(
       cricket::DeviceManagerFactory::Create());
-  CHECK(device_manager->Init()) << "DeviceManager::Init() failed";
+  RTC_CHECK(device_manager->Init()) << "DeviceManager::Init() failed";
   cricket::Device device;
   if (!device_manager->GetVideoCaptureDevice(device_name, &device)) {
     LOG(LS_ERROR) << "GetVideoCaptureDevice failed for " << device_name;
     return 0;
   }
   scoped_ptr<cricket::VideoCapturer> capturer(
       device_manager->CreateVideoCapturer(device));
 
   jclass j_video_capturer_class(
       FindClass(jni, "org/webrtc/VideoCapturer"));
@@ skipping 26 matching lines @@
   scoped_ptr<JavaVideoRendererWrapper> renderer(
       new JavaVideoRendererWrapper(jni, j_callbacks));
   return (jlong)renderer.release();
 }
 
 JOW(void, VideoRenderer_nativeCopyPlane)(
     JNIEnv *jni, jclass, jobject j_src_buffer, jint width, jint height,
     jint src_stride, jobject j_dst_buffer, jint dst_stride) {
   size_t src_size = jni->GetDirectBufferCapacity(j_src_buffer);
   size_t dst_size = jni->GetDirectBufferCapacity(j_dst_buffer);
-  CHECK(src_stride >= width) << "Wrong source stride " << src_stride;
-  CHECK(dst_stride >= width) << "Wrong destination stride " << dst_stride;
-  CHECK(src_size >= src_stride * height)
+  RTC_CHECK(src_stride >= width) << "Wrong source stride " << src_stride;
+  RTC_CHECK(dst_stride >= width) << "Wrong destination stride " << dst_stride;
+  RTC_CHECK(src_size >= src_stride * height)
       << "Insufficient source buffer capacity " << src_size;
-  CHECK(dst_size >= dst_stride * height)
+  RTC_CHECK(dst_size >= dst_stride * height)
       << "Isufficient destination buffer capacity " << dst_size;
   uint8_t *src =
       reinterpret_cast<uint8_t*>(jni->GetDirectBufferAddress(j_src_buffer));
   uint8_t *dst =
       reinterpret_cast<uint8_t*>(jni->GetDirectBufferAddress(j_dst_buffer));
   if (src_stride == dst_stride) {
     memcpy(dst, src, src_stride * height);
   } else {
     for (int i = 0; i < height; i++) {
       memcpy(dst, src, width);
@@ skipping 107 matching lines @@
   rtc::scoped_ptr<jbyte> buffer(static_cast<jbyte*>(malloc(log_size)));
   stream->ReadAll(buffer.get(), log_size, &read, nullptr);
 
   jbyteArray result = jni->NewByteArray(read);
   jni->SetByteArrayRegion(result, 0, read, buffer.get());
 
   return result;
 }
 
 }  // namespace webrtc_jni