🐝 Convert a few CHECKs to LOG(FATAL)

base/android/jni_android.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/android/jni_android.h"
 
 #include <stddef.h>
 
 #include <map>
 
@@ skipping 101 matching lines @@
       }
     }
 
     clazz = static_cast<jclass>(
         env->CallObjectMethod(g_class_loader.Get().obj(),
                               g_class_loader_load_class_method_id,
                               ConvertUTF8ToJavaString(env, dotted_name).obj()));
   } else {
     clazz = env->FindClass(class_name);
   }
-  CHECK(!ClearException(env) && clazz) << "Failed to find class " << class_name;
+  if (ClearException(env) || !clazz) {
+    LOG(FATAL) << "Failed to find class " << class_name;
+  }
   return ScopedJavaLocalRef<jclass>(env, clazz);
 }
 
 jclass LazyGetClass(
     JNIEnv* env,
     const char* class_name,
     base::subtle::AtomicWord* atomic_class_id) {
   static_assert(sizeof(subtle::AtomicWord) >= sizeof(jclass),
                 "AtomicWord can't be smaller than jclass");
   subtle::AtomicWord value = base::subtle::Acquire_Load(atomic_class_id);
@@ skipping 16 matching lines @@
 }
 
 template<MethodID::Type type>
 jmethodID MethodID::Get(JNIEnv* env,
                         jclass clazz,
                         const char* method_name,
                         const char* jni_signature) {
   jmethodID id = type == TYPE_STATIC ?
       env->GetStaticMethodID(clazz, method_name, jni_signature) :
       env->GetMethodID(clazz, method_name, jni_signature);
-  CHECK(base::android::ClearException(env) || id) <<

[Yaron, 2016/05/05 17:08:30]

Am I crazy? Wasn't this inverted?

[Torne, 2016/05/05 17:33:22]

Yes, this was inverted, you aren't crazy. It just didn't actually matter,
because if id is non-null then there won't have been an exception set, and so
the only way there can now be an exception is if there was already a pending
uncleared exception before this call.

I'm actually not sure whether it's even idiomatic/sensible to check for
exceptions when you get valid return values from the JNI functions. In Python-C
binding it's idiomatic to check if you get NULL back and only then care about
the exception state..

-      "Failed to find " <<
-      (type == TYPE_STATIC ? "static " : "") <<
-      "method " << method_name << " " << jni_signature;
+  if (base::android::ClearException(env) || !id) {
+    LOG(FATAL) << "Failed to find " <<
+        (type == TYPE_STATIC ? "static " : "") <<
+        "method " << method_name << " " << jni_signature;
+  }
   return id;
 }
 
 // If |atomic_method_id| set, it'll return immediately. Otherwise, it'll call
 // into ::Get() above. If there's a race, it's ok since the values are the same
 // (and the duplicated effort will happen only once).
 template<MethodID::Type type>
 jmethodID MethodID::LazyGet(JNIEnv* env,
                             jclass clazz,
                             const char* method_name,
@@ skipping 50 matching lines @@
     env->ExceptionDescribe();
     env->ExceptionClear();
 
     // Set the exception_string in BuildInfo so that breakpad can read it.
     // RVO should avoid any extra copies of the exception string.
     base::android::BuildInfo::GetInstance()->SetJavaExceptionInfo(
         GetJavaExceptionInfo(env, java_throwable));
   }
 
   // Now, feel good about it and die.
-  CHECK(false) << "Please include Java exception stack in crash report";
+  LOG(FATAL) << "Please include Java exception stack in crash report";
 }
 
 std::string GetJavaExceptionInfo(JNIEnv* env, jthrowable java_throwable) {
   ScopedJavaLocalRef<jclass> throwable_clazz =
       GetClass(env, "java/lang/Throwable");
   jmethodID throwable_printstacktrace =
       MethodID::Get<MethodID::TYPE_INSTANCE>(
           env, throwable_clazz.obj(), "printStackTrace",
           "(Ljava/io/PrintStream;)V");
 
@@ skipping 31 matching lines @@
       env, static_cast<jstring>(
           env->CallObjectMethod(bytearray_output_stream.obj(),
                                 bytearray_output_stream_tostring)));
 
   return ConvertJavaStringToUTF8(exception_string);
 }
 
 
 }  // namespace android
 }  // namespace base