Add support for calling static methods in the Java Bridge

content/browser/renderer_host/java/java_method.cc

 // Copyright (c) 2011 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 "content/browser/renderer_host/java/java_method.h"
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
+#include "base/lazy_instance.h"
 #include "base/memory/singleton.h"
 #include "base/string_util.h"  // For ReplaceSubstringsAfterOffset
 
 using base::android::AttachCurrentThread;
 using base::android::ConvertJavaStringToUTF8;
+using base::android::GetMethodID;
 using base::android::GetMethodIDFromClassName;
+using base::android::GetStaticMethodID;
+using base::android::ScopedJavaGlobalRef;
 using base::android::ScopedJavaLocalRef;
 
 namespace {
 
 const char kGetName[] = "getName";
 const char kGetDeclaringClass[] = "getDeclaringClass";
+const char kGetModifiers[] = "getModifiers";
 const char kGetParameterTypes[] = "getParameterTypes";
 const char kGetReturnType[] = "getReturnType";
+const char kIntegerReturningBoolean[] = "(I)Z";
+const char kIsStatic[] = "isStatic";
 const char kJavaLangClass[] = "java/lang/Class";
 const char kJavaLangReflectMethod[] = "java/lang/reflect/Method";
+const char kJavaLangReflectModifier[] = "java/lang/reflect/Modifier";
+const char kReturningInteger[] = "()I";
 const char kReturningJavaLangClass[] = "()Ljava/lang/Class;";
 const char kReturningJavaLangClassArray[] = "()[Ljava/lang/Class;";
 const char kReturningJavaLangString[] = "()Ljava/lang/String;";
 
+struct ModifierClassTraits :
+    public base::DefaultLazyInstanceTraits<ScopedJavaGlobalRef<jclass> > {
+  static ScopedJavaGlobalRef<jclass>* New(void* instance) {
+    JNIEnv* env = AttachCurrentThread();
+    // Use placement new to initialize our instance in our preallocated space.
+    // The parenthesis is very important here to force POD type initialization.

[joth, 2011/12/05 15:53:23]

this sentence not needed here. (we already know ScopedJavaGlobalRef<> is not
POD)

+    return new (instance) ScopedJavaGlobalRef<jclass>(
+        ScopedJavaLocalRef<jclass>(
+            env,
+            static_cast<jclass>(env->FindClass(kJavaLangReflectModifier))));
+  }
+};
+
+base::LazyInstance<ScopedJavaGlobalRef<jclass>, ModifierClassTraits>
+    g_java_lang_reflect_modifier_class = LAZY_INSTANCE_INITIALIZER;
+
 std::string BinaryNameToJNIName(const std::string& binary_name,
                                 JavaType* type) {
   DCHECK(type);
   *type = JavaType::CreateFromBinaryName(binary_name);
   switch (type->type) {
     case JavaType::TypeBoolean:
       return "Z";
     case JavaType::TypeByte:
       return "B";
     case JavaType::TypeChar:
@@ skipping 131 matching lines @@
           kReturningJavaLangClass))));
   ScopedJavaLocalRef<jstring> name(env, static_cast<jstring>(
       env->CallObjectMethod(clazz.obj(), GetMethodIDFromClassName(
           env,
           kJavaLangClass,
           kGetName,
           kReturningJavaLangString))));
   signature += BinaryNameToJNIName(ConvertJavaStringToUTF8(env, name.obj()),
                                    &return_type_);
 
+  // Determine whether the method is static.
+  jint modifiers = env->CallIntMethod(
+      java_method_.obj(), GetMethodIDFromClassName(env,
+                                                   kJavaLangReflectMethod,
+                                                   kGetModifiers,
+                                                   kReturningInteger));
+  bool is_static = env->CallStaticBooleanMethod(
+      g_java_lang_reflect_modifier_class.Pointer()->obj(),

[joth, 2011/12/05 15:53:23]

nit: g_java_lang_reflect_modifier_class.Get().obj() is slightly easier to read.

+      GetMethodIDFromClassName(env,
+                               kJavaLangReflectModifier,
+                               kIsStatic,
+                               kIntegerReturningBoolean),
+      modifiers);
+
   // Get the ID for this method.
   ScopedJavaLocalRef<jclass> declaring_class(env, static_cast<jclass>(
       env->CallObjectMethod(java_method_.obj(), GetMethodIDFromClassName(
           env,
           kJavaLangReflectMethod,
           kGetDeclaringClass,
           kReturningJavaLangClass))));
-  id_ = base::android::GetMethodID(env, declaring_class.obj(), name_.c_str(),
-                                   signature.c_str());
+  id_ = is_static ?
+        GetStaticMethodID(env, declaring_class.obj(), name_.c_str(),
+                          signature.c_str()) :
+        GetMethodID(env, declaring_class.obj(), name_.c_str(),
+                    signature.c_str());
 
   java_method_.Reset();
 }