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/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::GetStaticMethodID;
 using base::android::MethodID;
 using base::android::ScopedJavaLocalRef;
 
 namespace {
 
 // Java's reflection API represents types as a string using an extended 'binary
 // name'. This converts to an enum which we store in place of the binary name
 // for simplicity.
 JavaType::Type BinaryNameToType(const std::string& binary_name) {
   if (binary_name == "boolean") {
@@ skipping 48 matching lines @@
     case JavaType::TypeArray:
       return "[";
     default:
       DCHECK (*type == JavaType::TypeString || *type == JavaType::TypeObject);
       std::string jni_name = "L" + binary_name + ";";
       ReplaceSubstringsAfterOffset(&jni_name, 0, ".", "/");
       return jni_name;
   }
 }
 
 class MethodGetParameterTypesID : public MethodID {

[joth, 2011/11/29 11:24:36]

aside: I never noticed MethodID get added in the later patch of the prior CL.

I don't think it really belongs in base/... as (a) it's only useful if derived
into a class hierarchy - seems nicer to keep base primitives concrete where they
can be, and (b) the comment on it suggests it's not as good to use as the plain
GetMethodId method (that avoids the class name lookup)

more aside: as a general pattern I think the static jmethodId is preferable to
these Signletons: as well as needing less boiler plate, they also don't have the
heap overhead. (no difference for 1 or 2, but over hundreds of these things it
could add up?)

[Steve Block, 2011/11/29 16:54:00]

Personally I prefer a simple static too, but I think that statics are
discouraged. It was suggested that I use a Singleton -
http://codereview.chromium.org/8509019/diff/12003/content/browser/renderer_ho...

  public:
   static MethodGetParameterTypesID* GetInstance() {
     return Singleton<MethodGetParameterTypesID>::get();
   }
  private:
   friend struct DefaultSingletonTraits<MethodGetParameterTypesID>;
   MethodGetParameterTypesID()
       : MethodID(AttachCurrentThread(), "java/lang/reflect/Method",
                  "getParameterTypes", "()[Ljava/lang/Class;") {
   }
@@ skipping 35 matching lines @@
   }
  private:
   friend struct DefaultSingletonTraits<MethodGetDeclaringClassID>;
   MethodGetDeclaringClassID()
       : MethodID(AttachCurrentThread(), "java/lang/reflect/Method",
                  "getDeclaringClass", "()Ljava/lang/Class;") {
   }
   DISALLOW_COPY_AND_ASSIGN(MethodGetDeclaringClassID);
 };
 
+class MethodGetModifiersID : public MethodID {

[joth, 2011/11/29 11:24:36]

nit: I'd find all these easier to read if named like GetModifiersMethodId 

[Steve Block, 2011/11/29 16:54:00]

All of these are named <class><method>ID. I don't think we need an extra 'Get'?

+ public:
+  static MethodGetModifiersID* GetInstance() {
+    return Singleton<MethodGetModifiersID>::get();
+  }
+ private:

[joth, 2011/11/29 11:24:36]

nit: we normally have a blank line before private: and another before
DISALLOW.... (applies to whole file)

[Steve Block, 2011/11/29 16:54:00]

Done.

+  friend struct DefaultSingletonTraits<MethodGetModifiersID>;
+  MethodGetModifiersID()
+      : MethodID(AttachCurrentThread(), "java/lang/reflect/Method",
+                 "getModifiers", "()I") {
+  }
+  DISALLOW_COPY_AND_ASSIGN(MethodGetModifiersID);
+};
+
 class ClassGetNameID : public MethodID {

[joth, 2011/11/29 11:24:36]

add 'Method' in the name for consistency with the rest

[Steve Block, 2011/11/29 16:54:00]

See above

  public:
   static ClassGetNameID* GetInstance() {
     return Singleton<ClassGetNameID>::get();
   }
  private:
   friend struct DefaultSingletonTraits<ClassGetNameID>;
   ClassGetNameID()
       : MethodID(AttachCurrentThread(), "java/lang/Class", "getName",
                  "()Ljava/lang/String;") {
   }
   DISALLOW_COPY_AND_ASSIGN(ClassGetNameID);
 };
 
+class ModifierIsStaticID {
+ public:
+  static ModifierIsStaticID* GetInstance() {
+    return Singleton<ModifierIsStaticID>::get();
+  }
+  jclass clazz() { return clazz_.obj(); }
+  jmethodID id() { return id_; }
+ private:
+  friend struct DefaultSingletonTraits<ModifierIsStaticID>;
+  ModifierIsStaticID() {
+    JNIEnv* env = AttachCurrentThread();
+    clazz_.Reset(env, env->FindClass("java/lang/reflect/Modifier"));
+    id_ = GetStaticMethodID(env, clazz_.obj(), "isStatic", "(I)Z");
+  }
+  base::android::ScopedJavaGlobalRef<jclass> clazz_;
+  jmethodID id_;
+  DISALLOW_COPY_AND_ASSIGN(ModifierIsStaticID);
+};
+
 }  // namespace
 
 JavaMethod::JavaMethod(const base::android::JavaRef<jobject>& method)
     : java_method_(method),
       have_calculated_num_parameters_(false),
       id_(NULL) {
   JNIEnv* env = java_method_.env();
   // On construction, we do nothing except get the name. Everything else is
   // done lazily.
   ScopedJavaLocalRef<jstring> name(env, static_cast<jstring>(
@@ skipping 78 matching lines @@
 
   // Get the return type
   ScopedJavaLocalRef<jclass> clazz(env, static_cast<jclass>(
       env->CallObjectMethod(java_method_.obj(),
                             MethodGetReturnTypeID::GetInstance()->id())));
   ScopedJavaLocalRef<jstring> name(env, static_cast<jstring>(
       env->CallObjectMethod(clazz.obj(), ClassGetNameID::GetInstance()->id())));
   signature += BinaryNameToJNIName(ConvertJavaStringToUTF8(env, name.obj()),
                                    &return_type_);
 
+  // Determine whether the method is static.
+  jint modifiers = env->CallIntMethod(
+      java_method_.obj(),
+      MethodGetModifiersID::GetInstance()->id());
+  bool is_static = env->CallStaticBooleanMethod(
+      ModifierIsStaticID::GetInstance()->clazz(),
+      ModifierIsStaticID::GetInstance()->id(),
+      modifiers);
+
   // Get the ID for this method.
   ScopedJavaLocalRef<jclass> declaring_class(env, static_cast<jclass>(
       env->CallObjectMethod(java_method_.obj(),
                             MethodGetDeclaringClassID::GetInstance()->id())));
-  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();
 }