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

webrtc/modules/utility/source/jvm_android.cc

 /*
  *  Copyright (c) 2015 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 23 matching lines @@
 };
 
 // Android's FindClass() is trickier than usual because the app-specific
 // ClassLoader is not consulted when there is no app-specific frame on the
 // stack.  Consequently, we only look up all classes once in native WebRTC.
 // http://developer.android.com/training/articles/perf-jni.html#faq_FindClass
 void LoadClasses(JNIEnv* jni) {
   for (auto& c : loaded_classes) {
     jclass localRef = FindClass(jni, c.name);
     CHECK_EXCEPTION(jni) << "Error during FindClass: " << c.name;
-    CHECK(localRef) << c.name;
+    RTC_CHECK(localRef) << c.name;
     jclass globalRef = reinterpret_cast<jclass>(jni->NewGlobalRef(localRef));
     CHECK_EXCEPTION(jni) << "Error during NewGlobalRef: " << c.name;
-    CHECK(globalRef) << c.name;
+    RTC_CHECK(globalRef) << c.name;
     c.clazz = globalRef;
   }
 }
 
 void FreeClassReferences(JNIEnv* jni) {
   for (auto& c : loaded_classes) {
     jni->DeleteGlobalRef(c.clazz);
     c.clazz = nullptr;
   }
 }
 
 jclass LookUpClass(const char* name) {
   for (auto& c : loaded_classes) {
     if (strcmp(c.name, name) == 0)
       return c.clazz;
   }
-  CHECK(false) << "Unable to find class in lookup table";
+  RTC_CHECK(false) << "Unable to find class in lookup table";
   return 0;
 }
 
 // AttachCurrentThreadIfNeeded implementation.
 AttachCurrentThreadIfNeeded::AttachCurrentThreadIfNeeded()
     : attached_(false) {
   ALOGD("AttachCurrentThreadIfNeeded::ctor%s", GetThreadInfo().c_str());
   JavaVM* jvm = JVM::GetInstance()->jvm();
-  CHECK(jvm);
+  RTC_CHECK(jvm);
   JNIEnv* jni = GetEnv(jvm);
   if (!jni) {
     ALOGD("Attaching thread to JVM");
     JNIEnv* env = nullptr;
     jint ret = jvm->AttachCurrentThread(&env, nullptr);
     attached_ = (ret == JNI_OK);
   }
 }
 
 AttachCurrentThreadIfNeeded::~AttachCurrentThreadIfNeeded() {
   ALOGD("AttachCurrentThreadIfNeeded::dtor%s", GetThreadInfo().c_str());
-  DCHECK(thread_checker_.CalledOnValidThread());
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   if (attached_) {
     ALOGD("Detaching thread from JVM");
     jint res = JVM::GetInstance()->jvm()->DetachCurrentThread();
-    CHECK(res == JNI_OK) << "DetachCurrentThread failed: " << res;
+    RTC_CHECK(res == JNI_OK) << "DetachCurrentThread failed: " << res;
   }
 }
 
 // GlobalRef implementation.
 GlobalRef::GlobalRef(JNIEnv* jni, jobject object)
     : jni_(jni), j_object_(NewGlobalRef(jni, object)) {
   ALOGD("GlobalRef::ctor%s", GetThreadInfo().c_str());
 }
 
 GlobalRef::~GlobalRef() {
@@ skipping 71 matching lines @@
   return res;
 }
 
 // JNIEnvironment implementation.
 JNIEnvironment::JNIEnvironment(JNIEnv* jni) : jni_(jni) {
   ALOGD("JNIEnvironment::ctor%s", GetThreadInfo().c_str());
 }
 
 JNIEnvironment::~JNIEnvironment() {
   ALOGD("JNIEnvironment::dtor%s", GetThreadInfo().c_str());
-  DCHECK(thread_checker_.CalledOnValidThread());
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 rtc::scoped_ptr<NativeRegistration> JNIEnvironment::RegisterNatives(
     const char* name, const JNINativeMethod *methods, int num_methods) {
   ALOGD("JNIEnvironment::RegisterNatives(%s)", name);
-  DCHECK(thread_checker_.CalledOnValidThread());
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   jclass clazz = LookUpClass(name);
   jni_->RegisterNatives(clazz, methods, num_methods);
   CHECK_EXCEPTION(jni_) << "Error during RegisterNatives";
   return rtc::scoped_ptr<NativeRegistration>(
       new NativeRegistration(jni_, clazz));
 }
 
 std::string JNIEnvironment::JavaToStdString(const jstring& j_string) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   const char* jchars = jni_->GetStringUTFChars(j_string, nullptr);
   CHECK_EXCEPTION(jni_);
   const int size = jni_->GetStringUTFLength(j_string);
   CHECK_EXCEPTION(jni_);
   std::string ret(jchars, size);
   jni_->ReleaseStringUTFChars(j_string, jchars);
   CHECK_EXCEPTION(jni_);
   return ret;
 }
 
 // static
 void JVM::Initialize(JavaVM* jvm, jobject context) {
   ALOGD("JVM::Initialize%s", GetThreadInfo().c_str());
-  CHECK(!g_jvm);
+  RTC_CHECK(!g_jvm);
   g_jvm = new JVM(jvm, context);
 }
 
 // static
 void JVM::Uninitialize() {
   ALOGD("JVM::Uninitialize%s", GetThreadInfo().c_str());
-  DCHECK(g_jvm);
+  RTC_DCHECK(g_jvm);
   delete g_jvm;
   g_jvm = nullptr;
 }
 
 // static
 JVM* JVM::GetInstance() {
-  DCHECK(g_jvm);
+  RTC_DCHECK(g_jvm);
   return g_jvm;
 }
 
 JVM::JVM(JavaVM* jvm, jobject context)
     : jvm_(jvm) {
   ALOGD("JVM::JVM%s", GetThreadInfo().c_str());
-  CHECK(jni()) << "AttachCurrentThread() must be called on this thread.";
+  RTC_CHECK(jni()) << "AttachCurrentThread() must be called on this thread.";
   context_ = NewGlobalRef(jni(), context);
   LoadClasses(jni());
 }
 
 JVM::~JVM() {
   ALOGD("JVM::~JVM%s", GetThreadInfo().c_str());
-  DCHECK(thread_checker_.CalledOnValidThread());
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   FreeClassReferences(jni());
   DeleteGlobalRef(jni(), context_);
 }
 
 rtc::scoped_ptr<JNIEnvironment> JVM::environment() {
   ALOGD("JVM::environment%s", GetThreadInfo().c_str());
   // The JNIEnv is used for thread-local storage. For this reason, we cannot
   // share a JNIEnv between threads. If a piece of code has no other way to get
   // its JNIEnv, we should share the JavaVM, and use GetEnv to discover the
   // thread's JNIEnv. (Assuming it has one, if not, use AttachCurrentThread).
   // See // http://developer.android.com/training/articles/perf-jni.html.
   JNIEnv* jni = GetEnv(jvm_);
   if (!jni) {
     ALOGE("AttachCurrentThread() has not been called on this thread.");
     return rtc::scoped_ptr<JNIEnvironment>();
   }
   return rtc::scoped_ptr<JNIEnvironment>(new JNIEnvironment(jni));
 }
 
 JavaClass JVM::GetClass(const char* name) {
   ALOGD("JVM::GetClass(%s)%s", name, GetThreadInfo().c_str());
-  DCHECK(thread_checker_.CalledOnValidThread());
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   return JavaClass(jni(), LookUpClass(name));
 }
 
 }  // namespace webrtc