Don't use Singleton to cache JNI method IDs in 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::MethodID;
+using base::android::GetMethodIDFromClassName;
 using base::android::ScopedJavaLocalRef;
 
 namespace {
 
 std::string BinaryNameToJNIName(const std::string& binary_name,
                                 JavaType* type) {
   DCHECK(type);
   *type = JavaType::CreateFromBinaryName(binary_name);
   switch (type->type) {
     case JavaType::TypeBoolean:
@@ skipping 18 matching lines @@
       return "[";
     default:
       DCHECK(type->type == JavaType::TypeString ||
              type->type == JavaType::TypeObject);
       std::string jni_name = "L" + binary_name + ";";
       ReplaceSubstringsAfterOffset(&jni_name, 0, ".", "/");
       return jni_name;
   }
 }
 
-class MethodGetParameterTypesID : public MethodID {
- public:
-  static MethodGetParameterTypesID* GetInstance() {
-    return Singleton<MethodGetParameterTypesID>::get();
-  }
- private:
-  friend struct DefaultSingletonTraits<MethodGetParameterTypesID>;
-  MethodGetParameterTypesID()
-      : MethodID(AttachCurrentThread(), "java/lang/reflect/Method",
-                 "getParameterTypes", "()[Ljava/lang/Class;") {
-  }
-  DISALLOW_COPY_AND_ASSIGN(MethodGetParameterTypesID);
-};
+jmethodID GetMethodGetParameterTypesID() {
+  static jmethodID id = GetMethodIDFromClassName(AttachCurrentThread(),
+                                                 "java/lang/reflect/Method",
+                                                 "getParameterTypes",
+                                                 "()[Ljava/lang/Class;");
+  return id;
+}
 
-class MethodGetNameID : public MethodID {
- public:
-  static MethodGetNameID* GetInstance() {
-    return Singleton<MethodGetNameID>::get();
-  }
- private:
-  friend struct DefaultSingletonTraits<MethodGetNameID>;
-  MethodGetNameID()
-      : MethodID(AttachCurrentThread(), "java/lang/reflect/Method",
-                 "getName", "()Ljava/lang/String;") {
-  }
-  DISALLOW_COPY_AND_ASSIGN(MethodGetNameID);
-};
+jmethodID GetMethodGetNameID() {
+  static jmethodID id = GetMethodIDFromClassName(AttachCurrentThread(),
+                                                    "java/lang/reflect/Method",
+                                                    "getName",
+                                                    "()Ljava/lang/String;");
+  return id;
+}
 
-class MethodGetReturnTypeID : public MethodID {
- public:
-  static MethodGetReturnTypeID* GetInstance() {
-    return Singleton<MethodGetReturnTypeID>::get();
-  }
- private:
-  friend struct DefaultSingletonTraits<MethodGetReturnTypeID>;
-  MethodGetReturnTypeID()
-      : MethodID(AttachCurrentThread(), "java/lang/reflect/Method",
-                 "getReturnType", "()Ljava/lang/Class;") {
-  }
-  DISALLOW_COPY_AND_ASSIGN(MethodGetReturnTypeID);
-};
+jmethodID GetMethodGetReturnTypeID() {
+  static jmethodID id = GetMethodIDFromClassName(AttachCurrentThread(),
+                                                 "java/lang/reflect/Method",
+                                                 "getReturnType",
+                                                 "()Ljava/lang/Class;");
+  return id;
+}
 
-class MethodGetDeclaringClassID : public MethodID {
- public:
-  static MethodGetDeclaringClassID* GetInstance() {
-    return Singleton<MethodGetDeclaringClassID>::get();
-  }
- private:
-  friend struct DefaultSingletonTraits<MethodGetDeclaringClassID>;
-  MethodGetDeclaringClassID()
-      : MethodID(AttachCurrentThread(), "java/lang/reflect/Method",
-                 "getDeclaringClass", "()Ljava/lang/Class;") {
-  }
-  DISALLOW_COPY_AND_ASSIGN(MethodGetDeclaringClassID);
-};
+jmethodID GetMethodGetDeclaringClassID() {
+  static jmethodID id = GetMethodIDFromClassName(AttachCurrentThread(),
+                                                 "java/lang/reflect/Method",
+                                                 "getDeclaringClass",
+                                                 "()Ljava/lang/Class;");
+  return id;
+}
 
-class ClassGetNameID : public MethodID {
- 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);
-};
+jmethodID GetClassGetNameID() {
+  static jmethodID id = GetMethodIDFromClassName(AttachCurrentThread(),
+                                                   "java/lang/Class",
+                                                   "getName",
+                                                   "()Ljava/lang/String;");
+  return id;
+}
 
 }  // 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>(
