Changeset 82194 in webkit


Ignore:
Timestamp:
Mar 28, 2011 10:41:07 PM (13 years ago)
Author:
steveblock@google.com
Message:

2011-03-28 Steve Block <​steveblock@google.com>

Reviewed by Jeremy Orlow.

Add a new JavaValue to type to represent a Java value in the Java bridge
​https://bugs.webkit.org/show_bug.cgi?id=57022

This change introduces a new JavaValue type and uses it in place of jvalue
in the conversions to and from JavaNPObject used in the V8 Java bridge.

Refactoring only, no new tests.

  • WebCore.gypi:
  • bridge/jni/JNIUtility.cpp: (JSC::Bindings::javaTypeFromClassName): (JSC::Bindings::signatureFromJavaType): (JSC::Bindings::getJNIField): (JSC::Bindings::callJNIMethod):
  • bridge/jni/JavaType.h:
  • bridge/jni/v8/JNIUtilityPrivate.cpp: (JSC::Bindings::convertNPVariantToJavaValue): (JSC::Bindings::convertJavaValueToNPVariant): (JSC::Bindings::jvalueToJavaValue): (JSC::Bindings::javaValueToJvalue):
  • bridge/jni/v8/JNIUtilityPrivate.h:
  • bridge/jni/v8/JavaNPObjectV8.cpp: (JSC::Bindings::JavaNPObjectInvoke): (JSC::Bindings::JavaNPObjectGetProperty):
  • bridge/jni/v8/JavaValueV8.h: Added. (JSC::Bindings::JavaValue::JavaValue):
