Fix an incorrect comment in the Java Bridge when calling array methods

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"
@@ skipping 82 matching lines @@
 bool JavaNPObject::Invoke(NPObject* np_object, NPIdentifier np_identifier,
                           const NPVariant* args, uint32_t arg_count,
                           NPVariant* result) {
   std::string name = NPIdentifierToString(np_identifier);
   JavaNPObject* obj = reinterpret_cast<JavaNPObject*>(np_object);
   return obj->bound_object->Invoke(name, args, arg_count, result);
 }
 
 bool JavaNPObject::HasProperty(NPObject* np_object,
                                NPIdentifier np_identifier) {
-  // LIVECONNECT_COMPLIANCE: Return false to indicate that the property is not
-  // present. We should support this correctly.
+  // LIVECONNECT_COMPLIANCE: Existing behavior is to return false to indicate
+  // that the property is not present. Spec requires supporting this correctly.
   return false;
 }
 
 bool JavaNPObject::GetProperty(NPObject* np_object,
                                NPIdentifier np_identifier,
                                NPVariant* result) {
-  // LIVECONNECT_COMPLIANCE: Return false to indicate that the property is
-  // undefined. We should support this correctly.
+  // LIVECONNECT_COMPLIANCE: Existing behavior is to return false to indicate
+  // that the property is undefined. Spec requires supporting this correctly.
   return false;
 }
 
 // Calls a Java method through JNI and returns the result as an NPVariant. Note
 // that this method does not do any type coercion. The Java return value is
 // simply converted to the corresponding NPAPI type.
 NPVariant CallJNIMethod(jobject object, JavaType::Type return_type,
                         jmethodID id, jvalue* parameters) {
   JNIEnv* env = AttachCurrentThread();
   NPVariant result;
@@ skipping 23 matching lines @@
       break;
     case JavaType::TypeDouble:
       DOUBLE_TO_NPVARIANT(env->CallDoubleMethodA(object, id, parameters),
                           result);
       break;
     case JavaType::TypeVoid:
       env->CallVoidMethodA(object, id, parameters);
       VOID_TO_NPVARIANT(result);
       break;
     case JavaType::TypeArray:
-      // TODO(steveblock): Handle arrays
+      // LIVECONNECT_COMPLIANCE: Existing behavior is to not call methods that
+      // return arrays. Spec requires calling the method and converting the
+      // result to a JavaScript array.
       VOID_TO_NPVARIANT(result);
       break;
     case JavaType::TypeString: {
       ScopedJavaLocalRef<jstring> java_string(env, static_cast<jstring>(
           env->CallObjectMethodA(object, id, parameters)));
       if (!java_string.obj()) {
-        // LIVECONNECT_COMPLIANCE: Return undefined to maintain existing
-        // behavior. We should return a null string.
+        // LIVECONNECT_COMPLIANCE: Existing behavior is to return undefined.
+        // Spec requires returning a null string.
         VOID_TO_NPVARIANT(result);
         break;
       }
       std::string str =
           base::android::ConvertJavaStringToUTF8(env, java_string.obj());
       // Take a copy and pass ownership to the variant. We must allocate using
       // NPN_MemAlloc, to match NPN_ReleaseVariant, which uses NPN_MemFree.
       size_t length = str.length();
       char* buffer = static_cast<char*>(NPN_MemAlloc(length));
       str.copy(buffer, length, 0);
@@ skipping 21 matching lines @@
   jvalue result;
   DCHECK(variant.type == NPVariantType_Int32 ||
          variant.type == NPVariantType_Double);
   bool is_double = variant.type == NPVariantType_Double;
   switch (target_type) {
     case JavaType::TypeByte:
       result.b = is_double ? static_cast<jbyte>(NPVARIANT_TO_DOUBLE(variant)) :
                              static_cast<jbyte>(NPVARIANT_TO_INT32(variant));
       break;
     case JavaType::TypeChar:
-      // LIVECONNECT_COMPLIANCE: Convert double to 0 to maintain existing
-      // behavior.
+      // LIVECONNECT_COMPLIANCE: Existing behavior is to convert double to 0.
+      // Spec requires converting doubles the same as int32.
       result.c = is_double ? 0 :
                              static_cast<jchar>(NPVARIANT_TO_INT32(variant));
       break;
     case JavaType::TypeShort:
       result.s = is_double ? static_cast<jshort>(NPVARIANT_TO_DOUBLE(variant)) :
                              static_cast<jshort>(NPVARIANT_TO_INT32(variant));
       break;
     case JavaType::TypeInt:
       result.i = is_double ? static_cast<jint>(NPVARIANT_TO_DOUBLE(variant)) :
                              NPVARIANT_TO_INT32(variant);
       break;
     case JavaType::TypeLong:
       result.j = is_double ? static_cast<jlong>(NPVARIANT_TO_DOUBLE(variant)) :
                              NPVARIANT_TO_INT32(variant);
       break;
     case JavaType::TypeFloat:
       result.f = is_double ? static_cast<jfloat>(NPVARIANT_TO_DOUBLE(variant)) :
                              NPVARIANT_TO_INT32(variant);
       break;
     case JavaType::TypeDouble:
       result.d = is_double ? NPVARIANT_TO_DOUBLE(variant) :
                              NPVARIANT_TO_INT32(variant);
       break;
     case JavaType::TypeObject:
-      // LIVECONNECT_COMPLIANCE: Convert to null to maintain existing behavior.
-      // We should handle object equivalents of primitive types.
+      // LIVECONNECT_COMPLIANCE: Existing behavior is to convert to null. Spec
+      // requires handling object equivalents of primitive types.
       result.l = NULL;
       break;
     case JavaType::TypeString:
       result.l = ConvertUTF8ToJavaString(
           AttachCurrentThread(),
           is_double ?  StringPrintf("%.6lg", NPVARIANT_TO_DOUBLE(variant)) :
                        base::IntToString(NPVARIANT_TO_INT32(variant)));
       break;
     case JavaType::TypeBoolean:
-      // LIVECONNECT_COMPLIANCE: Convert to false to maintain existing behavior.
-      // We should convert to false for o or NaN, true otherwise.
+      // LIVECONNECT_COMPLIANCE: Existing behavior is to convert to false. Spec
+      // requires converting to false for 0 or NaN, true otherwise.
       result.z = JNI_FALSE;
       break;
     case JavaType::TypeArray:
-      // LIVECONNECT_COMPLIANCE: Convert to null to maintain existing behavior.
-      // We should raise a JavaScript exception.
+      // LIVECONNECT_COMPLIANCE: Existing behavior is to convert to null. Spec
+      // requires raising a JavaScript exception.
       result.l = NULL;
       break;
     case JavaType::TypeVoid:
       // Conversion to void must never happen.
       NOTREACHED();
       break;
   }
   return result;
 }
 
 jvalue CoerceJavaScriptBooleanToJavaValue(const NPVariant& variant,
                                           JavaType::Type target_type) {
   // See http://jdk6.java.net/plugin2/liveconnect/#JS_BOOLEAN_VALUES.
   DCHECK_EQ(NPVariantType_Bool, variant.type);
   bool boolean_value = NPVARIANT_TO_BOOLEAN(variant);
   jvalue result;
   switch (target_type) {
     case JavaType::TypeBoolean:
       result.z = boolean_value ? JNI_TRUE : JNI_FALSE;
       break;
     case JavaType::TypeObject:
-      // LIVECONNECT_COMPLIANCE: Convert to NULL to maintain existing behavior.
-      // We should handle java.lang.Boolean and java.lang.Object.
+      // LIVECONNECT_COMPLIANCE: Existing behavior is to convert to NULL. Spec
+      // requires handling java.lang.Boolean and java.lang.Object.
       result.l = NULL;
       break;
     case JavaType::TypeString:
       result.l = ConvertUTF8ToJavaString(AttachCurrentThread(),
                                          boolean_value ? "true" : "false");
       break;
     case JavaType::TypeByte:
     case JavaType::TypeChar:
     case JavaType::TypeShort:
     case JavaType::TypeInt:
     case JavaType::TypeLong:
     case JavaType::TypeFloat:
     case JavaType::TypeDouble: {
-      // LIVECONNECT_COMPLIANCE: Convert to 0 to maintain existing behavior. We
-      // should convert to 0 or 1.
+      // LIVECONNECT_COMPLIANCE: Existing behavior is to convert to 0. Spec
+      // requires converting to 0 or 1.
       jvalue null_value = {0};
       result = null_value;
       break;
     }
     case JavaType::TypeArray:
-      // LIVECONNECT_COMPLIANCE: Convert to NULL to maintain existing behavior.
-      // We should raise a JavaScript exception.
+      // LIVECONNECT_COMPLIANCE: Existing behavior is to convert to NULL. Spec
+      // requires raising a JavaScript exception.
       result.l = NULL;
       break;
     case JavaType::TypeVoid:
       // Conversion to void must never happen.
       NOTREACHED();
       break;
   }
   return result;
 }
 
 jvalue CoerceJavaScriptStringToJavaValue(const NPVariant& variant,
                                          JavaType::Type target_type) {
   // See http://jdk6.java.net/plugin2/liveconnect/#JS_STRING_VALUES.
   DCHECK_EQ(NPVariantType_String, variant.type);
   jvalue result;
   switch (target_type) {
     case JavaType::TypeString:
       result.l = ConvertUTF8ToJavaString(
           AttachCurrentThread(),
           base::StringPiece(NPVARIANT_TO_STRING(variant).UTF8Characters,
                             NPVARIANT_TO_STRING(variant).UTF8Length));
       break;
     case JavaType::TypeObject:
-      // LIVECONNECT_COMPLIANCE: Convert to NULL to maintain existing behavior.
-      // We should handle java.lang.Object.
+      // LIVECONNECT_COMPLIANCE: Existing behavior is to convert to NULL. Spec
+      // requires handling java.lang.Object.
       result.l = NULL;
       break;
     case JavaType::TypeByte:
     case JavaType::TypeShort:
     case JavaType::TypeInt:
     case JavaType::TypeLong:
     case JavaType::TypeFloat:
     case JavaType::TypeDouble: {
-      // LIVECONNECT_COMPLIANCE: Convert to 0 to maintain existing behavior. we
-      // should use valueOf() method of corresponding object type.
+      // LIVECONNECT_COMPLIANCE: Existing behavior is to convert to 0. Spec
+      // requires using valueOf() method of corresponding object type.
       jvalue null_value = {0};
       result = null_value;
       break;
     }
     case JavaType::TypeChar:
-      // LIVECONNECT_COMPLIANCE: Convert to 0 to maintain existing behavior. we
-      // should use java.lang.Short.decode().
+      // LIVECONNECT_COMPLIANCE: Existing behavior is to convert to 0. Spec
+      // requires using java.lang.Short.decode().
       result.c = 0;
       break;
     case JavaType::TypeBoolean:
-      // LIVECONNECT_COMPLIANCE: Convert to false to maintain existing behavior.
-      // We should convert the empty string to false, otherwise true.
+      // LIVECONNECT_COMPLIANCE: Existing behavior is to convert to false. Spec
+      // requires converting the empty string to false, otherwise true.
       result.z = JNI_FALSE;
       break;
     case JavaType::TypeArray:
-      // LIVECONNECT_COMPLIANCE: Convert to NULL to maintain existing behavior.
-      // We should raise a JavaScript exception.
+      // LIVECONNECT_COMPLIANCE: Existing behavior is to convert to NULL. Spec
+      // requires raising a JavaScript exception.
       result.l = NULL;
       break;
     case JavaType::TypeVoid:
       // Conversion to void must never happen.
       NOTREACHED();
       break;
   }
   return result;
 }
 
 jvalue CoerceJavaScriptObjectToJavaValue(const NPVariant& variant,
                                          JavaType::Type target_type) {
   // We only handle Java objects. See
   // http://jdk6.java.net/plugin2/liveconnect/#JS_JAVA_OBJECTS.
   // TODO(steveblock): Handle arrays.
   // TODO(steveblock): Handle JavaScript objects.
   DCHECK_EQ(NPVariantType_Object, variant.type);
 
   // The only type of object we should encounter is a Java object, as
   // other objects should have been converted to NULL in the renderer.
   // See CreateNPVariantParam().
   // TODO(steveblock): This will have to change once we support arrays and
   // JavaScript objects.
   NPObject* object = NPVARIANT_TO_OBJECT(variant);
   DCHECK_EQ(&JavaNPObject::kNPClass, object->_class);
 
   jvalue result;
   switch (target_type) {
     case JavaType::TypeObject:
-      // LIVECONNECT_COMPLIANCE: Pass all Java objects to maintain existing
-      // behavior. We should pass only Java objects which are
+      // LIVECONNECT_COMPLIANCE: Existing behavior is to pass all Java objects.
+      // Spec requires passing only Java objects which are
       // assignment-compatibile.
       result.l = AttachCurrentThread()->NewLocalRef(
           JavaBoundObject::GetJavaObject(object));
       break;
     case JavaType::TypeString:
-      // LIVECONNECT_COMPLIANCE: Convert to "undefined" to maintain existing
-      // behavior. We should call toString() on the Java object.
+      // LIVECONNECT_COMPLIANCE: Existing behavior is to convert to
+      // "undefined". Spec requires calling toString() on the Java object.
       result.l = ConvertUTF8ToJavaString(AttachCurrentThread(), "undefined");
       break;
     case JavaType::TypeByte:
     case JavaType::TypeShort:
     case JavaType::TypeInt:
     case JavaType::TypeLong:
     case JavaType::TypeFloat:
     case JavaType::TypeDouble:
     case JavaType::TypeChar: {
-      // LIVECONNECT_COMPLIANCE: Convert to 0 to maintain existing behavior. We
-      // should raise a JavaScript exception.
+      // LIVECONNECT_COMPLIANCE: Existing behavior is to convert to 0. Spec
+      // requires raising a JavaScript exception.
       jvalue null_value = {0};
       result = null_value;
       break;
     }
     case JavaType::TypeBoolean:
-      // LIVECONNECT_COMPLIANCE: Convert to false to maintain existing behavior.
-      // We should raise a JavaScript exception.
+      // LIVECONNECT_COMPLIANCE: Existing behavior is to convert to false. Spec
+      // requires raising a JavaScript exception.
       result.z = JNI_FALSE;
       break;
     case JavaType::TypeArray:
-      // LIVECONNECT_COMPLIANCE: Convert to NULL to maintain existing behavior.
-      // We should raise a JavaScript exception.
+      // LIVECONNECT_COMPLIANCE: Existing behavior is to convert to NULL. Spec
+      // requires raising a JavaScript exception.
       result.l = NULL;
       break;
     case JavaType::TypeVoid:
       // Conversion to void must never happen.
       NOTREACHED();
       break;
   }
   return result;
 }
 
 jvalue CoerceJavaScriptNullOrUndefinedToJavaValue(const NPVariant& variant,
                                                   JavaType::Type target_type) {
   // See http://jdk6.java.net/plugin2/liveconnect/#JS_NULL.
   DCHECK(variant.type == NPVariantType_Null ||
          variant.type == NPVariantType_Void);
   jvalue result;
   switch (target_type) {
     case JavaType::TypeObject:
       result.l = NULL;
       break;
     case JavaType::TypeString:
       if (variant.type == NPVariantType_Void) {
-        // LIVECONNECT_COMPLIANCE: Convert undefined to "undefined" to maintain
-        // existing behavior. We should convert undefined to NULL.
+        // LIVECONNECT_COMPLIANCE: Existing behavior is to convert undefined to
+        // "undefined". Spec requires converting undefined to NULL.
         result.l =  ConvertUTF8ToJavaString(AttachCurrentThread(), "undefined");
       } else {
         result.l = NULL;
       }
       break;
     case JavaType::TypeByte:
     case JavaType::TypeChar:
     case JavaType::TypeShort:
     case JavaType::TypeInt:
     case JavaType::TypeLong:
     case JavaType::TypeFloat:
     case JavaType::TypeDouble: {
       jvalue null_value = {0};
       result = null_value;
       break;
     }
     case JavaType::TypeBoolean:
       result.z = JNI_FALSE;
       break;
     case JavaType::TypeArray:
-      // LIVECONNECT_COMPLIANCE: Convert to NULL to maintain existing behavior.
-      // We should raise a JavaScript exception.
+      // LIVECONNECT_COMPLIANCE: Existing behavior is to convert to NULL. Spec
+      // requires raising a JavaScript exception.
       result.l = NULL;
       break;
     case JavaType::TypeVoid:
       // Conversion to void must never happen.
       NOTREACHED();
       break;
   }
   return result;
 }
 
@@ skipping 141 matching lines @@
   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));
   }
 }