-      env->CallObjectMethod(java_method_.obj(),
-                            MethodGetNameID::GetInstance()->id())));
+      env->CallObjectMethod(java_method_.obj(), GetMethodGetNameID())));
   name_ = ConvertJavaStringToUTF8(env, name.obj());
 }
 
 JavaMethod::~JavaMethod() {
 }
 
 size_t JavaMethod::num_parameters() const {
   EnsureNumParametersIsSetUp();
   return num_parameters_;
 }
@@ skipping 18 matching lines @@
     return;
   }
   have_calculated_num_parameters_ = true;
 
   // The number of parameters will be used frequently when determining
   // whether to call this method. We don't get the ID etc until actually
   // required.
   JNIEnv* env = java_method_.env();
   ScopedJavaLocalRef<jarray> parameters(env, static_cast<jarray>(
       env->CallObjectMethod(java_method_.obj(),
-                            MethodGetParameterTypesID::GetInstance()->id())));
+                            GetMethodGetParameterTypesID())));
   num_parameters_ = env->GetArrayLength(parameters.obj());
 }
 
 void JavaMethod::EnsureTypesAndIDAreSetUp() const {
   if (id_) {
     return;
   }
 
   // Get the parameters
   JNIEnv* env = java_method_.env();
   ScopedJavaLocalRef<jobjectArray> parameters(env, static_cast<jobjectArray>(
       env->CallObjectMethod(java_method_.obj(),
-                            MethodGetParameterTypesID::GetInstance()->id())));
+                            GetMethodGetParameterTypesID())));
   // Usually, this will already have been called.
   EnsureNumParametersIsSetUp();
   DCHECK_EQ(num_parameters_,
             static_cast<size_t>(env->GetArrayLength(parameters.obj())));
 
   // Java gives us the argument type using an extended version of the 'binary
   // name'. See
   // http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Class.html#getName().
   // If we build the signature now, there's no need to store the binary name
   // of the arguments. We just store the simple type.
   std::string signature("(");
 
   // Form the signature and record the parameter types.
   parameter_types_.resize(num_parameters_);
   for (size_t i = 0; i < num_parameters_; ++i) {
     ScopedJavaLocalRef<jobject> parameter(env, env->GetObjectArrayElement(
         parameters.obj(), i));
     ScopedJavaLocalRef<jstring> name(env, static_cast<jstring>(
-        env->CallObjectMethod(parameter.obj(),
-                              ClassGetNameID::GetInstance()->id())));
+        env->CallObjectMethod(parameter.obj(), GetClassGetNameID())));
     std::string name_utf8 = ConvertJavaStringToUTF8(env, name.obj());
     signature += BinaryNameToJNIName(name_utf8, &parameter_types_[i]);
   }
   signature += ")";
 
   // Get the return type
   ScopedJavaLocalRef<jclass> clazz(env, static_cast<jclass>(
-      env->CallObjectMethod(java_method_.obj(),
-                            MethodGetReturnTypeID::GetInstance()->id())));
+      env->CallObjectMethod(java_method_.obj(), GetMethodGetReturnTypeID())));
   ScopedJavaLocalRef<jstring> name(env, static_cast<jstring>(
-      env->CallObjectMethod(clazz.obj(), ClassGetNameID::GetInstance()->id())));
+      env->CallObjectMethod(clazz.obj(), GetClassGetNameID())));
   signature += BinaryNameToJNIName(ConvertJavaStringToUTF8(env, name.obj()),
                                    &return_type_);
 
   // Get the ID for this method.
   ScopedJavaLocalRef<jclass> declaring_class(env, static_cast<jclass>(
       env->CallObjectMethod(java_method_.obj(),
-                            MethodGetDeclaringClassID::GetInstance()->id())));
+                            GetMethodGetDeclaringClassID())));
   id_ = base::android::GetMethodID(env, declaring_class.obj(), name_.c_str(),
                                    signature.c_str());
 
   java_method_.Reset();
 }