[Android] Check for Java object types covariance in Java Bridge

content/browser/android/java/java_method.cc

 // Copyright 2014 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/android/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/strings/string_util.h"  // For ReplaceSubstringsAfterOffset
 #include "content/browser/android/java/jni_helper.h"
 
 using base::android::AttachCurrentThread;
 using base::android::ConvertJavaStringToUTF8;
 using base::android::GetClass;
 using base::android::MethodID;
 using base::android::ScopedJavaGlobalRef;
 using base::android::ScopedJavaLocalRef;
 
 namespace content {
@@ skipping 21 matching lines @@
     JNIEnv* env = AttachCurrentThread();
     // Use placement new to initialize our instance in our preallocated space.
     return new (instance) ScopedJavaGlobalRef<jclass>(
         GetClass(env, 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) {
+std::string BinaryNameToJNISignature(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:
-      return "C";
-    case JavaType::TypeShort:
-      return "S";
-    case JavaType::TypeInt:
-      return "I";
-    case JavaType::TypeLong:
-      return "J";
-    case JavaType::TypeFloat:
-      return "F";
-    case JavaType::TypeDouble:
-      return "D";
-    case JavaType::TypeVoid:
-      return "V";
-    case JavaType::TypeArray: {
-      // For array types, the binary name uses the JNI name encodings.
-      std::string jni_name = binary_name;
-      ReplaceSubstringsAfterOffset(&jni_name, 0, ".", "/");
-      return jni_name;
-    }
-    case JavaType::TypeString:
-    case JavaType::TypeObject:
-      std::string jni_name = "L" + binary_name + ";";
-      ReplaceSubstringsAfterOffset(&jni_name, 0, ".", "/");
-      return jni_name;
-  }
-  NOTREACHED();
-  return std::string();
+  return type->JNISignature();
 }
 
 }  // namespace
 
 JavaMethod::JavaMethod(const base::android::JavaRef<jobject>& method)
     : java_method_(method),
       have_calculated_num_parameters_(false),
       id_(NULL) {
   JNIEnv* env = AttachCurrentThread();
   // On construction, we do nothing except get the name. Everything else is
@@ skipping 84 matching lines @@
   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(), GetMethodIDFromClassName(
             env,
             kJavaLangClass,
             kGetName,
             kReturningJavaLangString))));
     std::string name_utf8 = ConvertJavaStringToUTF8(name);
-    signature += BinaryNameToJNIName(name_utf8, &parameter_types_[i]);
+    signature += BinaryNameToJNISignature(name_utf8, &parameter_types_[i]);
   }
   signature += ")";
 
   // Get the return type
   ScopedJavaLocalRef<jclass> clazz(env, static_cast<jclass>(
       env->CallObjectMethod(java_method_.obj(), GetMethodIDFromClassName(
           env,
           kJavaLangReflectMethod,
           kGetReturnType,
           kReturningJavaLangClass))));
   ScopedJavaLocalRef<jstring> name(env, static_cast<jstring>(
       env->CallObjectMethod(clazz.obj(), GetMethodIDFromClassName(
           env,
           kJavaLangClass,
           kGetName,
           kReturningJavaLangString))));
-  signature += BinaryNameToJNIName(ConvertJavaStringToUTF8(name),
-                                   &return_type_);
+  signature += BinaryNameToJNISignature(ConvertJavaStringToUTF8(name),
+                                        &return_type_);
 
   // Determine whether the method is static.
   jint modifiers = env->CallIntMethod(
       java_method_.obj(), GetMethodIDFromClassName(env,
                                                    kJavaLangReflectMethod,
                                                    kGetModifiers,
                                                    kReturningInteger));
   is_static_ = env->CallStaticBooleanMethod(
       g_java_lang_reflect_modifier_class.Get().obj(),
       MethodID::Get<MethodID::TYPE_STATIC>(
@@ skipping 10 matching lines @@
           kReturningJavaLangClass))));
   id_ = is_static_ ?
       MethodID::Get<MethodID::TYPE_STATIC>(
           env, declaring_class.obj(), name_.c_str(), signature.c_str()) :
       MethodID::Get<MethodID::TYPE_INSTANCE>(
           env, declaring_class.obj(), name_.c_str(), signature.c_str());
   java_method_.Reset();
 }
 
 }  // namespace content