Location:
trunk/Source/WebCore
Files:
1 added
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r82193 r82194  
     12011-03-28  Steve Block  <steveblock@google.com>
     2
     3        Reviewed by Jeremy Orlow.
     4
     5        Add a new JavaValue to type to represent a Java value in the Java bridge
     6        https://bugs.webkit.org/show_bug.cgi?id=57022
     7
     8        This change introduces a new JavaValue type and uses it in place of jvalue
     9        in the conversions to and from JavaNPObject used in the V8 Java bridge.
     10
     11        Refactoring only, no new tests.
     12
     13        * WebCore.gypi:
     14        * bridge/jni/JNIUtility.cpp:
     15        (JSC::Bindings::javaTypeFromClassName):
     16        (JSC::Bindings::signatureFromJavaType):
     17        (JSC::Bindings::getJNIField):
     18        (JSC::Bindings::callJNIMethod):
     19        * bridge/jni/JavaType.h:
     20        * bridge/jni/v8/JNIUtilityPrivate.cpp:
     21        (JSC::Bindings::convertNPVariantToJavaValue):
     22        (JSC::Bindings::convertJavaValueToNPVariant):
     23        (JSC::Bindings::jvalueToJavaValue):
     24        (JSC::Bindings::javaValueToJvalue):
     25        * bridge/jni/v8/JNIUtilityPrivate.h:
     26        * bridge/jni/v8/JavaNPObjectV8.cpp:
     27        (JSC::Bindings::JavaNPObjectInvoke):
     28        (JSC::Bindings::JavaNPObjectGetProperty):
     29        * bridge/jni/v8/JavaValueV8.h: Added.
     30        (JSC::Bindings::JavaValue::JavaValue):
     31
    1322011-03-28  Patrick Gansterer  <paroga@webkit.org>
    233

  • trunk/Source/WebCore/WebCore.gypi

    r82127 r82194  
    21962196            'bridge/jni/v8/JavaNPObjectV8.h',
    21972197            'bridge/jni/v8/JavaStringV8.h',
     2198            'bridge/jni/v8/JavaValueV8.h',
    21982199            'bridge/jsc/BridgeJSC.cpp',
    21992200            'bridge/npruntime.cpp',

  • trunk/Source/WebCore/bridge/jni/JNIUtility.cpp

    r81860 r82194  
    191191    else if ('[' == name[0])
    192192        type = JavaTypeArray;
     193#if USE(V8)
     194    else if (!strcmp("java.lang.String", name))
     195        type = JavaTypeString;
     196#endif
    193197    else
    194198        type = JavaTypeObject;
    … …  
    207211
    208212    case JavaTypeObject:
     213#if USE(V8)
     214    case JavaTypeString:
     215#endif
    209216        return "L";
    210217
    … …  
    297304                case JavaTypeArray:
    298305                case JavaTypeObject:
     306#if USE(V8)
     307                case JavaTypeString:
     308#endif
    299309                    result.l = env->functions->GetObjectField(env, obj, field);
    300310                    break;
    … …  
    350360        break;
    351361    case JavaTypeObject:
     362#if USE(V8)
     363    case JavaTypeString:
     364#endif
    352365        result.l = callJNIMethodIDA<jobject>(object, methodId, args);
    353366        break;

  • trunk/Source/WebCore/bridge/jni/JavaType.h

    r81860 r82194  
    5353    JavaTypeFloat,
    5454    JavaTypeDouble,
    55     JavaTypeArray
     55    JavaTypeArray,
     56#if USE(V8)
     57    // JavaTypeString is distinct from JavaTypeObject because strings receive
     58    // special handling when we convert to and from JavaScript. When calling
     59    // Java methods, we must create Java String objects for string arguments.
     60    // However, at conversion time we cannot assume that the mechanism used to
     61    // interact with Java is JNI. Instead we use a special JavaTypeString.
     62    // Implementations of JavaInstance which use JNI will create a Java String
     63    // object when converting the JavaValue to a jvalue.
     64    //
     65    // Note that this type is independent of the JavaScript engine, but is
     66    // currently used only with V8.
     67    // See https://bugs.webkit.org/show_bug.cgi?id=57023.
     68    JavaTypeString,
     69#endif
    5670};
    5771

  • trunk/Source/WebCore/bridge/jni/v8/JNIUtilityPrivate.cpp

    r81860 r82194  
    3131#include "JavaInstanceV8.h"
    3232#include "JavaNPObjectV8.h"
     33#include "JavaValueV8.h"
    3334#include <wtf/text/CString.h>
    3435
    … …  
    3738namespace Bindings {
    3839
    39 jvalue convertNPVariantToJValue(NPVariant value, const WTF::String& javaClass)
     40JavaValue convertNPVariantToJavaValue(NPVariant value, const String& javaClass)
    4041{
    4142    CString javaClassName = javaClass.utf8();
    4243    JavaType javaType = javaTypeFromClassName(javaClassName.data());
    43     jvalue result;
     44    JavaValue result;
     45    result.m_type = javaType;
    4446    NPVariantType type = value.type;
    4547
    … …  
    4850    case JavaTypeObject:
    4951        {
    50             result.l = static_cast<jobject>(0);
    51 
    52             // First see if we have a Java instance.
     52            // See if we have a Java instance.
    5353            if (type == NPVariantType_Object) {
    5454                NPObject* objectImp = NPVARIANT_TO_OBJECT(value);
    55                 if (JavaInstance* instance = ExtractJavaInstance(objectImp))
    56                     result.l = instance->javaInstance();
     55                result.m_objectValue = ExtractJavaInstance(objectImp);
    5756            }
    58 
    59             // Now convert value to a string if the target type is a java.lang.string, and we're not
    60             // converting from a Null.
    61             if (!result.l && !strcmp(javaClassName.data(), "java.lang.String")) {
     57        }
     58        break;
     59
     60    case JavaTypeString:
     61        {
    6262#ifdef CONVERT_NULL_TO_EMPTY_STRING
    63                 if (type == NPVariantType_Null) {
    64                     JNIEnv* env = getJNIEnv();
    65                     jchar buf[2];
    66                     jobject javaString = env->functions->NewString(env, buf, 0);
    67                     result.l = javaString;
    68                 } else
     63            if (type == NPVariantType_Null) {
     64                result.m_type = JavaTypeString;
     65                result.m_stringValue = String::fromUTF8("");
     66            } else
    6967#else
    70                 if (type == NPVariantType_String)
     68            if (type == NPVariantType_String)
    7169#endif
    72                 {
    73                     NPString src = NPVARIANT_TO_STRING(value);
    74                     JNIEnv* env = getJNIEnv();
    75                     jobject javaString = env->NewStringUTF(src.UTF8Characters);
    76                     result.l = javaString;
    77                 }
    78             } else if (!result.l)
    79                 memset(&result, 0, sizeof(jvalue)); // Handle it the same as a void case
     70            {
     71                NPString src = NPVARIANT_TO_STRING(value);
     72                result.m_type = JavaTypeString;
     73                result.m_stringValue = String::fromUTF8(src.UTF8Characters);
     74            }
    8075        }
    8176        break;
    … …  
    8479        {
    8580            if (type == NPVariantType_Bool)
    86                 result.z = NPVARIANT_TO_BOOLEAN(value);
    87             else
    88                 memset(&result, 0, sizeof(jvalue)); // as void case
     81                result.m_booleanValue = NPVARIANT_TO_BOOLEAN(value);
    8982        }
    9083        break;
    … …  
    9386        {
    9487            if (type == NPVariantType_Int32)
    95                 result.b = static_cast<jbyte>(NPVARIANT_TO_INT32(value));
    96             else if (type == NPVariantType_Double)
    97                 result.b = static_cast<jbyte>(NPVARIANT_TO_DOUBLE(value));
    98             else
    99                 memset(&result, 0, sizeof(jvalue));
     88                result.m_byteValue = static_cast<signed char>(NPVARIANT_TO_INT32(value));
     89            else if (type == NPVariantType_Double)
     90                result.m_byteValue = static_cast<signed char>(NPVARIANT_TO_DOUBLE(value));
    10091        }
    10192        break;
    … …  
    10495        {
    10596            if (type == NPVariantType_Int32)
    106                 result.c = static_cast<char>(NPVARIANT_TO_INT32(value));
    107             else
    108                 memset(&result, 0, sizeof(jvalue));
     97                result.m_charValue = static_cast<unsigned short>(NPVARIANT_TO_INT32(value));
    10998        }
    11099        break;
    … …  
    113102        {
    114103            if (type == NPVariantType_Int32)
    115                 result.s = static_cast<jshort>(NPVARIANT_TO_INT32(value));
    116             else if (type == NPVariantType_Double)
    117                 result.s = static_cast<jshort>(NPVARIANT_TO_DOUBLE(value));
    118             else
    119                 memset(&result, 0, sizeof(jvalue));
     104                result.m_shortValue = static_cast<short>(NPVARIANT_TO_INT32(value));
     105            else if (type == NPVariantType_Double)
     106                result.m_shortValue = static_cast<short>(NPVARIANT_TO_DOUBLE(value));
    120107        }
    121108        break;
    … …  
    124111        {
    125112            if (type == NPVariantType_Int32)
    126                 result.i = static_cast<jint>(NPVARIANT_TO_INT32(value));
    127             else if (type == NPVariantType_Double)
    128                 result.i = static_cast<jint>(NPVARIANT_TO_DOUBLE(value));
    129             else
    130                 memset(&result, 0, sizeof(jvalue));
     113                result.m_intValue = static_cast<int>(NPVARIANT_TO_INT32(value));
     114            else if (type == NPVariantType_Double)
     115                result.m_intValue = static_cast<int>(NPVARIANT_TO_DOUBLE(value));
    131116        }
    132117        break;
    … …  
    135120        {
    136121            if (type == NPVariantType_Int32)
    137                 result.j = static_cast<jlong>(NPVARIANT_TO_INT32(value));
    138             else if (type == NPVariantType_Double)
    139                 result.j = static_cast<jlong>(NPVARIANT_TO_DOUBLE(value));
    140             else
    141                 memset(&result, 0, sizeof(jvalue));
     122                result.m_longValue = static_cast<long long>(NPVARIANT_TO_INT32(value));
     123            else if (type == NPVariantType_Double)
     124                result.m_longValue = static_cast<long long>(NPVARIANT_TO_DOUBLE(value));
    142125        }
    143126        break;
    … …  
    146129        {
    147130            if (type == NPVariantType_Int32)
    148                 result.f = static_cast<jfloat>(NPVARIANT_TO_INT32(value));
    149             else if (type == NPVariantType_Double)
    150                 result.f = static_cast<jfloat>(NPVARIANT_TO_DOUBLE(value));
    151             else
    152                 memset(&result, 0, sizeof(jvalue));
     131                result.m_floatValue = static_cast<float>(NPVARIANT_TO_INT32(value));
     132            else if (type == NPVariantType_Double)
     133                result.m_floatValue = static_cast<float>(NPVARIANT_TO_DOUBLE(value));
    153134        }
    154135        break;
    … …  
    157138        {
    158139            if (type == NPVariantType_Int32)
    159                 result.d = static_cast<jdouble>(NPVARIANT_TO_INT32(value));
    160             else if (type == NPVariantType_Double)
    161                 result.d = static_cast<jdouble>(NPVARIANT_TO_DOUBLE(value));
    162             else
    163                 memset(&result, 0, sizeof(jvalue));
    164         }
    165         break;
    166 
    167         break;
    168 
    169     case JavaTypeInvalid:
     140                result.m_doubleValue = static_cast<double>(NPVARIANT_TO_INT32(value));
     141            else if (type == NPVariantType_Double)
     142                result.m_doubleValue = static_cast<double>(NPVARIANT_TO_DOUBLE(value));
     143        }
     144        break;
    170145    default:
    171     case JavaTypeVoid:
    172         {
    173             memset(&result, 0, sizeof(jvalue));
    174         }
    175146        break;
    176147    }
    … …  
    179150
    180151
    181 void convertJValueToNPVariant(jvalue value, JavaType javaType, const char* javaTypeName, NPVariant* result)
     152void convertJavaValueToNPVariant(JavaValue value, NPVariant* result)
    182153{
    183     switch (javaType) {
     154    switch (value.m_type) {
    184155    case JavaTypeVoid:
    185156        {
    … …  
    190161    case JavaTypeObject:
    191162        {
    192             if (value.l) {
    193                 if (!strcmp(javaTypeName, "java.lang.String")) {
    194                     const char* v = getCharactersFromJString(static_cast<jstring>(value.l));
    195                     // s is freed in NPN_ReleaseVariantValue (see npruntime.cpp)
    196                     const char* s = strdup(v);
    197                     releaseCharactersForJString(static_cast<jstring>(value.l), v);
    198                     STRINGZ_TO_NPVARIANT(s, *result);
    199                 } else
    200                     OBJECT_TO_NPVARIANT(JavaInstanceToNPObject(new JavaInstance(value.l)), *result);
    201             } else
     163            // If the JavaValue is a String object, it should have type JavaTypeString.
     164            if (value.m_objectValue)
     165                OBJECT_TO_NPVARIANT(JavaInstanceToNPObject(value.m_objectValue.get()), *result);
     166            else
    202167                VOID_TO_NPVARIANT(*result);
    203168        }
    204169        break;
    205170
     171    case JavaTypeString:
     172        {
     173            const char* utf8String = strdup(value.m_stringValue.utf8().data());
     174            // The copied string is freed in NPN_ReleaseVariantValue (see npruntime.cpp)
     175            STRINGZ_TO_NPVARIANT(utf8String, *result);
     176        }
     177        break;
     178
    206179    case JavaTypeBoolean:
    207180        {
    208             BOOLEAN_TO_NPVARIANT(value.z, *result);
     181            BOOLEAN_TO_NPVARIANT(value.m_booleanValue, *result);
    209182        }
    210183        break;
    … …  
    212185    case JavaTypeByte:
    213186        {
    214             INT32_TO_NPVARIANT(value.b, *result);
     187            INT32_TO_NPVARIANT(value.m_byteValue, *result);
    215188        }
    216189        break;
    … …  
    218191    case JavaTypeChar:
    219192        {
    220             INT32_TO_NPVARIANT(value.c, *result);
     193            INT32_TO_NPVARIANT(value.m_charValue, *result);
    221194        }
    222195        break;
    … …  
    224197    case JavaTypeShort:
    225198        {
    226             INT32_TO_NPVARIANT(value.s, *result);
     199            INT32_TO_NPVARIANT(value.m_shortValue, *result);
    227200        }
    228201        break;
    … …  
    230203    case JavaTypeInt:
    231204        {
    232             INT32_TO_NPVARIANT(value.i, *result);
     205            INT32_TO_NPVARIANT(value.m_intValue, *result);
    233206        }
    234207        break;
    … …  
    237210    case JavaTypeLong:
    238211        {
    239             DOUBLE_TO_NPVARIANT(value.j, *result);
     212            DOUBLE_TO_NPVARIANT(value.m_longValue, *result);
    240213        }
    241214        break;
    … …  
    243216    case JavaTypeFloat:
    244217        {
    245             DOUBLE_TO_NPVARIANT(value.f, *result);
     218            DOUBLE_TO_NPVARIANT(value.m_floatValue, *result);
    246219        }
    247220        break;
    … …  
    249222    case JavaTypeDouble:
    250223        {
    251             DOUBLE_TO_NPVARIANT(value.d, *result);
     224            DOUBLE_TO_NPVARIANT(value.m_doubleValue, *result);
    252225        }
    253226        break;
    … …  
    262235}
    263236
     237JavaValue jvalueToJavaValue(const jvalue& value, const JavaType& type)
     238{
     239    JavaValue result;
     240    result.m_type = type;
     241    switch (result.m_type) {
     242    case JavaTypeVoid:
     243        break;
     244    case JavaTypeObject:
     245        result.m_objectValue = new JavaInstance(value.l);
     246        break;
     247    case JavaTypeString:
     248        {
     249            jstring javaString = static_cast<jstring>(value.l);
     250            const UChar* a = getUCharactersFromJStringInEnv(getJNIEnv(), javaString);
     251            // We take a copy to allow the Java String to be released.
     252            result.m_stringValue = String(a).threadsafeCopy();
     253            releaseUCharactersForJStringInEnv(getJNIEnv(), javaString, a);
     254        }
     255        break;
     256    case JavaTypeBoolean:
     257        result.m_booleanValue = value.z == JNI_FALSE ? false : true;
     258        break;
     259    case JavaTypeByte:
     260        result.m_byteValue = value.b;
     261        break;
     262    case JavaTypeChar:
     263        result.m_charValue = value.c;
     264        break;
     265    case JavaTypeShort:
     266        result.m_shortValue = value.s;
     267        break;
     268    case JavaTypeInt:
     269        result.m_intValue = value.i;
     270        break;
     271    case JavaTypeLong:
     272        result.m_longValue = value.j;
     273        break;
     274    case JavaTypeFloat:
     275        result.m_floatValue = value.f;
     276        break;
     277    case JavaTypeDouble:
     278        result.m_doubleValue = value.d;
     279        break;
     280    default:
     281        ASSERT(false);
     282    }
     283    return result;
     284}
     285
     286jvalue javaValueToJvalue(const JavaValue& value)
     287{
     288    jvalue result;
     289    memset(&result, 0, sizeof(jvalue));
     290    switch (value.m_type) {
     291    case JavaTypeVoid:
     292        break;
     293    case JavaTypeObject:
     294        if (value.m_objectValue)
     295            result.l = value.m_objectValue->javaInstance();
     296        break;
     297    case JavaTypeString:
     298        // This creates a local reference to a new String object, which will
     299        // be released when the call stack returns to Java. Note that this
     300        // may cause leaks if invoked from a native message loop, as is the
     301        // case in workers.
     302        result.l = getJNIEnv()->NewString(value.m_stringValue.characters(), value.m_stringValue.length());
     303        break;
     304    case JavaTypeBoolean:
     305        result.z = value.m_booleanValue ? JNI_TRUE : JNI_FALSE;
     306        break;
     307    case JavaTypeByte:
     308        result.b = value.m_byteValue;
     309        break;
     310    case JavaTypeChar:
     311        result.c = value.m_charValue;
     312        break;
     313    case JavaTypeShort:
     314        result.s = value.m_shortValue;
     315        break;
     316    case JavaTypeInt:
     317        result.i = value.m_intValue;
     318        break;
     319    case JavaTypeLong:
     320        result.j = value.m_longValue;
     321        break;
     322    case JavaTypeFloat:
     323        result.f = value.m_floatValue;
     324        break;
     325    case JavaTypeDouble:
     326        result.d = value.m_doubleValue;
     327        break;
     328    default:
     329        ASSERT(false);
     330    }
     331    return result;
     332}
     333
    264334} // namespace Bindings
    265335

  • trunk/Source/WebCore/bridge/jni/v8/JNIUtilityPrivate.h

    r81860 r82194  
    3737namespace Bindings {
    3838
    39 jvalue convertNPVariantToJValue(NPVariant, const WTF::String& javaClass);
    40 void convertJValueToNPVariant(jvalue, JavaType, const char* javaClassName, NPVariant*);
     39class JavaValue;
     40
     41JavaValue convertNPVariantToJavaValue(NPVariant, const String& javaClass);
     42void convertJavaValueToNPVariant(JavaValue, NPVariant*);
     43
     44JavaValue jvalueToJavaValue(const jvalue&, const JavaType&);
     45jvalue javaValueToJvalue(const JavaValue&);
    4146
    4247} // namespace Bindings

  • trunk/Source/WebCore/bridge/jni/v8/JavaNPObjectV8.cpp

    r81860 r82194  
    3535#include "JavaInstanceV8.h"
    3636#include "JavaMethod.h"
     37#include "JavaValueV8.h"
    3738#include "npruntime_impl.h"
    3839
    … …  
    145146
    146147    for (unsigned int i = 0; i < argCount; i++)
    147         jArgs[i] = convertNPVariantToJValue(args[i], jMethod->parameterAt(i));
     148        jArgs[i] = javaValueToJvalue(convertNPVariantToJavaValue(args[i], jMethod->parameterAt(i)));
    148149
    149150    jvalue jResult = instance->invokeMethod(jMethod, jArgs);
    … …  
    152153
    153154    VOID_TO_NPVARIANT(*result);
    154     convertJValueToNPVariant(jResult, jMethod->returnType(), jMethod->returnTypeClassName(), result);
     155    convertJavaValueToNPVariant(jvalueToJavaValue(jResult, jMethod->returnType()), result);
    155156    return true;
    156157}
    … …  
    190191    instance->end();
    191192
    192     convertJValueToNPVariant(value, field->type(), field->typeClassName(), result);
     193    convertJavaValueToNPVariant(jvalueToJavaValue(value, field->type()), result);
    193194
    194195    return true;
Note: See TracChangeset for help on using the changeset viewer.