Don't use Singleton to cache JNI method IDs in Java Bridge

content/browser/renderer_host/java/java_bound_object.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_bound_object.h"
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
 #include "base/memory/singleton.h"
 #include "base/string_number_conversions.h"
 #include "base/stringprintf.h"
 #include "content/browser/renderer_host/java/java_type.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebBindings.h"
 
 using base::StringPrintf;
 using base::android::AttachCurrentThread;
 using base::android::ConvertUTF8ToJavaString;
+using base::android::GetMethodIDFromClassName;
 using base::android::JavaRef;
-using base::android::MethodID;
 using base::android::ScopedJavaGlobalRef;
 using base::android::ScopedJavaLocalRef;
 using WebKit::WebBindings;
 
 // The conversion between JavaScript and Java types is based on the Live
 // Connect 2 spec. See
 // http://jdk6.java.net/plugin2/liveconnect/#JS_JAVA_CONVERSIONS.
 
 // Note that in some cases, we differ from from the spec in order to maintain
 // existing behavior. These areas are marked LIVECONNECT_COMPLIANCE. We may
 // revisit this decision in the future.
 
 namespace {
 
+const char kJavaLangClass[] = "java/lang/Class";
+const char kJavaLangObject[] = "java/lang/Object";
+const char kGetClass[] = "getClass";
+const char kGetMethods[] = "getMethods";
+const char kReturningJavaLangClass[] = "()Ljava/lang/Class;";
+const char kReturningJavaLangReflectMethodArray[] =
+    "()[Ljava/lang/reflect/Method;";
+
 // Our special NPObject type.  We extend an NPObject with a pointer to a
 // JavaBoundObject.  We also add static methods for each of the NPObject
 // callbacks, which are registered by our NPClass. These methods simply
 // delegate to the private implementation methods of JavaBoundObject.
 struct JavaNPObject : public NPObject {
   JavaBoundObject* bound_object;
 
   static const NPClass kNPClass;
 
   static NPObject* Allocate(NPP npp, NPClass* np_class);
@@ skipping 430 matching lines @@
     case NPVariantType_Object:
       return CoerceJavaScriptObjectToJavaValue(variant, target_type);
     case NPVariantType_Null:
     case NPVariantType_Void:
       return CoerceJavaScriptNullOrUndefinedToJavaValue(variant, target_type);
   }
   NOTREACHED();
   return jvalue();
 }
 
-class ObjectGetClassID : public MethodID {
- public:
-  static ObjectGetClassID* GetInstance() {
-    return Singleton<ObjectGetClassID>::get();
-  }
- private:
-  friend struct DefaultSingletonTraits<ObjectGetClassID>;
-  ObjectGetClassID()
-      : MethodID(AttachCurrentThread(), "java/lang/Object", "getClass",
-                 "()Ljava/lang/Class;") {
-  }
-  DISALLOW_COPY_AND_ASSIGN(ObjectGetClassID);
-};
-
-class ClassGetMethodsID : public MethodID {
- public:
-  static ClassGetMethodsID* GetInstance() {
-    return Singleton<ClassGetMethodsID>::get();
-  }
- private:
-  friend struct DefaultSingletonTraits<ClassGetMethodsID>;
-  ClassGetMethodsID()
-      : MethodID(AttachCurrentThread(), "java/lang/Class", "getMethods",
-                 "()[Ljava/lang/reflect/Method;") {
-  }
-  DISALLOW_COPY_AND_ASSIGN(ClassGetMethodsID);
-};
-
 }  // namespace
 
 
 NPObject* JavaBoundObject::Create(const JavaRef<jobject>& object) {
   // The first argument (a plugin's instance handle) is passed through to the
   // allocate function directly, and we don't use it, so it's ok to be 0.
   // The object is created with a ref count of one.
   NPObject* np_object = WebBindings::createObject(0, const_cast<NPClass*>(
       &JavaNPObject::kNPClass));
   // The NPObject takes ownership of the JavaBoundObject.
@@ skipping 62 matching lines @@
   return true;
 }
 
 void JavaBoundObject::EnsureMethodsAreSetUp() const {
   if (!methods_.empty()) {
     return;
   }
 
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jclass> clazz(env, static_cast<jclass>(
-      env->CallObjectMethod(java_object_,
-                            ObjectGetClassID::GetInstance()->id())));
+      env->CallObjectMethod(java_object_,  GetMethodIDFromClassName(
+          env,
+          kJavaLangObject,
+          kGetClass,
+          kReturningJavaLangClass))));
   ScopedJavaLocalRef<jobjectArray> methods(env, static_cast<jobjectArray>(
-      env->CallObjectMethod(clazz.obj(),
-                            ClassGetMethodsID::GetInstance()->id())));
+      env->CallObjectMethod(clazz.obj(), GetMethodIDFromClassName(
+          env,
+          kJavaLangClass,
+          kGetMethods,
+          kReturningJavaLangReflectMethodArray))));
   size_t num_methods = env->GetArrayLength(methods.obj());
   DCHECK(num_methods) << "Java objects always have public methods";
   for (size_t i = 0; i < num_methods; ++i) {
     ScopedJavaLocalRef<jobject> java_method(
         env,
         env->GetObjectArrayElement(methods.obj(), i));
     JavaMethod* method = new JavaMethod(java_method);
     methods_.insert(std::make_pair(method->name(), method));
   }
 }