Android: adds Get(Static)MethodIDOrNULL.

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 <map>
 
 #include "base/android/build_info.h"
 #include "base/android/jni_string.h"
@@ skipping 78 matching lines @@
       printstream.obj());
 
   // Call ByteArrayOutputStream.toString()
   ScopedJavaLocalRef<jstring> exception_string(
       env, static_cast<jstring>(
           env->CallObjectMethod(bytearray_output_stream.obj(),
                                 bytearray_output_stream_tostring)));
 
   return ConvertJavaStringToUTF8(exception_string);
 }
+
+enum MethodType {
+  METHODTYPE_STATIC,
+  METHODTYPE_NORMAL,
+};
+
+enum ExceptionCheck {
+  EXCEPTIONCHECK_YES,
+  EXCEPTIONCHECK_NO,
+};
+
+template<MethodType method_type, ExceptionCheck exception_check>
+jmethodID GetMethodIDInternal(JNIEnv* env,
+                              jclass clazz,
+                              const char* method_name,
+                              const char* jni_signature) {
+  jmethodID method_id = method_type == METHODTYPE_STATIC ?
+      env->GetStaticMethodID(clazz, method_name, jni_signature) :
+      env->GetMethodID(clazz, method_name, jni_signature);
+  if (exception_check == EXCEPTIONCHECK_YES) {
+    CHECK(!base::android::ClearException(env) && method_id) <<
+      "Failed to find " <<
+      (method_type == METHODTYPE_STATIC ? "static " : "") <<
+      "method " << method_name << " " << jni_signature;
+  } else if (base::android::HasException(env)) {
+    env->ExceptionClear();
+  }
+  return method_id;
+}
+
 }  // namespace
 
 namespace base {
 namespace android {
 
 JNIEnv* AttachCurrentThread() {
   if (!g_jvm)
     return NULL;
   JNIEnv* env = NULL;
   jint ret = g_jvm->AttachCurrentThread(&env, NULL);
@@ skipping 22 matching lines @@
   DCHECK(!g_application_context.Get().is_null());
   return g_application_context.Get().obj();
 }
 
 ScopedJavaLocalRef<jclass> GetClass(JNIEnv* env, const char* class_name) {
   return ScopedJavaLocalRef<jclass>(env, GetUnscopedClass(env, class_name));
 }
 
 jclass GetUnscopedClass(JNIEnv* env, const char* class_name) {
   jclass clazz = env->FindClass(class_name);
-  CHECK(clazz && !ClearException(env)) << "Failed to find class " << class_name;
+  CHECK(!ClearException(env) && clazz) << "Failed to find class " << class_name;
   return clazz;
 }
 
 bool HasClass(JNIEnv* env, const char* class_name) {
   ScopedJavaLocalRef<jclass> clazz(env, env->FindClass(class_name));
   if (!clazz.obj()) {
     ClearException(env);
     return false;
   }
   bool error = ClearException(env);
   DCHECK(!error);
   return true;
 }
 
 jmethodID GetMethodID(JNIEnv* env,
                       const JavaRef<jclass>& clazz,
                       const char* method_name,
                       const char* jni_signature) {
   // clazz.env() can not be used as that may be from a different thread.
   return GetMethodID(env, clazz.obj(), method_name, jni_signature);
 }
 
 jmethodID GetMethodID(JNIEnv* env,
                       jclass clazz,
                       const char* method_name,
                       const char* jni_signature) {
-  jmethodID method_id =
-      env->GetMethodID(clazz, method_name, jni_signature);
-  CHECK(method_id && !ClearException(env)) << "Failed to find method " <<
-      method_name << " " << jni_signature;
-  return method_id;
+  return GetMethodIDInternal<METHODTYPE_NORMAL, EXCEPTIONCHECK_YES>(
+      env, clazz, method_name, jni_signature);
+}
+
+jmethodID GetMethodIDOrNull(JNIEnv* env,
+                            jclass clazz,
+                            const char* method_name,
+                            const char* jni_signature) {
+  return GetMethodIDInternal<METHODTYPE_NORMAL, EXCEPTIONCHECK_NO>(
+      env, clazz, method_name, jni_signature);
 }
 
 jmethodID GetStaticMethodID(JNIEnv* env,
                             const JavaRef<jclass>& clazz,
                             const char* method_name,
                             const char* jni_signature) {
   return GetStaticMethodID(env, clazz.obj(), method_name,
       jni_signature);
 }
 
 jmethodID GetStaticMethodID(JNIEnv* env,
                             jclass clazz,
                             const char* method_name,
                             const char* jni_signature) {
-  jmethodID method_id =
-      env->GetStaticMethodID(clazz, method_name, jni_signature);
-  CHECK(method_id && !ClearException(env)) << "Failed to find static method " <<
-      method_name << " " << jni_signature;
-  return method_id;
+  return GetMethodIDInternal<METHODTYPE_STATIC, EXCEPTIONCHECK_YES>(
+      env, clazz, method_name, jni_signature);
+}
+
+jmethodID GetStaticMethodIDOrNull(JNIEnv* env,
+                                  jclass clazz,
+                                  const char* method_name,
+                                  const char* jni_signature) {
+  return GetMethodIDInternal<METHODTYPE_STATIC, EXCEPTIONCHECK_NO>(
+      env, clazz, method_name, jni_signature);
 }
 
 bool HasMethod(JNIEnv* env,
                const JavaRef<jclass>& clazz,
                const char* method_name,
                const char* jni_signature) {
   jmethodID method_id =
       env->GetMethodID(clazz.obj(), method_name, jni_signature);
   if (!method_id) {
     ClearException(env);
     return false;
   }
   bool error = ClearException(env);
   DCHECK(!error);
   return true;
 }
 
 jfieldID GetFieldID(JNIEnv* env,
                     const JavaRef<jclass>& clazz,
                     const char* field_name,
                     const char* jni_signature) {
   jfieldID field_id = env->GetFieldID(clazz.obj(), field_name, jni_signature);
-  CHECK(field_id && !ClearException(env)) << "Failed to find field " <<
+  CHECK(!ClearException(env) && field_id) << "Failed to find field " <<
       field_name << " " << jni_signature;
   bool error = ClearException(env);

[joth, 2012/10/02 17:51:40]

so we can remove this ClearException now...

[bulach, 2012/10/02 18:02:26]

Done.

   DCHECK(!error);
   return field_id;
 }
 
 bool HasField(JNIEnv* env,
               const JavaRef<jclass>& clazz,
               const char* field_name,
               const char* jni_signature) {
   jfieldID field_id = env->GetFieldID(clazz.obj(), field_name, jni_signature);
   if (!field_id) {
     ClearException(env);
     return false;
   }
   bool error = ClearException(env);
   DCHECK(!error);
   return true;
 }
 
 jfieldID GetStaticFieldID(JNIEnv* env,
                           const JavaRef<jclass>& clazz,
                           const char* field_name,
                           const char* jni_signature) {
   jfieldID field_id =
       env->GetStaticFieldID(clazz.obj(), field_name, jni_signature);
-  CHECK(field_id && !ClearException(env)) << "Failed to find static field " <<
+  CHECK(!ClearException(env) && field_id) << "Failed to find static field " <<
       field_name << " " << jni_signature;
   bool error = ClearException(env);

[joth, 2012/10/02 17:51:40]

ditto

[bulach, 2012/10/02 18:02:26]

Done.

   DCHECK(!error);
   return field_id;
 }
 
 jmethodID GetMethodIDFromClassName(JNIEnv* env,
                                    const char* class_name,
                                    const char* method,
                                    const char* jni_signature) {
   MethodIdentifier key;
   key.class_name = class_name;
@@ skipping 65 matching lines @@
   // RVO should avoid any extra copies of the exception string.
   base::android::BuildInfo::GetInstance()->set_java_exception_info(
       GetJavaExceptionInfo(env, java_throwable));
 
   // Now, feel good about it and die.
   CHECK(false);
 }
 
 }  // namespace android
 }  // namespace base