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

content/browser/android/java/java_type.cc

Index: content/browser/android/java/java_type.cc
diff --git a/content/browser/android/java/java_type.cc b/content/browser/android/java/java_type.cc
index c2808fecca164614050f5340bee4bf3ce9336014..5cd9b5454358afc37ec12352a6d7a9c5a68c19c2 100644
--- a/content/browser/android/java/java_type.cc
+++ b/content/browser/android/java/java_type.cc
@@ -5,53 +5,62 @@
 #include "content/browser/android/java/java_type.h"
 
 #include "base/logging.h"
+#include "base/strings/string_util.h"  // For ReplaceSubstringsAfterOffset
 
 namespace content {
 namespace {
 
-JavaType JavaTypeFromJNIName(const std::string& jni_name) {
-  JavaType result;
-  DCHECK(!jni_name.empty());
-  switch (jni_name[0]) {
+// Array component type names are similar to JNI type names, except for using
+// dots as namespace separators in class names.
+scoped_ptr<JavaType> CreateFromArrayComponentTypeName(
+    const std::string& type_name) {
+  scoped_ptr<JavaType> result(new JavaType());
+  DCHECK(!type_name.empty());
+  switch (type_name[0]) {
     case 'Z':
-      result.type = JavaType::TypeBoolean;
+      result->type = JavaType::TypeBoolean;
       break;
     case 'B':
-      result.type = JavaType::TypeByte;
+      result->type = JavaType::TypeByte;
       break;
     case 'C':
-      result.type = JavaType::TypeChar;
+      result->type = JavaType::TypeChar;
       break;
     case 'S':
-      result.type = JavaType::TypeShort;
+      result->type = JavaType::TypeShort;
       break;
     case 'I':
-      result.type = JavaType::TypeInt;
+      result->type = JavaType::TypeInt;
       break;
     case 'J':
-      result.type = JavaType::TypeLong;
+      result->type = JavaType::TypeLong;
       break;
     case 'F':
-      result.type = JavaType::TypeFloat;
+      result->type = JavaType::TypeFloat;
       break;
     case 'D':
-      result.type = JavaType::TypeDouble;
+      result->type = JavaType::TypeDouble;
       break;
     case '[':
-      result.type = JavaType::TypeArray;
-      // LIVECONNECT_COMPLIANCE: We don't support multi-dimensional arrays, so
-      // there's no need to populate the inner types.
+      result->type = JavaType::TypeArray;
+      result->inner_type =
+          CreateFromArrayComponentTypeName(type_name.substr(1));
       break;
     case 'L':
-      result.type = jni_name == "Ljava.lang.String;" ?
-                    JavaType::TypeString :
-                    JavaType::TypeObject;
+      if (type_name == "Ljava.lang.String;") {
+        result->type = JavaType::TypeString;
+        result->class_jni_name = "java/lang/String";
+      } else {
+        result->type = JavaType::TypeObject;
+        result->class_jni_name = type_name.substr(1, type_name.length() - 2);
+        ReplaceSubstringsAfterOffset(&result->class_jni_name, 0, ".", "/");
+      }
       break;
     default:
       // Includes void (V).
       NOTREACHED();
   }
-  return result;
+  return result.Pass();
 }
 
 }  // namespace
@@ -67,6 +76,8 @@ JavaType::~JavaType() {
 }
 
 JavaType& JavaType::operator=(const JavaType& other) {
+  if (this == &other)
+    return *this;
   type = other.type;
   if (other.inner_type) {
     DCHECK_EQ(JavaType::TypeArray, type);
@@ -74,9 +85,11 @@ JavaType& JavaType::operator=(const JavaType& other) {
   } else {
     inner_type.reset();
   }
+  class_jni_name = other.class_jni_name;
   return *this;
 }
 
+// static
 JavaType JavaType::CreateFromBinaryName(const std::string& binary_name) {
   JavaType result;
   DCHECK(!binary_name.empty());
@@ -100,15 +113,53 @@ JavaType JavaType::CreateFromBinaryName(const std::string& binary_name) {
     result.type = JavaType::TypeVoid;
   } else if (binary_name[0] == '[') {
     result.type = JavaType::TypeArray;
-    // The inner type of an array is represented in JNI format.
-    result.inner_type.reset(new JavaType(JavaTypeFromJNIName(
-        binary_name.substr(1))));
+    result.inner_type = CreateFromArrayComponentTypeName(binary_name.substr(1));
   } else if (binary_name == "java.lang.String") {
     result.type = JavaType::TypeString;
+    result.class_jni_name = "java/lang/String";
   } else {
     result.type = JavaType::TypeObject;
+    result.class_jni_name = binary_name;
+    ReplaceSubstringsAfterOffset(&result.class_jni_name, 0, ".", "/");
   }
   return result;
 }
 
+std::string JavaType::JNIName() const {
+  switch (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:
+      return "[" + inner_type->JNISignature();
+    case JavaType::TypeString:
+    case JavaType::TypeObject:
+      return class_jni_name;
+  }
+  NOTREACHED();
+  return std::string();
+}
+
+std::string JavaType::JNISignature() const {
+  if (type == JavaType::TypeString || type == JavaType::TypeObject)
+    return "L" + JNIName() + ";";
+  else
+    return JNIName();
+}
+
 }  // namespace content