diff options
Diffstat (limited to 'Source/WebCore/bridge')
40 files changed, 784 insertions, 525 deletions
diff --git a/Source/WebCore/bridge/c/CRuntimeObject.h b/Source/WebCore/bridge/c/CRuntimeObject.h index 267d71e..85815fb 100644 --- a/Source/WebCore/bridge/c/CRuntimeObject.h +++ b/Source/WebCore/bridge/c/CRuntimeObject.h @@ -44,9 +44,9 @@ public: static const ClassInfo s_info; - static PassRefPtr<Structure> createStructure(JSValue prototype) + static PassRefPtr<Structure> createStructure(JSGlobalData& globalData, JSValue prototype) { - return Structure::create(prototype, TypeInfo(ObjectType, StructureFlags), AnonymousSlotCount, &s_info); + return Structure::create(globalData, prototype, TypeInfo(ObjectType, StructureFlags), AnonymousSlotCount, &s_info); } }; diff --git a/Source/WebCore/bridge/c/c_class.cpp b/Source/WebCore/bridge/c/c_class.cpp index a808946..4f9cdd9 100644 --- a/Source/WebCore/bridge/c/c_class.cpp +++ b/Source/WebCore/bridge/c/c_class.cpp @@ -35,6 +35,7 @@ #include <runtime/ScopeChain.h> #include <runtime/Identifier.h> #include <runtime/JSLock.h> +#include <runtime/JSObject.h> #include <wtf/text/StringHash.h> namespace JSC { namespace Bindings { diff --git a/Source/WebCore/bridge/c/c_instance.cpp b/Source/WebCore/bridge/c/c_instance.cpp index 27affeb..21fae4f 100644 --- a/Source/WebCore/bridge/c/c_instance.cpp +++ b/Source/WebCore/bridge/c/c_instance.cpp @@ -120,9 +120,9 @@ public: ASSERT(inherits(&s_info)); } - static PassRefPtr<Structure> createStructure(JSValue prototype) + static PassRefPtr<Structure> createStructure(JSGlobalData& globalData, JSValue prototype) { - return Structure::create(prototype, TypeInfo(ObjectType, StructureFlags), AnonymousSlotCount, &s_info); + return Structure::create(globalData, prototype, TypeInfo(ObjectType, StructureFlags), AnonymousSlotCount, &s_info); } static const ClassInfo s_info; diff --git a/Source/WebCore/bridge/c/c_runtime.cpp b/Source/WebCore/bridge/c/c_runtime.cpp index f8c0dba..a84acbb 100644 --- a/Source/WebCore/bridge/c/c_runtime.cpp +++ b/Source/WebCore/bridge/c/c_runtime.cpp @@ -34,6 +34,7 @@ #include "npruntime_impl.h" #include <runtime/ScopeChain.h> #include <runtime/JSLock.h> +#include <runtime/JSObject.h> namespace JSC { namespace Bindings { diff --git a/Source/WebCore/bridge/jni/JNIUtility.cpp b/Source/WebCore/bridge/jni/JNIUtility.cpp index 17cc038..cfd4e83 100644 --- a/Source/WebCore/bridge/jni/JNIUtility.cpp +++ b/Source/WebCore/bridge/jni/JNIUtility.cpp @@ -166,122 +166,129 @@ void releaseUCharactersForJStringInEnv(JNIEnv* env, jstring aJString, const jcha env->ReleaseStringChars(aJString, s); } -JNIType JNITypeFromClassName(const char* name) +JavaType javaTypeFromClassName(const char* name) { - JNIType type; + JavaType type; if (!strcmp("byte", name)) - type = byte_type; + type = JavaTypeByte; else if (!strcmp("short", name)) - type = short_type; + type = JavaTypeShort; else if (!strcmp("int", name)) - type = int_type; + type = JavaTypeInt; else if (!strcmp("long", name)) - type = long_type; + type = JavaTypeLong; else if (!strcmp("float", name)) - type = float_type; + type = JavaTypeFloat; else if (!strcmp("double", name)) - type = double_type; + type = JavaTypeDouble; else if (!strcmp("char", name)) - type = char_type; + type = JavaTypeChar; else if (!strcmp("boolean", name)) - type = boolean_type; + type = JavaTypeBoolean; else if (!strcmp("void", name)) - type = void_type; + type = JavaTypeVoid; else if ('[' == name[0]) - type = array_type; + type = JavaTypeArray; +#if USE(V8) + else if (!strcmp("java.lang.String", name)) + type = JavaTypeString; +#endif else - type = object_type; + type = JavaTypeObject; return type; } -const char* signatureFromPrimitiveType(JNIType type) +const char* signatureFromJavaType(JavaType type) { switch (type) { - case void_type: + case JavaTypeVoid: return "V"; - case array_type: + case JavaTypeArray: return "["; - case object_type: + case JavaTypeObject: +#if USE(V8) + case JavaTypeString: +#endif return "L"; - case boolean_type: + case JavaTypeBoolean: return "Z"; - case byte_type: + case JavaTypeByte: return "B"; - case char_type: + case JavaTypeChar: return "C"; - case short_type: + case JavaTypeShort: return "S"; - case int_type: + case JavaTypeInt: return "I"; - case long_type: + case JavaTypeLong: return "J"; - case float_type: + case JavaTypeFloat: return "F"; - case double_type: + case JavaTypeDouble: return "D"; - case invalid_type: + case JavaTypeInvalid: default: break; } return ""; } -JNIType JNITypeFromPrimitiveType(char type) +JavaType javaTypeFromPrimitiveType(char type) { switch (type) { case 'V': - return void_type; + return JavaTypeVoid; case 'L': - return object_type; + return JavaTypeObject; case '[': - return array_type; + return JavaTypeArray; case 'Z': - return boolean_type; + return JavaTypeBoolean; case 'B': - return byte_type; + return JavaTypeByte; case 'C': - return char_type; + return JavaTypeChar; case 'S': - return short_type; + return JavaTypeShort; case 'I': - return int_type; + return JavaTypeInt; case 'J': - return long_type; + return JavaTypeLong; case 'F': - return float_type; + return JavaTypeFloat; case 'D': - return double_type; + return JavaTypeDouble; default: break; } - return invalid_type; + return JavaTypeInvalid; } -jvalue getJNIField(jobject obj, JNIType type, const char* name, const char* signature) +jvalue getJNIField(jobject obj, JavaType type, const char* name, const char* signature) { JavaVM* jvm = getJavaVM(); JNIEnv* env = getJNIEnv(); @@ -294,32 +301,35 @@ jvalue getJNIField(jobject obj, JNIType type, const char* name, const char* sign jfieldID field = env->GetFieldID(cls, name, signature); if (field) { switch (type) { - case array_type: - case object_type: + case JavaTypeArray: + case JavaTypeObject: +#if USE(V8) + case JavaTypeString: +#endif result.l = env->functions->GetObjectField(env, obj, field); break; - case boolean_type: + case JavaTypeBoolean: result.z = env->functions->GetBooleanField(env, obj, field); break; - case byte_type: + case JavaTypeByte: result.b = env->functions->GetByteField(env, obj, field); break; - case char_type: + case JavaTypeChar: result.c = env->functions->GetCharField(env, obj, field); break; - case short_type: + case JavaTypeShort: result.s = env->functions->GetShortField(env, obj, field); break; - case int_type: + case JavaTypeInt: result.i = env->functions->GetIntField(env, obj, field); break; - case long_type: + case JavaTypeLong: result.j = env->functions->GetLongField(env, obj, field); break; - case float_type: + case JavaTypeFloat: result.f = env->functions->GetFloatField(env, obj, field); break; - case double_type: + case JavaTypeDouble: result.d = env->functions->GetDoubleField(env, obj, field); break; default: @@ -340,6 +350,50 @@ jvalue getJNIField(jobject obj, JNIType type, const char* name, const char* sign return result; } +jvalue callJNIMethod(jobject object, JavaType returnType, const char* name, const char* signature, jvalue* args) +{ + jmethodID methodId = getMethodID(object, name, signature); + jvalue result; + switch (returnType) { + case JavaTypeVoid: + callJNIMethodIDA<void>(object, methodId, args); + break; + case JavaTypeObject: +#if USE(V8) + case JavaTypeString: +#endif + result.l = callJNIMethodIDA<jobject>(object, methodId, args); + break; + case JavaTypeBoolean: + result.z = callJNIMethodIDA<jboolean>(object, methodId, args); + break; + case JavaTypeByte: + result.b = callJNIMethodIDA<jbyte>(object, methodId, args); + break; + case JavaTypeChar: + result.c = callJNIMethodIDA<jchar>(object, methodId, args); + break; + case JavaTypeShort: + result.s = callJNIMethodIDA<jshort>(object, methodId, args); + break; + case JavaTypeInt: + result.i = callJNIMethodIDA<jint>(object, methodId, args); + break; + case JavaTypeLong: + result.j = callJNIMethodIDA<jlong>(object, methodId, args); + break; + case JavaTypeFloat: + result.f = callJNIMethodIDA<jfloat>(object, methodId, args); + break; + case JavaTypeDouble: + result.d = callJNIMethodIDA<jdouble>(object, methodId, args); + break; + default: + break; + } + return result; +} + } // namespace Bindings } // namespace JSC diff --git a/Source/WebCore/bridge/jni/JNIUtility.h b/Source/WebCore/bridge/jni/JNIUtility.h index 7b5d37c..508a2e5 100644 --- a/Source/WebCore/bridge/jni/JNIUtility.h +++ b/Source/WebCore/bridge/jni/JNIUtility.h @@ -28,36 +28,14 @@ #if ENABLE(JAVA_BRIDGE) +#include "JavaType.h" + #if OS(MAC_OS_X) #include <JavaVM/jni.h> #else #include <jni.h> #endif -// The order of these items can not be modified as they are tightly -// bound with the JVM on Mac OSX. If new types need to be added, they -// should be added to the end. It is used in jni_obc.mm when calling -// through to the JVM. Newly added items need to be made compatible -// in that file. -// -// TODO: Strictly, these are not JNI types but simply Java types. The type -// conversion logic used here needs improving and this enum will likely be -// changed at that time. See https://bugs.webkit.org/show_bug.cgi?id=38745 -typedef enum { - invalid_type = 0, - void_type, - object_type, - boolean_type, - byte_type, - char_type, - short_type, - int_type, - long_type, - float_type, - double_type, - array_type -} JNIType; - namespace JSC { namespace Bindings { @@ -70,11 +48,12 @@ void releaseCharactersForJStringInEnv(JNIEnv*, jstring, const char*); const jchar* getUCharactersFromJStringInEnv(JNIEnv*, jstring); void releaseUCharactersForJStringInEnv(JNIEnv*, jstring, const jchar*); -JNIType JNITypeFromClassName(const char* name); -JNIType JNITypeFromPrimitiveType(char type); -const char* signatureFromPrimitiveType(JNIType); +JavaType javaTypeFromClassName(const char* name); +JavaType javaTypeFromPrimitiveType(char type); +const char* signatureFromJavaType(JavaType); -jvalue getJNIField(jobject, JNIType, const char* name, const char* signature); +jvalue getJNIField(jobject, JavaType, const char* name, const char* signature); +jvalue callJNIMethod(jobject, JavaType returnType, const char* name, const char* signature, jvalue* args); jmethodID getMethodID(jobject, const char* name, const char* sig); JNIEnv* getJNIEnv(); diff --git a/Source/WebCore/bridge/jni/JavaMethod.h b/Source/WebCore/bridge/jni/JavaMethod.h index 39d04c9..f15b653 100644 --- a/Source/WebCore/bridge/jni/JavaMethod.h +++ b/Source/WebCore/bridge/jni/JavaMethod.h @@ -30,9 +30,9 @@ #if ENABLE(JAVA_BRIDGE) #include "Bridge.h" -#include "JNIUtility.h" +#include "JavaType.h" -#include "JavaString.h" +#include <wtf/text/WTFString.h> namespace JSC { @@ -42,29 +42,12 @@ typedef const char* RuntimeType; class JavaMethod : public Method { public: - JavaMethod(JNIEnv*, jobject aMethod); - ~JavaMethod(); - - const JavaString& name() const { return m_name; } - RuntimeType returnType() const { return m_returnType.utf8(); } - const WTF::String& parameterAt(int i) const { return m_parameters[i]; } - int numParameters() const { return m_parameters.size(); } - - const char* signature() const; - JNIType JNIReturnType() const; - - jmethodID methodID(jobject obj) const; - - bool isStatic() const { return m_isStatic; } - -private: - Vector<WTF::String> m_parameters; - JavaString m_name; - mutable char* m_signature; - JavaString m_returnType; - JNIType m_JNIReturnType; - mutable jmethodID m_methodID; - bool m_isStatic; + virtual String name() const = 0; + virtual RuntimeType returnTypeClassName() const = 0; + virtual String parameterAt(int) const = 0; + virtual const char* signature() const = 0; + virtual JavaType returnType() const = 0; + virtual bool isStatic() const = 0; }; } // namespace Bindings diff --git a/Source/WebCore/bridge/jni/JavaMethod.cpp b/Source/WebCore/bridge/jni/JavaMethodJobject.cpp index 60620a0..2f2802c 100644 --- a/Source/WebCore/bridge/jni/JavaMethod.cpp +++ b/Source/WebCore/bridge/jni/JavaMethodJobject.cpp @@ -25,7 +25,7 @@ */ #include "config.h" -#include "JavaMethod.h" +#include "JavaMethodJobject.h" #if ENABLE(JAVA_BRIDGE) @@ -40,7 +40,7 @@ using namespace JSC; using namespace JSC::Bindings; -JavaMethod::JavaMethod(JNIEnv* env, jobject aMethod) +JavaMethodJobject::JavaMethodJobject(JNIEnv* env, jobject aMethod) { // Get return type name jstring returnTypeName = 0; @@ -50,14 +50,14 @@ JavaMethod::JavaMethod(JNIEnv* env, jobject aMethod) returnTypeName = env->NewStringUTF("<Unknown>"); env->DeleteLocalRef(returnType); } - m_returnType = JavaString(env, returnTypeName); - m_JNIReturnType = JNITypeFromClassName(m_returnType.utf8()); + m_returnTypeClassName = JavaString(env, returnTypeName); + m_returnType = javaTypeFromClassName(m_returnTypeClassName.utf8()); env->DeleteLocalRef(returnTypeName); // Get method name jstring methodName = static_cast<jstring>(callJNIMethod<jobject>(aMethod, "getName", "()Ljava/lang/String;")); - if (!returnTypeName) - returnTypeName = env->NewStringUTF("<Unknown>"); + if (!methodName) + methodName = env->NewStringUTF("<Unknown>"); m_name = JavaString(env, methodName); env->DeleteLocalRef(methodName); @@ -79,7 +79,6 @@ JavaMethod::JavaMethod(JNIEnv* env, jobject aMethod) // Created lazily. m_signature = 0; - m_methodID = 0; jclass modifierClass = env->FindClass("java/lang/reflect/Modifier"); int modifiers = callJNIMethod<jint>(aMethod, "getModifiers", "()I"); @@ -87,7 +86,7 @@ JavaMethod::JavaMethod(JNIEnv* env, jobject aMethod) env->DeleteLocalRef(modifierClass); } -JavaMethod::~JavaMethod() +JavaMethodJobject::~JavaMethodJobject() { if (m_signature) fastFree(m_signature); @@ -115,7 +114,7 @@ static void appendClassName(StringBuilder& builder, const char* className) fastFree(result); } -const char* JavaMethod::signature() const +const char* JavaMethodJobject::signature() const { if (!m_signature) { #if USE(JSC) @@ -126,12 +125,12 @@ const char* JavaMethod::signature() const signatureBuilder.append('('); for (unsigned int i = 0; i < m_parameters.size(); i++) { CString javaClassName = parameterAt(i).utf8(); - JNIType type = JNITypeFromClassName(javaClassName.data()); - if (type == array_type) + JavaType type = javaTypeFromClassName(javaClassName.data()); + if (type == JavaTypeArray) appendClassName(signatureBuilder, javaClassName.data()); else { - signatureBuilder.append(signatureFromPrimitiveType(type)); - if (type == object_type) { + signatureBuilder.append(signatureFromJavaType(type)); + if (type == JavaTypeObject) { appendClassName(signatureBuilder, javaClassName.data()); signatureBuilder.append(';'); } @@ -139,12 +138,12 @@ const char* JavaMethod::signature() const } signatureBuilder.append(')'); - const char* returnType = m_returnType.utf8(); - if (m_JNIReturnType == array_type) + const char* returnType = m_returnTypeClassName.utf8(); + if (m_returnType == JavaTypeArray) appendClassName(signatureBuilder, returnType); else { - signatureBuilder.append(signatureFromPrimitiveType(m_JNIReturnType)); - if (m_JNIReturnType == object_type) { + signatureBuilder.append(signatureFromJavaType(m_returnType)); + if (m_returnType == JavaTypeObject) { appendClassName(signatureBuilder, returnType); signatureBuilder.append(';'); } @@ -157,16 +156,4 @@ const char* JavaMethod::signature() const return m_signature; } -JNIType JavaMethod::JNIReturnType() const -{ - return m_JNIReturnType; -} - -jmethodID JavaMethod::methodID(jobject obj) const -{ - if (!m_methodID) - m_methodID = getMethodID(obj, m_name.utf8(), signature()); - return m_methodID; -} - #endif // ENABLE(JAVA_BRIDGE) diff --git a/Source/WebCore/bridge/jni/JavaMethodJobject.h b/Source/WebCore/bridge/jni/JavaMethodJobject.h new file mode 100644 index 0000000..d9482ba --- /dev/null +++ b/Source/WebCore/bridge/jni/JavaMethodJobject.h @@ -0,0 +1,72 @@ +/* + * Copyright (C) 2003, 2004, 2005, 2007, 2009, 2010 Apple Inc. All rights reserved. + * Copyright 2010, The Android Open Source Project + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef JavaMethodJobject_h +#define JavaMethodJobject_h + +#if ENABLE(JAVA_BRIDGE) + +#include "JavaMethod.h" +#include "JavaString.h" + +#include <wtf/text/CString.h> + +namespace JSC { + +namespace Bindings { + +class JavaMethodJobject : public JavaMethod { +public: + JavaMethodJobject(JNIEnv*, jobject); + virtual ~JavaMethodJobject(); + + // JavaMethod implementation + virtual String name() const { return m_name.impl(); } + virtual RuntimeType returnTypeClassName() const { return m_returnTypeClassName.utf8(); } + virtual String parameterAt(int i) const { return m_parameters[i]; } + virtual const char* signature() const; + virtual JavaType returnType() const { return m_returnType; } + virtual bool isStatic() const { return m_isStatic; } + + // Method implementation + virtual int numParameters() const { return m_parameters.size(); } + +private: + Vector<String> m_parameters; + JavaString m_name; + mutable char* m_signature; + JavaString m_returnTypeClassName; + JavaType m_returnType; + bool m_isStatic; +}; + +} // namespace Bindings + +} // namespace JSC + +#endif // ENABLE(JAVA_BRIDGE) + +#endif // JavaMethodJobject_h diff --git a/Source/WebCore/bridge/jni/JavaType.h b/Source/WebCore/bridge/jni/JavaType.h new file mode 100644 index 0000000..17053fb --- /dev/null +++ b/Source/WebCore/bridge/jni/JavaType.h @@ -0,0 +1,78 @@ +/* + * Copyright (C) 2003, 2004, 2005, 2008, 2009, 2010 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef JavaType_h +#define JavaType_h + +#if ENABLE(JAVA_BRIDGE) + +namespace JSC { + +namespace Bindings { + +// The order of these items can not be modified as they are tightly +// bound with the JVM on Mac OSX. If new types need to be added, they +// should be added to the end. It is used in jni_obc.mm when calling +// through to the JVM. Newly added items need to be made compatible +// in that file. +// +// The type conversion logic used here needs improving and this enum will likely +// be changed at that time. See https://bugs.webkit.org/show_bug.cgi?id=38745 +enum JavaType { + JavaTypeInvalid = 0, + JavaTypeVoid, + JavaTypeObject, + JavaTypeBoolean, + JavaTypeByte, + JavaTypeChar, + JavaTypeShort, + JavaTypeInt, + JavaTypeLong, + JavaTypeFloat, + JavaTypeDouble, + JavaTypeArray, +#if USE(V8) + // JavaTypeString is distinct from JavaTypeObject because strings receive + // special handling when we convert to and from JavaScript. When calling + // Java methods, we must create Java String objects for string arguments. + // However, at conversion time we cannot assume that the mechanism used to + // interact with Java is JNI. Instead we use a special JavaTypeString. + // Implementations of JavaInstance which use JNI will create a Java String + // object when converting the JavaValue to a jvalue. + // + // Note that this type is independent of the JavaScript engine, but is + // currently used only with V8. + // See https://bugs.webkit.org/show_bug.cgi?id=57023. + JavaTypeString, +#endif +}; + +} // namespace Bindings + +} // namespace JSC + +#endif // ENABLE(JAVA_BRIDGE) + +#endif // JavaType_h diff --git a/Source/WebCore/bridge/jni/jni_jsobject.mm b/Source/WebCore/bridge/jni/jni_jsobject.mm index 172559e..03b8fc2 100644 --- a/Source/WebCore/bridge/jni/jni_jsobject.mm +++ b/Source/WebCore/bridge/jni/jni_jsobject.mm @@ -419,7 +419,7 @@ jstring JavaJSObject::toString() const JSObject *thisObj = const_cast<JSObject*>(_imp); ExecState* exec = rootObject->globalObject()->globalExec(); - return static_cast<jstring>(convertValueToJValue(exec, rootObject, thisObj, object_type, "java.lang.String").l); + return static_cast<jstring>(convertValueToJValue(exec, rootObject, thisObj, JavaTypeObject, "java.lang.String").l); } void JavaJSObject::finalize() const diff --git a/Source/WebCore/bridge/jni/jni_objc.mm b/Source/WebCore/bridge/jni/jni_objc.mm index 8fa2c3f..9c943e8 100644 --- a/Source/WebCore/bridge/jni/jni_objc.mm +++ b/Source/WebCore/bridge/jni/jni_objc.mm @@ -28,31 +28,31 @@ #if ENABLE(JAVA_BRIDGE) #import <Foundation/Foundation.h> -#import "JNIUtility.h" #import "JNIUtilityPrivate.h" +#import "JavaType.h" #import "objc_utility.h" #include <runtime/JSLock.h> using namespace JSC::Bindings; @interface NSObject (WebScriptingPrivate) -- (jvalue)webPlugInCallJava:(jobject)object method:(jmethodID)method returnType:(JNIType)returnType arguments:(jvalue*)args; +- (jvalue)webPlugInCallJava:(jobject)object method:(jmethodID)method returnType:(JavaType)returnType arguments:(jvalue*)args; - (jvalue)webPlugInCallJava:(jobject)object isStatic:(BOOL)isStatic - returnType:(JNIType)returnType + returnType:(JavaType)returnType method:(jmethodID)method arguments:(jvalue*)args callingURL:(NSURL *)url exceptionDescription:(NSString **)exceptionString; @end -bool JSC::Bindings::dispatchJNICall(ExecState* exec, const void* targetAppletView, jobject obj, bool isStatic, JNIType returnType, jmethodID methodID, jvalue* args, jvalue &result, const char*, JSValue& exceptionDescription) +bool JSC::Bindings::dispatchJNICall(ExecState* exec, const void* targetAppletView, jobject obj, bool isStatic, JavaType returnType, jmethodID methodID, jvalue* args, jvalue &result, const char*, JSValue& exceptionDescription) { id view = (id)targetAppletView; - // As array_type is not known by the Mac JVM, change it to a compatible type. - if (returnType == array_type) - returnType = object_type; + // As JavaTypeArray is not known by the Mac JVM, change it to a compatible type. + if (returnType == JavaTypeArray) + returnType = JavaTypeObject; if ([view respondsToSelector:@selector(webPlugInCallJava:isStatic:returnType:method:arguments:callingURL:exceptionDescription:)]) { NSString *_exceptionDescription = 0; diff --git a/Source/WebCore/bridge/jni/jsc/JNIUtilityPrivate.cpp b/Source/WebCore/bridge/jni/jsc/JNIUtilityPrivate.cpp index a8be0bd..2356fe1 100644 --- a/Source/WebCore/bridge/jni/jsc/JNIUtilityPrivate.cpp +++ b/Source/WebCore/bridge/jni/jsc/JNIUtilityPrivate.cpp @@ -53,8 +53,8 @@ static jobject convertArrayInstanceToJavaArray(ExecState* exec, JSArray* jsArray jobjectArray jarray = 0; // Build the correct array type - switch (JNITypeFromPrimitiveType(javaClassName[1])) { - case object_type: + switch (javaTypeFromPrimitiveType(javaClassName[1])) { + case JavaTypeObject: { // Only support string object types if (!strcmp("[Ljava.lang.String;", javaClassName)) { @@ -71,7 +71,7 @@ static jobject convertArrayInstanceToJavaArray(ExecState* exec, JSArray* jsArray break; } - case boolean_type: + case JavaTypeBoolean: { jarray = (jobjectArray)env->NewBooleanArray(length); for (unsigned i = 0; i < length; i++) { @@ -82,7 +82,7 @@ static jobject convertArrayInstanceToJavaArray(ExecState* exec, JSArray* jsArray break; } - case byte_type: + case JavaTypeByte: { jarray = (jobjectArray)env->NewByteArray(length); for (unsigned i = 0; i < length; i++) { @@ -93,7 +93,7 @@ static jobject convertArrayInstanceToJavaArray(ExecState* exec, JSArray* jsArray break; } - case char_type: + case JavaTypeChar: { jarray = (jobjectArray)env->NewCharArray(length); for (unsigned i = 0; i < length; i++) { @@ -107,7 +107,7 @@ static jobject convertArrayInstanceToJavaArray(ExecState* exec, JSArray* jsArray break; } - case short_type: + case JavaTypeShort: { jarray = (jobjectArray)env->NewShortArray(length); for (unsigned i = 0; i < length; i++) { @@ -118,7 +118,7 @@ static jobject convertArrayInstanceToJavaArray(ExecState* exec, JSArray* jsArray break; } - case int_type: + case JavaTypeInt: { jarray = (jobjectArray)env->NewIntArray(length); for (unsigned i = 0; i < length; i++) { @@ -129,7 +129,7 @@ static jobject convertArrayInstanceToJavaArray(ExecState* exec, JSArray* jsArray break; } - case long_type: + case JavaTypeLong: { jarray = (jobjectArray)env->NewLongArray(length); for (unsigned i = 0; i < length; i++) { @@ -140,7 +140,7 @@ static jobject convertArrayInstanceToJavaArray(ExecState* exec, JSArray* jsArray break; } - case float_type: + case JavaTypeFloat: { jarray = (jobjectArray)env->NewFloatArray(length); for (unsigned i = 0; i < length; i++) { @@ -151,7 +151,7 @@ static jobject convertArrayInstanceToJavaArray(ExecState* exec, JSArray* jsArray break; } - case double_type: + case JavaTypeDouble: { jarray = (jobjectArray)env->NewDoubleArray(length); for (unsigned i = 0; i < length; i++) { @@ -162,9 +162,9 @@ static jobject convertArrayInstanceToJavaArray(ExecState* exec, JSArray* jsArray break; } - case array_type: // don't handle embedded arrays - case void_type: // Don't expect arrays of void objects - case invalid_type: // Array of unknown objects + case JavaTypeArray: // don't handle embedded arrays + case JavaTypeVoid: // Don't expect arrays of void objects + case JavaTypeInvalid: // Array of unknown objects break; } @@ -172,16 +172,16 @@ static jobject convertArrayInstanceToJavaArray(ExecState* exec, JSArray* jsArray return jarray; } -jvalue convertValueToJValue(ExecState* exec, RootObject* rootObject, JSValue value, JNIType jniType, const char* javaClassName) +jvalue convertValueToJValue(ExecState* exec, RootObject* rootObject, JSValue value, JavaType javaType, const char* javaClassName) { JSLock lock(SilenceAssertionsOnly); jvalue result; memset(&result, 0, sizeof(jvalue)); - switch (jniType) { - case array_type: - case object_type: + switch (javaType) { + case JavaTypeArray: + case JavaTypeObject: { // FIXME: JavaJSObject::convertValueToJObject functionality is almost exactly the same, // these functions should use common code. @@ -258,56 +258,56 @@ jvalue convertValueToJValue(ExecState* exec, RootObject* rootObject, JSValue val } break; - case boolean_type: + case JavaTypeBoolean: { result.z = (jboolean)value.toNumber(exec); } break; - case byte_type: + case JavaTypeByte: { result.b = (jbyte)value.toNumber(exec); } break; - case char_type: + case JavaTypeChar: { result.c = (jchar)value.toNumber(exec); } break; - case short_type: + case JavaTypeShort: { result.s = (jshort)value.toNumber(exec); } break; - case int_type: + case JavaTypeInt: { result.i = (jint)value.toNumber(exec); } break; - case long_type: + case JavaTypeLong: { result.j = (jlong)value.toNumber(exec); } break; - case float_type: + case JavaTypeFloat: { result.f = (jfloat)value.toNumber(exec); } break; - case double_type: + case JavaTypeDouble: { result.d = (jdouble)value.toNumber(exec); } break; - case invalid_type: - case void_type: + case JavaTypeInvalid: + case JavaTypeVoid: break; } return result; diff --git a/Source/WebCore/bridge/jni/jsc/JNIUtilityPrivate.h b/Source/WebCore/bridge/jni/jsc/JNIUtilityPrivate.h index 1266acd..ed09fd6 100644 --- a/Source/WebCore/bridge/jni/jsc/JNIUtilityPrivate.h +++ b/Source/WebCore/bridge/jni/jsc/JNIUtilityPrivate.h @@ -41,8 +41,8 @@ namespace Bindings { class RootObject; -jvalue convertValueToJValue(ExecState*, RootObject*, JSValue, JNIType, const char* javaClassName); -bool dispatchJNICall(ExecState*, const void* targetAppletView, jobject obj, bool isStatic, JNIType returnType, jmethodID methodID, jvalue* args, jvalue& result, const char* callingURL, JSValue& exceptionDescription); +jvalue convertValueToJValue(ExecState*, RootObject*, JSValue, JavaType, const char* javaClassName); +bool dispatchJNICall(ExecState*, const void* targetAppletView, jobject, bool isStatic, JavaType returnType, jmethodID, jvalue* args, jvalue& result, const char* callingURL, JSValue& exceptionDescription); } // namespace Bindings diff --git a/Source/WebCore/bridge/jni/jsc/JavaArrayJSC.cpp b/Source/WebCore/bridge/jni/jsc/JavaArrayJSC.cpp index db87baa..caa8579 100644 --- a/Source/WebCore/bridge/jni/jsc/JavaArrayJSC.cpp +++ b/Source/WebCore/bridge/jni/jsc/JavaArrayJSC.cpp @@ -75,7 +75,7 @@ void JavaArray::setValueAt(ExecState* exec, unsigned index, JSValue aValue) cons JNIEnv* env = getJNIEnv(); char* javaClassName = 0; - JNIType arrayType = JNITypeFromPrimitiveType(m_type[1]); + JavaType arrayType = javaTypeFromPrimitiveType(m_type[1]); if (m_type[1] == 'L') { // The type of the array will be something like: // "[Ljava.lang.string;". This is guaranteed, so no need @@ -86,54 +86,54 @@ void JavaArray::setValueAt(ExecState* exec, unsigned index, JSValue aValue) cons jvalue aJValue = convertValueToJValue(exec, m_rootObject.get(), aValue, arrayType, javaClassName); switch (arrayType) { - case object_type: + case JavaTypeObject: { env->SetObjectArrayElement(static_cast<jobjectArray>(javaArray()), index, aJValue.l); break; } - case boolean_type: + case JavaTypeBoolean: { env->SetBooleanArrayRegion(static_cast<jbooleanArray>(javaArray()), index, 1, &aJValue.z); break; } - case byte_type: + case JavaTypeByte: { env->SetByteArrayRegion(static_cast<jbyteArray>(javaArray()), index, 1, &aJValue.b); break; } - case char_type: + case JavaTypeChar: { env->SetCharArrayRegion(static_cast<jcharArray>(javaArray()), index, 1, &aJValue.c); break; } - case short_type: + case JavaTypeShort: { env->SetShortArrayRegion(static_cast<jshortArray>(javaArray()), index, 1, &aJValue.s); break; } - case int_type: + case JavaTypeInt: { env->SetIntArrayRegion(static_cast<jintArray>(javaArray()), index, 1, &aJValue.i); break; } - case long_type: + case JavaTypeLong: { env->SetLongArrayRegion(static_cast<jlongArray>(javaArray()), index, 1, &aJValue.j); } - case float_type: + case JavaTypeFloat: { env->SetFloatArrayRegion(static_cast<jfloatArray>(javaArray()), index, 1, &aJValue.f); break; } - case double_type: + case JavaTypeDouble: { env->SetDoubleArrayRegion(static_cast<jdoubleArray>(javaArray()), index, 1, &aJValue.d); break; @@ -149,9 +149,9 @@ void JavaArray::setValueAt(ExecState* exec, unsigned index, JSValue aValue) cons JSValue JavaArray::valueAt(ExecState* exec, unsigned index) const { JNIEnv* env = getJNIEnv(); - JNIType arrayType = JNITypeFromPrimitiveType(m_type[1]); + JavaType arrayType = javaTypeFromPrimitiveType(m_type[1]); switch (arrayType) { - case object_type: + case JavaTypeObject: { jobjectArray objectArray = static_cast<jobjectArray>(javaArray()); jobject anObject; @@ -168,7 +168,7 @@ JSValue JavaArray::valueAt(ExecState* exec, unsigned index) const return JavaInstance::create(anObject, rootObject())->createRuntimeObject(exec); } - case boolean_type: + case JavaTypeBoolean: { jbooleanArray booleanArray = static_cast<jbooleanArray>(javaArray()); jboolean aBoolean; @@ -176,7 +176,7 @@ JSValue JavaArray::valueAt(ExecState* exec, unsigned index) const return jsBoolean(aBoolean); } - case byte_type: + case JavaTypeByte: { jbyteArray byteArray = static_cast<jbyteArray>(javaArray()); jbyte aByte; @@ -184,7 +184,7 @@ JSValue JavaArray::valueAt(ExecState* exec, unsigned index) const return jsNumber(aByte); } - case char_type: + case JavaTypeChar: { jcharArray charArray = static_cast<jcharArray>(javaArray()); jchar aChar; @@ -193,7 +193,7 @@ JSValue JavaArray::valueAt(ExecState* exec, unsigned index) const break; } - case short_type: + case JavaTypeShort: { jshortArray shortArray = static_cast<jshortArray>(javaArray()); jshort aShort; @@ -201,7 +201,7 @@ JSValue JavaArray::valueAt(ExecState* exec, unsigned index) const return jsNumber(aShort); } - case int_type: + case JavaTypeInt: { jintArray intArray = static_cast<jintArray>(javaArray()); jint anInt; @@ -209,7 +209,7 @@ JSValue JavaArray::valueAt(ExecState* exec, unsigned index) const return jsNumber(anInt); } - case long_type: + case JavaTypeLong: { jlongArray longArray = static_cast<jlongArray>(javaArray()); jlong aLong; @@ -217,7 +217,7 @@ JSValue JavaArray::valueAt(ExecState* exec, unsigned index) const return jsNumber(aLong); } - case float_type: + case JavaTypeFloat: { jfloatArray floatArray = static_cast<jfloatArray>(javaArray()); jfloat aFloat; @@ -225,7 +225,7 @@ JSValue JavaArray::valueAt(ExecState* exec, unsigned index) const return jsNumber(aFloat); } - case double_type: + case JavaTypeDouble: { jdoubleArray doubleArray = static_cast<jdoubleArray>(javaArray()); jdouble aDouble; diff --git a/Source/WebCore/bridge/jni/jsc/JavaClassJSC.cpp b/Source/WebCore/bridge/jni/jsc/JavaClassJSC.cpp index 18cd1af..44ea2b4 100644 --- a/Source/WebCore/bridge/jni/jsc/JavaClassJSC.cpp +++ b/Source/WebCore/bridge/jni/jsc/JavaClassJSC.cpp @@ -28,10 +28,9 @@ #if ENABLE(JAVA_BRIDGE) -#include "JNIUtility.h" #include "JSDOMWindow.h" #include "JavaFieldJSC.h" -#include "JavaMethod.h" +#include "JavaMethodJobject.h" #include <runtime/Identifier.h> #include <runtime/JSLock.h> @@ -77,7 +76,7 @@ JavaClass::JavaClass(jobject anInstance) int numMethods = env->GetArrayLength(methods); for (i = 0; i < numMethods; i++) { jobject aJMethod = env->GetObjectArrayElement((jobjectArray)methods, i); - JavaMethod* aMethod = new JavaMethod(env, aJMethod); // deleted in the JavaClass destructor + JavaMethod* aMethod = new JavaMethodJobject(env, aJMethod); // deleted in the JavaClass destructor MethodList* methodList; { JSLock lock(SilenceAssertionsOnly); diff --git a/Source/WebCore/bridge/jni/jsc/JavaFieldJSC.cpp b/Source/WebCore/bridge/jni/jsc/JavaFieldJSC.cpp index d3ba06a..b7c664e 100644 --- a/Source/WebCore/bridge/jni/jsc/JavaFieldJSC.cpp +++ b/Source/WebCore/bridge/jni/jsc/JavaFieldJSC.cpp @@ -48,9 +48,9 @@ JavaField::JavaField(JNIEnv* env, jobject aField) fieldTypeName = static_cast<jstring>(callJNIMethod<jobject>(fieldType, "getName", "()Ljava/lang/String;")); if (!fieldTypeName) fieldTypeName = env->NewStringUTF("<Unknown>"); - m_type = JavaString(env, fieldTypeName); + m_typeClassName = JavaString(env, fieldTypeName); - m_JNIType = JNITypeFromClassName(m_type.utf8()); + m_type = javaTypeFromClassName(m_typeClassName.utf8()); // Get field name jstring fieldName = static_cast<jstring>(callJNIMethod<jobject>(aField, "getName", "()Ljava/lang/String;")); @@ -61,7 +61,7 @@ JavaField::JavaField(JNIEnv* env, jobject aField) m_field = new JobjectWrapper(aField); } -jvalue JavaField::dispatchValueFromInstance(ExecState* exec, const JavaInstance* instance, const char* name, const char* sig, JNIType returnType) const +jvalue JavaField::dispatchValueFromInstance(ExecState* exec, const JavaInstance* instance, const char* name, const char* sig, JavaType returnType) const { jobject jinstance = instance->javaInstance(); jobject fieldJInstance = m_field->m_instance; @@ -94,17 +94,17 @@ JSValue JavaField::valueFromInstance(ExecState* exec, const Instance* i) const JSValue jsresult = jsUndefined(); - switch (m_JNIType) { - case array_type: - case object_type: + switch (m_type) { + case JavaTypeArray: + case JavaTypeObject: { - jvalue result = dispatchValueFromInstance(exec, instance, "get", "(Ljava/lang/Object;)Ljava/lang/Object;", object_type); + jvalue result = dispatchValueFromInstance(exec, instance, "get", "(Ljava/lang/Object;)Ljava/lang/Object;", JavaTypeObject); jobject anObject = result.l; if (!anObject) return jsNull(); - const char* arrayType = type(); + const char* arrayType = typeClassName(); if (arrayType[0] == '[') jsresult = JavaArray::convertJObjectToArray(exec, anObject, arrayType, instance->rootObject()); else if (anObject) @@ -112,29 +112,29 @@ JSValue JavaField::valueFromInstance(ExecState* exec, const Instance* i) const } break; - case boolean_type: - jsresult = jsBoolean(dispatchValueFromInstance(exec, instance, "getBoolean", "(Ljava/lang/Object;)Z", boolean_type).z); + case JavaTypeBoolean: + jsresult = jsBoolean(dispatchValueFromInstance(exec, instance, "getBoolean", "(Ljava/lang/Object;)Z", JavaTypeBoolean).z); break; - case byte_type: - case char_type: - case short_type: + case JavaTypeByte: + case JavaTypeChar: + case JavaTypeShort: - case int_type: + case JavaTypeInt: { jint value; - jvalue result = dispatchValueFromInstance(exec, instance, "getInt", "(Ljava/lang/Object;)I", int_type); + jvalue result = dispatchValueFromInstance(exec, instance, "getInt", "(Ljava/lang/Object;)I", JavaTypeInt); value = result.i; jsresult = jsNumber(static_cast<int>(value)); } break; - case long_type: - case float_type: - case double_type: + case JavaTypeLong: + case JavaTypeFloat: + case JavaTypeDouble: { jdouble value; - jvalue result = dispatchValueFromInstance(exec, instance, "getDouble", "(Ljava/lang/Object;)D", double_type); + jvalue result = dispatchValueFromInstance(exec, instance, "getDouble", "(Ljava/lang/Object;)D", JavaTypeDouble); value = result.i; jsresult = jsNumber(static_cast<double>(value)); } @@ -166,7 +166,7 @@ void JavaField::dispatchSetValueToInstance(ExecState* exec, const JavaInstance* args[0].l = jinstance; args[1] = javaValue; - dispatchJNICall(exec, rootObject->nativeHandle(), fieldJInstance, false, void_type, mid, args, result, 0, exceptionDescription); + dispatchJNICall(exec, rootObject->nativeHandle(), fieldJInstance, false, JavaTypeVoid, mid, args, result, 0, exceptionDescription); if (exceptionDescription) throwError(exec, createError(exec, exceptionDescription.toString(exec))); } @@ -177,61 +177,61 @@ void JavaField::dispatchSetValueToInstance(ExecState* exec, const JavaInstance* void JavaField::setValueToInstance(ExecState* exec, const Instance* i, JSValue aValue) const { const JavaInstance* instance = static_cast<const JavaInstance*>(i); - jvalue javaValue = convertValueToJValue(exec, i->rootObject(), aValue, m_JNIType, type()); + jvalue javaValue = convertValueToJValue(exec, i->rootObject(), aValue, m_type, typeClassName()); LOG(LiveConnect, "JavaField::setValueToInstance setting value %s to %s", UString(name().impl()).utf8().data(), aValue.toString(exec).ascii().data()); - switch (m_JNIType) { - case array_type: - case object_type: + switch (m_type) { + case JavaTypeArray: + case JavaTypeObject: { dispatchSetValueToInstance(exec, instance, javaValue, "set", "(Ljava/lang/Object;Ljava/lang/Object;)V"); } break; - case boolean_type: + case JavaTypeBoolean: { dispatchSetValueToInstance(exec, instance, javaValue, "setBoolean", "(Ljava/lang/Object;Z)V"); } break; - case byte_type: + case JavaTypeByte: { dispatchSetValueToInstance(exec, instance, javaValue, "setByte", "(Ljava/lang/Object;B)V"); } break; - case char_type: + case JavaTypeChar: { dispatchSetValueToInstance(exec, instance, javaValue, "setChar", "(Ljava/lang/Object;C)V"); } break; - case short_type: + case JavaTypeShort: { dispatchSetValueToInstance(exec, instance, javaValue, "setShort", "(Ljava/lang/Object;S)V"); } break; - case int_type: + case JavaTypeInt: { dispatchSetValueToInstance(exec, instance, javaValue, "setInt", "(Ljava/lang/Object;I)V"); } break; - case long_type: + case JavaTypeLong: { dispatchSetValueToInstance(exec, instance, javaValue, "setLong", "(Ljava/lang/Object;J)V"); } break; - case float_type: + case JavaTypeFloat: { dispatchSetValueToInstance(exec, instance, javaValue, "setFloat", "(Ljava/lang/Object;F)V"); } break; - case double_type: + case JavaTypeDouble: { dispatchSetValueToInstance(exec, instance, javaValue, "setDouble", "(Ljava/lang/Object;D)V"); } diff --git a/Source/WebCore/bridge/jni/jsc/JavaFieldJSC.h b/Source/WebCore/bridge/jni/jsc/JavaFieldJSC.h index a67264a..9b95132 100644 --- a/Source/WebCore/bridge/jni/jsc/JavaFieldJSC.h +++ b/Source/WebCore/bridge/jni/jsc/JavaFieldJSC.h @@ -47,17 +47,16 @@ public: virtual void setValueToInstance(ExecState*, const Instance*, JSValue) const; const JavaString& name() const { return m_name; } - virtual RuntimeType type() const { return m_type.utf8(); } - - JNIType getJNIType() const { return m_JNIType; } + virtual RuntimeType typeClassName() const { return m_typeClassName.utf8(); } + JavaType type() const { return m_type; } private: void dispatchSetValueToInstance(ExecState*, const JavaInstance*, jvalue, const char* name, const char* sig) const; - jvalue dispatchValueFromInstance(ExecState*, const JavaInstance*, const char* name, const char* sig, JNIType returnType) const; + jvalue dispatchValueFromInstance(ExecState*, const JavaInstance*, const char* name, const char* sig, JavaType returnType) const; JavaString m_name; - JavaString m_type; - JNIType m_JNIType; + JavaString m_typeClassName; + JavaType m_type; RefPtr<JobjectWrapper> m_field; }; diff --git a/Source/WebCore/bridge/jni/jsc/JavaInstanceJSC.cpp b/Source/WebCore/bridge/jni/jsc/JavaInstanceJSC.cpp index 9d9a450..806efa6 100644 --- a/Source/WebCore/bridge/jni/jsc/JavaInstanceJSC.cpp +++ b/Source/WebCore/bridge/jni/jsc/JavaInstanceJSC.cpp @@ -29,7 +29,6 @@ #if ENABLE(JAVA_BRIDGE) #include "JavaRuntimeObject.h" -#include "JNIUtility.h" #include "JNIUtilityPrivate.h" #include "JSDOMBinding.h" #include "JavaArrayJSC.h" @@ -125,9 +124,9 @@ public: ASSERT(inherits(&s_info)); } - static PassRefPtr<Structure> createStructure(JSValue prototype) + static PassRefPtr<Structure> createStructure(JSGlobalData& globalData, JSValue prototype) { - return Structure::create(prototype, TypeInfo(ObjectType, StructureFlags), AnonymousSlotCount, &s_info); + return Structure::create(globalData, prototype, TypeInfo(ObjectType, StructureFlags), AnonymousSlotCount, &s_info); } static const ClassInfo s_info; @@ -178,7 +177,7 @@ JSValue JavaInstance::invokeMethod(ExecState* exec, RuntimeMethod* runtimeMethod for (i = 0; i < count; i++) { CString javaClassName = jMethod->parameterAt(i).utf8(); - jArgs[i] = convertValueToJValue(exec, m_rootObject.get(), exec->argument(i), JNITypeFromClassName(javaClassName.data()), javaClassName.data()); + jArgs[i] = convertValueToJValue(exec, m_rootObject.get(), exec->argument(i), javaTypeFromClassName(javaClassName.data()), javaClassName.data()); LOG(LiveConnect, "JavaInstance::invokeMethod arg[%d] = %s", i, exec->argument(i).toString(exec).ascii().data()); } @@ -196,7 +195,8 @@ JSValue JavaInstance::invokeMethod(ExecState* exec, RuntimeMethod* runtimeMethod jobject obj = m_instance->m_instance; JSValue exceptionDescription; const char *callingURL = 0; // FIXME, need to propagate calling URL to Java - handled = dispatchJNICall(exec, rootObject->nativeHandle(), obj, jMethod->isStatic(), jMethod->JNIReturnType(), jMethod->methodID(obj), jArgs.data(), result, callingURL, exceptionDescription); + jmethodID methodId = getMethodID(obj, jMethod->name().utf8().data(), jMethod->signature()); + handled = dispatchJNICall(exec, rootObject->nativeHandle(), obj, jMethod->isStatic(), jMethod->returnType(), methodId, jArgs.data(), result, callingURL, exceptionDescription); if (exceptionDescription) { throwError(exec, createError(exec, exceptionDescription.toString(exec))); return jsUndefined(); @@ -206,58 +206,22 @@ JSValue JavaInstance::invokeMethod(ExecState* exec, RuntimeMethod* runtimeMethod // This is a deprecated code path which should not be required on Android. // Remove this guard once Bug 39476 is fixed. #if PLATFORM(ANDROID) || defined(BUILDING_ON_TIGER) - if (!handled) { - jobject obj = m_instance->m_instance; - switch (jMethod->JNIReturnType()) { - case void_type: - callJNIMethodIDA<void>(obj, jMethod->methodID(obj), jArgs.data()); - break; - case object_type: - result.l = callJNIMethodIDA<jobject>(obj, jMethod->methodID(obj), jArgs.data()); - break; - case boolean_type: - result.z = callJNIMethodIDA<jboolean>(obj, jMethod->methodID(obj), jArgs.data()); - break; - case byte_type: - result.b = callJNIMethodIDA<jbyte>(obj, jMethod->methodID(obj), jArgs.data()); - break; - case char_type: - result.c = callJNIMethodIDA<jchar>(obj, jMethod->methodID(obj), jArgs.data()); - break; - case short_type: - result.s = callJNIMethodIDA<jshort>(obj, jMethod->methodID(obj), jArgs.data()); - break; - case int_type: - result.i = callJNIMethodIDA<jint>(obj, jMethod->methodID(obj), jArgs.data()); - break; - case long_type: - result.j = callJNIMethodIDA<jlong>(obj, jMethod->methodID(obj), jArgs.data()); - break; - case float_type: - result.f = callJNIMethodIDA<jfloat>(obj, jMethod->methodID(obj), jArgs.data()); - break; - case double_type: - result.d = callJNIMethodIDA<jdouble>(obj, jMethod->methodID(obj), jArgs.data()); - break; - case array_type: - case invalid_type: - break; - } - } + if (!handled) + result = callJNIMethod(m_instance->m_instance, jMethod->returnType(), jMethod->name().utf8().data(), jMethod->signature(), jArgs.data()); #endif - switch (jMethod->JNIReturnType()) { - case void_type: + switch (jMethod->returnType()) { + case JavaTypeVoid: { resultValue = jsUndefined(); } break; - case object_type: + case JavaTypeObject: { if (result.l) { - // FIXME: array_type return type is handled below, can we actually get an array here? - const char* arrayType = jMethod->returnType(); + // FIXME: JavaTypeArray return type is handled below, can we actually get an array here? + const char* arrayType = jMethod->returnTypeClassName(); if (arrayType[0] == '[') resultValue = JavaArray::convertJObjectToArray(exec, result.l, arrayType, rootObject); else { @@ -281,63 +245,63 @@ JSValue JavaInstance::invokeMethod(ExecState* exec, RuntimeMethod* runtimeMethod } break; - case boolean_type: + case JavaTypeBoolean: { resultValue = jsBoolean(result.z); } break; - case byte_type: + case JavaTypeByte: { resultValue = jsNumber(result.b); } break; - case char_type: + case JavaTypeChar: { resultValue = jsNumber(result.c); } break; - case short_type: + case JavaTypeShort: { resultValue = jsNumber(result.s); } break; - case int_type: + case JavaTypeInt: { resultValue = jsNumber(result.i); } break; - case long_type: + case JavaTypeLong: { resultValue = jsNumber(result.j); } break; - case float_type: + case JavaTypeFloat: { resultValue = jsNumber(result.f); } break; - case double_type: + case JavaTypeDouble: { resultValue = jsNumber(result.d); } break; - case array_type: + case JavaTypeArray: { - const char* arrayType = jMethod->returnType(); + const char* arrayType = jMethod->returnTypeClassName(); ASSERT(arrayType[0] == '['); resultValue = JavaArray::convertJObjectToArray(exec, result.l, arrayType, rootObject); } break; - case invalid_type: + case JavaTypeInvalid: { resultValue = jsUndefined(); } diff --git a/Source/WebCore/bridge/jni/jsc/JavaRuntimeObject.h b/Source/WebCore/bridge/jni/jsc/JavaRuntimeObject.h index 12a85ae..03f116f 100644 --- a/Source/WebCore/bridge/jni/jsc/JavaRuntimeObject.h +++ b/Source/WebCore/bridge/jni/jsc/JavaRuntimeObject.h @@ -42,9 +42,9 @@ public: static const ClassInfo s_info; - static PassRefPtr<Structure> createStructure(JSValue prototype) + static PassRefPtr<Structure> createStructure(JSGlobalData& globalData, JSValue prototype) { - return Structure::create(prototype, TypeInfo(ObjectType, StructureFlags), AnonymousSlotCount, &s_info); + return Structure::create(globalData, prototype, TypeInfo(ObjectType, StructureFlags), AnonymousSlotCount, &s_info); } }; diff --git a/Source/WebCore/bridge/jni/jsc/JavaStringJSC.h b/Source/WebCore/bridge/jni/jsc/JavaStringJSC.h index 3ce7a16..7c19d4e 100644 --- a/Source/WebCore/bridge/jni/jsc/JavaStringJSC.h +++ b/Source/WebCore/bridge/jni/jsc/JavaStringJSC.h @@ -28,7 +28,9 @@ #include "JNIUtility.h" #include "JavaInstanceJSC.h" + #include <runtime/JSLock.h> +#include <runtime/ScopeChain.h> namespace JSC { diff --git a/Source/WebCore/bridge/jni/v8/JNIUtilityPrivate.cpp b/Source/WebCore/bridge/jni/v8/JNIUtilityPrivate.cpp index 30e344d..7ac1a93 100644 --- a/Source/WebCore/bridge/jni/v8/JNIUtilityPrivate.cpp +++ b/Source/WebCore/bridge/jni/v8/JNIUtilityPrivate.cpp @@ -30,22 +30,28 @@ #include "JavaInstanceV8.h" #include "JavaNPObjectV8.h" +<<<<<<< HEAD #if PLATFORM(ANDROID) #include "npruntime_impl.h" #endif // PLATFORM(ANDROID) +======= +#include "JavaValueV8.h" +>>>>>>> webkit.org at r82507 #include <wtf/text/CString.h> namespace JSC { namespace Bindings { -jvalue convertNPVariantToJValue(NPVariant value, const WTF::String& javaType) +JavaValue convertNPVariantToJavaValue(NPVariant value, const String& javaClass) { - CString javaClassName = javaType.utf8(); - JNIType jniType = JNITypeFromClassName(javaClassName.data()); - jvalue result; + CString javaClassName = javaClass.utf8(); + JavaType javaType = javaTypeFromClassName(javaClassName.data()); + JavaValue result; + result.m_type = javaType; NPVariantType type = value.type; +<<<<<<< HEAD switch (jniType) { case array_type: #if PLATFORM(ANDROID) @@ -208,29 +214,31 @@ jvalue convertNPVariantToJValue(NPVariant value, const WTF::String& javaType) #endif // PLATFORM(ANDROID) case object_type: +======= + switch (javaType) { + case JavaTypeArray: + case JavaTypeObject: +>>>>>>> webkit.org at r82507 { - result.l = static_cast<jobject>(0); - - // First see if we have a Java instance. + // See if we have a Java instance. if (type == NPVariantType_Object) { NPObject* objectImp = NPVARIANT_TO_OBJECT(value); - if (JavaInstance* instance = ExtractJavaInstance(objectImp)) - result.l = instance->javaInstance(); + result.m_objectValue = ExtractJavaInstance(objectImp); } + } + break; - // Now convert value to a string if the target type is a java.lang.string, and we're not - // converting from a Null. - if (!result.l && !strcmp(javaClassName.data(), "java.lang.String")) { + case JavaTypeString: + { #ifdef CONVERT_NULL_TO_EMPTY_STRING - if (type == NPVariantType_Null) { - JNIEnv* env = getJNIEnv(); - jchar buf[2]; - jobject javaString = env->functions->NewString(env, buf, 0); - result.l = javaString; - } else + if (type == NPVariantType_Null) { + result.m_type = JavaTypeString; + result.m_stringValue = String::fromUTF8(""); + } else #else - if (type == NPVariantType_String) + if (type == NPVariantType_String) #endif +<<<<<<< HEAD { NPString src = NPVARIANT_TO_STRING(value); JNIEnv* env = getJNIEnv(); @@ -261,182 +269,167 @@ jvalue convertNPVariantToJValue(NPVariant value, const WTF::String& javaType) #endif // PLATFORM(ANDROID) } else if (!result.l) memset(&result, 0, sizeof(jvalue)); // Handle it the same as a void case +======= + { + NPString src = NPVARIANT_TO_STRING(value); + result.m_type = JavaTypeString; + result.m_stringValue = String::fromUTF8(src.UTF8Characters); + } +>>>>>>> webkit.org at r82507 } break; - case boolean_type: + case JavaTypeBoolean: { if (type == NPVariantType_Bool) - result.z = NPVARIANT_TO_BOOLEAN(value); - else - memset(&result, 0, sizeof(jvalue)); // as void case + result.m_booleanValue = NPVARIANT_TO_BOOLEAN(value); } break; - case byte_type: + case JavaTypeByte: { if (type == NPVariantType_Int32) - result.b = static_cast<jbyte>(NPVARIANT_TO_INT32(value)); + result.m_byteValue = static_cast<signed char>(NPVARIANT_TO_INT32(value)); else if (type == NPVariantType_Double) - result.b = static_cast<jbyte>(NPVARIANT_TO_DOUBLE(value)); - else - memset(&result, 0, sizeof(jvalue)); + result.m_byteValue = static_cast<signed char>(NPVARIANT_TO_DOUBLE(value)); } break; - case char_type: + case JavaTypeChar: { if (type == NPVariantType_Int32) - result.c = static_cast<char>(NPVARIANT_TO_INT32(value)); - else - memset(&result, 0, sizeof(jvalue)); + result.m_charValue = static_cast<unsigned short>(NPVARIANT_TO_INT32(value)); } break; - case short_type: + case JavaTypeShort: { if (type == NPVariantType_Int32) - result.s = static_cast<jshort>(NPVARIANT_TO_INT32(value)); + result.m_shortValue = static_cast<short>(NPVARIANT_TO_INT32(value)); else if (type == NPVariantType_Double) - result.s = static_cast<jshort>(NPVARIANT_TO_DOUBLE(value)); - else - memset(&result, 0, sizeof(jvalue)); + result.m_shortValue = static_cast<short>(NPVARIANT_TO_DOUBLE(value)); } break; - case int_type: + case JavaTypeInt: { if (type == NPVariantType_Int32) - result.i = static_cast<jint>(NPVARIANT_TO_INT32(value)); + result.m_intValue = static_cast<int>(NPVARIANT_TO_INT32(value)); else if (type == NPVariantType_Double) - result.i = static_cast<jint>(NPVARIANT_TO_DOUBLE(value)); - else - memset(&result, 0, sizeof(jvalue)); + result.m_intValue = static_cast<int>(NPVARIANT_TO_DOUBLE(value)); } break; - case long_type: + case JavaTypeLong: { if (type == NPVariantType_Int32) - result.j = static_cast<jlong>(NPVARIANT_TO_INT32(value)); + result.m_longValue = static_cast<long long>(NPVARIANT_TO_INT32(value)); else if (type == NPVariantType_Double) - result.j = static_cast<jlong>(NPVARIANT_TO_DOUBLE(value)); - else - memset(&result, 0, sizeof(jvalue)); + result.m_longValue = static_cast<long long>(NPVARIANT_TO_DOUBLE(value)); } break; - case float_type: + case JavaTypeFloat: { if (type == NPVariantType_Int32) - result.f = static_cast<jfloat>(NPVARIANT_TO_INT32(value)); + result.m_floatValue = static_cast<float>(NPVARIANT_TO_INT32(value)); else if (type == NPVariantType_Double) - result.f = static_cast<jfloat>(NPVARIANT_TO_DOUBLE(value)); - else - memset(&result, 0, sizeof(jvalue)); + result.m_floatValue = static_cast<float>(NPVARIANT_TO_DOUBLE(value)); } break; - case double_type: + case JavaTypeDouble: { if (type == NPVariantType_Int32) - result.d = static_cast<jdouble>(NPVARIANT_TO_INT32(value)); + result.m_doubleValue = static_cast<double>(NPVARIANT_TO_INT32(value)); else if (type == NPVariantType_Double) - result.d = static_cast<jdouble>(NPVARIANT_TO_DOUBLE(value)); - else - memset(&result, 0, sizeof(jvalue)); + result.m_doubleValue = static_cast<double>(NPVARIANT_TO_DOUBLE(value)); } break; - - break; - - case invalid_type: default: - case void_type: - { - memset(&result, 0, sizeof(jvalue)); - } break; } return result; } -void convertJValueToNPVariant(jvalue value, JNIType jniType, const char* javaTypeName, NPVariant* result) +void convertJavaValueToNPVariant(JavaValue value, NPVariant* result) { - switch (jniType) { - case void_type: + switch (value.m_type) { + case JavaTypeVoid: { VOID_TO_NPVARIANT(*result); } break; - case object_type: + case JavaTypeObject: { - if (value.l) { - if (!strcmp(javaTypeName, "java.lang.String")) { - const char* v = getCharactersFromJString(static_cast<jstring>(value.l)); - // s is freed in NPN_ReleaseVariantValue (see npruntime.cpp) - const char* s = strdup(v); - releaseCharactersForJString(static_cast<jstring>(value.l), v); - STRINGZ_TO_NPVARIANT(s, *result); - } else - OBJECT_TO_NPVARIANT(JavaInstanceToNPObject(new JavaInstance(value.l)), *result); - } else + // If the JavaValue is a String object, it should have type JavaTypeString. + if (value.m_objectValue) + OBJECT_TO_NPVARIANT(JavaInstanceToNPObject(value.m_objectValue.get()), *result); + else VOID_TO_NPVARIANT(*result); } break; - case boolean_type: + case JavaTypeString: + { + const char* utf8String = strdup(value.m_stringValue.utf8().data()); + // The copied string is freed in NPN_ReleaseVariantValue (see npruntime.cpp) + STRINGZ_TO_NPVARIANT(utf8String, *result); + } + break; + + case JavaTypeBoolean: { - BOOLEAN_TO_NPVARIANT(value.z, *result); + BOOLEAN_TO_NPVARIANT(value.m_booleanValue, *result); } break; - case byte_type: + case JavaTypeByte: { - INT32_TO_NPVARIANT(value.b, *result); + INT32_TO_NPVARIANT(value.m_byteValue, *result); } break; - case char_type: + case JavaTypeChar: { - INT32_TO_NPVARIANT(value.c, *result); + INT32_TO_NPVARIANT(value.m_charValue, *result); } break; - case short_type: + case JavaTypeShort: { - INT32_TO_NPVARIANT(value.s, *result); + INT32_TO_NPVARIANT(value.m_shortValue, *result); } break; - case int_type: + case JavaTypeInt: { - INT32_TO_NPVARIANT(value.i, *result); + INT32_TO_NPVARIANT(value.m_intValue, *result); } break; // TODO: Check if cast to double is needed. - case long_type: + case JavaTypeLong: { - DOUBLE_TO_NPVARIANT(value.j, *result); + DOUBLE_TO_NPVARIANT(value.m_longValue, *result); } break; - case float_type: + case JavaTypeFloat: { - DOUBLE_TO_NPVARIANT(value.f, *result); + DOUBLE_TO_NPVARIANT(value.m_floatValue, *result); } break; - case double_type: + case JavaTypeDouble: { - DOUBLE_TO_NPVARIANT(value.d, *result); + DOUBLE_TO_NPVARIANT(value.m_doubleValue, *result); } break; - case invalid_type: + case JavaTypeInvalid: default: { VOID_TO_NPVARIANT(*result); @@ -445,6 +438,103 @@ void convertJValueToNPVariant(jvalue value, JNIType jniType, const char* javaTyp } } +JavaValue jvalueToJavaValue(const jvalue& value, const JavaType& type) +{ + JavaValue result; + result.m_type = type; + switch (result.m_type) { + case JavaTypeVoid: + break; + case JavaTypeObject: + result.m_objectValue = new JavaInstance(value.l); + break; + case JavaTypeString: + { + jstring javaString = static_cast<jstring>(value.l); + const UChar* a = getUCharactersFromJStringInEnv(getJNIEnv(), javaString); + // We take a copy to allow the Java String to be released. + result.m_stringValue = String(a).threadsafeCopy(); + releaseUCharactersForJStringInEnv(getJNIEnv(), javaString, a); + } + break; + case JavaTypeBoolean: + result.m_booleanValue = value.z == JNI_FALSE ? false : true; + break; + case JavaTypeByte: + result.m_byteValue = value.b; + break; + case JavaTypeChar: + result.m_charValue = value.c; + break; + case JavaTypeShort: + result.m_shortValue = value.s; + break; + case JavaTypeInt: + result.m_intValue = value.i; + break; + case JavaTypeLong: + result.m_longValue = value.j; + break; + case JavaTypeFloat: + result.m_floatValue = value.f; + break; + case JavaTypeDouble: + result.m_doubleValue = value.d; + break; + default: + ASSERT(false); + } + return result; +} + +jvalue javaValueToJvalue(const JavaValue& value) +{ + jvalue result; + memset(&result, 0, sizeof(jvalue)); + switch (value.m_type) { + case JavaTypeVoid: + break; + case JavaTypeObject: + if (value.m_objectValue) + result.l = value.m_objectValue->javaInstance(); + break; + case JavaTypeString: + // This creates a local reference to a new String object, which will + // be released when the call stack returns to Java. Note that this + // may cause leaks if invoked from a native message loop, as is the + // case in workers. + result.l = getJNIEnv()->NewString(value.m_stringValue.characters(), value.m_stringValue.length()); + break; + case JavaTypeBoolean: + result.z = value.m_booleanValue ? JNI_TRUE : JNI_FALSE; + break; + case JavaTypeByte: + result.b = value.m_byteValue; + break; + case JavaTypeChar: + result.c = value.m_charValue; + break; + case JavaTypeShort: + result.s = value.m_shortValue; + break; + case JavaTypeInt: + result.i = value.m_intValue; + break; + case JavaTypeLong: + result.j = value.m_longValue; + break; + case JavaTypeFloat: + result.f = value.m_floatValue; + break; + case JavaTypeDouble: + result.d = value.m_doubleValue; + break; + default: + ASSERT(false); + } + return result; +} + } // namespace Bindings } // namespace JSC diff --git a/Source/WebCore/bridge/jni/v8/JNIUtilityPrivate.h b/Source/WebCore/bridge/jni/v8/JNIUtilityPrivate.h index df73a9e..0282904 100644 --- a/Source/WebCore/bridge/jni/v8/JNIUtilityPrivate.h +++ b/Source/WebCore/bridge/jni/v8/JNIUtilityPrivate.h @@ -36,8 +36,13 @@ namespace JSC { namespace Bindings { -jvalue convertNPVariantToJValue(NPVariant, const WTF::String& javaType); -void convertJValueToNPVariant(jvalue, JNIType, const char* javaClassName, NPVariant*); +class JavaValue; + +JavaValue convertNPVariantToJavaValue(NPVariant, const String& javaClass); +void convertJavaValueToNPVariant(JavaValue, NPVariant*); + +JavaValue jvalueToJavaValue(const jvalue&, const JavaType&); +jvalue javaValueToJvalue(const JavaValue&); } // namespace Bindings diff --git a/Source/WebCore/bridge/jni/v8/JavaClassV8.cpp b/Source/WebCore/bridge/jni/v8/JavaClassV8.cpp index 18377bd..24d05f3 100644 --- a/Source/WebCore/bridge/jni/v8/JavaClassV8.cpp +++ b/Source/WebCore/bridge/jni/v8/JavaClassV8.cpp @@ -29,7 +29,7 @@ #if ENABLE(JAVA_BRIDGE) #include "JavaFieldV8.h" -#include "JavaMethod.h" +#include "JavaMethodJobject.h" using namespace JSC::Bindings; @@ -38,7 +38,7 @@ JavaClass::JavaClass(jobject anInstance) jobject aClass = callJNIMethod<jobject>(anInstance, "getClass", "()Ljava/lang/Class;"); if (!aClass) { - fprintf(stderr, "%s: unable to call getClass on instance %p\n", __PRETTY_FUNCTION__, anInstance); + LOG_ERROR("unable to call getClass on instance %p", anInstance); return; } @@ -62,13 +62,13 @@ JavaClass::JavaClass(jobject anInstance) int numMethods = env->GetArrayLength(methods); for (i = 0; i < numMethods; i++) { jobject aJMethod = env->GetObjectArrayElement(static_cast<jobjectArray>(methods), i); - JavaMethod* aMethod = new JavaMethod(env, aJMethod); // deleted in the JavaClass destructor + JavaMethod* aMethod = new JavaMethodJobject(env, aJMethod); // deleted in the JavaClass destructor MethodList* methodList; { - methodList = m_methods.get(aMethod->name().utf8()); + methodList = m_methods.get(aMethod->name()); if (!methodList) { methodList = new MethodList(); - m_methods.set(aMethod->name().utf8(), methodList); + m_methods.set(aMethod->name(), methodList); } } methodList->append(aMethod); diff --git a/Source/WebCore/bridge/jni/v8/JavaFieldV8.cpp b/Source/WebCore/bridge/jni/v8/JavaFieldV8.cpp index 62081eb..2a6dd0b 100644 --- a/Source/WebCore/bridge/jni/v8/JavaFieldV8.cpp +++ b/Source/WebCore/bridge/jni/v8/JavaFieldV8.cpp @@ -35,8 +35,8 @@ JavaField::JavaField(JNIEnv* env, jobject aField) // Get field type jobject fieldType = callJNIMethod<jobject>(aField, "getType", "()Ljava/lang/Class;"); jstring fieldTypeName = static_cast<jstring>(callJNIMethod<jobject>(fieldType, "getName", "()Ljava/lang/String;")); - m_type = JavaString(env, fieldTypeName); - m_JNIType = JNITypeFromClassName(m_type.utf8()); + m_typeClassName = JavaString(env, fieldTypeName); + m_type = javaTypeFromClassName(m_typeClassName.utf8()); // Get field name jstring fieldName = static_cast<jstring>(callJNIMethod<jobject>(aField, "getName", "()Ljava/lang/String;")); diff --git a/Source/WebCore/bridge/jni/v8/JavaFieldV8.h b/Source/WebCore/bridge/jni/v8/JavaFieldV8.h index caf28bf..defed60 100644 --- a/Source/WebCore/bridge/jni/v8/JavaFieldV8.h +++ b/Source/WebCore/bridge/jni/v8/JavaFieldV8.h @@ -40,14 +40,13 @@ public: JavaField(JNIEnv*, jobject aField); const JavaString& name() const { return m_name; } - const char* type() const { return m_type.utf8(); } - - JNIType getJNIType() const { return m_JNIType; } + const char* typeClassName() const { return m_typeClassName.utf8(); } + JavaType type() const { return m_type; } private: JavaString m_name; - JavaString m_type; - JNIType m_JNIType; + JavaString m_typeClassName; + JavaType m_type; RefPtr<JobjectWrapper> m_field; }; diff --git a/Source/WebCore/bridge/jni/v8/JavaInstanceV8.cpp b/Source/WebCore/bridge/jni/v8/JavaInstanceV8.cpp index dbf53f0..d1075ae 100644 --- a/Source/WebCore/bridge/jni/v8/JavaInstanceV8.cpp +++ b/Source/WebCore/bridge/jni/v8/JavaInstanceV8.cpp @@ -29,10 +29,12 @@ #if ENABLE(JAVA_BRIDGE) -#include "JavaMethod.h" #include "JNIUtilityPrivate.h" #include "JavaClassV8.h" +#include "JavaFieldV8.h" +#include "JavaMethod.h" +#include <wtf/OwnArrayPtr.h> #include <wtf/text/CString.h> using namespace JSC::Bindings; @@ -68,88 +70,21 @@ JavaClass* JavaInstance::getClass() const return m_class; } -bool JavaInstance::invokeMethod(const char* methodName, const NPVariant* args, int count, NPVariant* resultValue) +JavaValue JavaInstance::invokeMethod(const JavaMethod* method, JavaValue* args) { - VOID_TO_NPVARIANT(*resultValue); - - MethodList methodList = getClass()->methodsNamed(methodName); - - size_t numMethods = methodList.size(); - - // Try to find a good match for the overloaded method. The - // fundamental problem is that JavaScript doesn't have the - // notion of method overloading and Java does. We could - // get a bit more sophisticated and attempt to does some - // type checking as we as checking the number of parameters. - JavaMethod* aMethod; - JavaMethod* method = 0; - for (size_t methodIndex = 0; methodIndex < numMethods; methodIndex++) { - aMethod = methodList[methodIndex]; - if (aMethod->numParameters() == count) { - method = aMethod; - break; - } - } - if (!method) - return false; - - const JavaMethod* jMethod = static_cast<const JavaMethod*>(method); - - jvalue* jArgs = 0; - if (count > 0) - jArgs = static_cast<jvalue*>(malloc(count * sizeof(jvalue))); - - for (int i = 0; i < count; i++) - jArgs[i] = convertNPVariantToJValue(args[i], jMethod->parameterAt(i)); - - jvalue result; - - // The following code can be conditionally removed once we have a Tiger update that - // contains the new Java plugin. It is needed for builds prior to Tiger. - { - jobject obj = javaInstance(); - switch (jMethod->JNIReturnType()) { - case void_type: - callJNIMethodIDA<void>(obj, jMethod->methodID(obj), jArgs); - break; - case object_type: - result.l = callJNIMethodIDA<jobject>(obj, jMethod->methodID(obj), jArgs); - break; - case boolean_type: - result.z = callJNIMethodIDA<jboolean>(obj, jMethod->methodID(obj), jArgs); - break; - case byte_type: - result.b = callJNIMethodIDA<jbyte>(obj, jMethod->methodID(obj), jArgs); - break; - case char_type: - result.c = callJNIMethodIDA<jchar>(obj, jMethod->methodID(obj), jArgs); - break; - case short_type: - result.s = callJNIMethodIDA<jshort>(obj, jMethod->methodID(obj), jArgs); - break; - case int_type: - result.i = callJNIMethodIDA<jint>(obj, jMethod->methodID(obj), jArgs); - break; - - case long_type: - result.j = callJNIMethodIDA<jlong>(obj, jMethod->methodID(obj), jArgs); - break; - case float_type: - result.f = callJNIMethodIDA<jfloat>(obj, jMethod->methodID(obj), jArgs); - break; - case double_type: - result.d = callJNIMethodIDA<jdouble>(obj, jMethod->methodID(obj), jArgs); - break; - case invalid_type: - default: - break; - } - } - - convertJValueToNPVariant(result, jMethod->JNIReturnType(), jMethod->returnType(), resultValue); - free(jArgs); + ASSERT(getClass()->methodsNamed(method->name().utf8().data()).find(method) != notFound); + unsigned int numParams = method->numParameters(); + OwnArrayPtr<jvalue> jvalueArgs = adoptArrayPtr(new jvalue[numParams]); + for (unsigned int i = 0; i < numParams; ++i) + jvalueArgs[i] = javaValueToJvalue(args[i]); + jvalue result = callJNIMethod(javaInstance(), method->returnType(), method->name().utf8().data(), method->signature(), jvalueArgs.get()); + return jvalueToJavaValue(result, method->returnType()); +} - return true; +JavaValue JavaInstance::getField(const JavaField* field) +{ + ASSERT(getClass()->fieldNamed(field->name().utf8()) == field); + return jvalueToJavaValue(getJNIField(javaInstance(), field->type(), field->name().utf8(), field->typeClassName()), field->type()); } #endif // ENABLE(JAVA_BRIDGE) diff --git a/Source/WebCore/bridge/jni/v8/JavaInstanceV8.h b/Source/WebCore/bridge/jni/v8/JavaInstanceV8.h index 8ee3195..b1150f8 100644 --- a/Source/WebCore/bridge/jni/v8/JavaInstanceV8.h +++ b/Source/WebCore/bridge/jni/v8/JavaInstanceV8.h @@ -30,6 +30,7 @@ #if ENABLE(JAVA_BRIDGE) #include "JNIUtility.h" +#include "JavaValueV8.h" #include "JobjectWrapper.h" #include "npruntime.h" @@ -43,6 +44,8 @@ namespace JSC { namespace Bindings { class JavaClass; +class JavaField; +class JavaMethod; class JavaInstance : public RefCounted<JavaInstance> { public: @@ -50,9 +53,10 @@ public: virtual ~JavaInstance(); JavaClass* getClass() const; - - bool invokeMethod(const char* name, const NPVariant* args, int argsCount, NPVariant* result); - + // args must be an array of length greater than or equal to the number of + // arguments expected by the method. + JavaValue invokeMethod(const JavaMethod*, JavaValue* args); + JavaValue getField(const JavaField*); jobject javaInstance() const { return m_instance->m_instance; } // These functions are called before and after the main entry points into diff --git a/Source/WebCore/bridge/jni/v8/JavaNPObjectV8.cpp b/Source/WebCore/bridge/jni/v8/JavaNPObjectV8.cpp index 7a7adc5..b02d059 100644 --- a/Source/WebCore/bridge/jni/v8/JavaNPObjectV8.cpp +++ b/Source/WebCore/bridge/jni/v8/JavaNPObjectV8.cpp @@ -33,6 +33,8 @@ #include "JavaClassV8.h" #include "JavaFieldV8.h" #include "JavaInstanceV8.h" +#include "JavaMethod.h" +#include "JavaValueV8.h" #include "npruntime_impl.h" namespace JSC { @@ -115,12 +117,40 @@ bool JavaNPObjectInvoke(NPObject* obj, NPIdentifier identifier, const NPVariant* return false; instance->begin(); - bool r = instance->invokeMethod(name, args, argCount, result); - instance->end(); + MethodList methodList = instance->getClass()->methodsNamed(name); // TODO: use NPN_MemFree free(name); - return r; + + // Try to find a good match for the overloaded method. The + // fundamental problem is that JavaScript doesn't have the + // notion of method overloading and Java does. We could + // get a bit more sophisticated and attempt to do some + // type checking as well as checking the number of parameters. + size_t numMethods = methodList.size(); + JavaMethod* aMethod; + JavaMethod* jMethod = 0; + for (size_t methodIndex = 0; methodIndex < numMethods; methodIndex++) { + aMethod = methodList[methodIndex]; + if (aMethod->numParameters() == static_cast<int>(argCount)) { + jMethod = aMethod; + break; + } + } + if (!jMethod) + return false; + + JavaValue* jArgs = new JavaValue[argCount]; + for (unsigned int i = 0; i < argCount; i++) + jArgs[i] = convertNPVariantToJavaValue(args[i], jMethod->parameterAt(i)); + + JavaValue jResult = instance->invokeMethod(jMethod, jArgs); + instance->end(); + delete[] jArgs; + + VOID_TO_NPVARIANT(*result); + convertJavaValueToNPVariant(jResult, result); + return true; } bool JavaNPObjectHasProperty(NPObject* obj, NPIdentifier identifier) @@ -150,12 +180,11 @@ bool JavaNPObjectGetProperty(NPObject* obj, NPIdentifier identifier, NPVariant* instance->begin(); JavaField* field = instance->getClass()->fieldNamed(name); - instance->end(); free(name); // TODO: use NPN_MemFree - if (!field) return false; +<<<<<<< HEAD #if PLATFORM(ANDROID) // JSC does not seem to support returning object properties so we emulate that // behaviour here. @@ -167,6 +196,12 @@ bool JavaNPObjectGetProperty(NPObject* obj, NPIdentifier identifier, NPVariant* field->type()); #endif // PLATFORM(ANDROID) convertJValueToNPVariant(value, field->getJNIType(), field->type(), result); +======= + JavaValue value = instance->getField(field); + instance->end(); + + convertJavaValueToNPVariant(value, result); +>>>>>>> webkit.org at r82507 return true; } diff --git a/Source/WebCore/bridge/jni/v8/JavaValueV8.h b/Source/WebCore/bridge/jni/v8/JavaValueV8.h new file mode 100644 index 0000000..3e1c623 --- /dev/null +++ b/Source/WebCore/bridge/jni/v8/JavaValueV8.h @@ -0,0 +1,75 @@ +/* + * Copyright 2011, The Android Open Source Project + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef JavaValueV8_h +#define JavaValueV8_h + +#if ENABLE(JAVA_BRIDGE) + +#include "JavaType.h" + +#include <wtf/text/WTFString.h> + +namespace JSC { + +namespace Bindings { + +class JavaInstance; + +// A variant used to represent a Java value, almost identical to the JNI +// jvalue type. It exists because the logic to convert between JavaScript +// objects (as JavaNPObject or JSValue) and Java objects should not depend upon +// JNI, to allow ports to provide a JavaInstance object etc which does not use +// JNI. This means that the 'object' field of this variant uses JavaInstance, +// not jobject. +// +// Note that this class is independent of the JavaScript engine, but is +// currently used only with V8. +// See https://bugs.webkit.org/show_bug.cgi?id=57023. +struct JavaValue { + JavaValue() : m_type(JavaTypeInvalid) {} + + JavaType m_type; + // We don't use a union because we want to be able to ref-count some of the + // values. This requires types with non-trivial constructors. + RefPtr<JavaInstance> m_objectValue; + bool m_booleanValue; + signed char m_byteValue; + unsigned short m_charValue; + short m_shortValue; + int m_intValue; + long long m_longValue; + float m_floatValue; + double m_doubleValue; + String m_stringValue; +}; + +} // namespace Bindings + +} // namespace JSC + +#endif // ENABLE(JAVA_BRIDGE) + +#endif // JavaValueV8_h diff --git a/Source/WebCore/bridge/objc/ObjCRuntimeObject.h b/Source/WebCore/bridge/objc/ObjCRuntimeObject.h index e9fa10d..b29a333 100644 --- a/Source/WebCore/bridge/objc/ObjCRuntimeObject.h +++ b/Source/WebCore/bridge/objc/ObjCRuntimeObject.h @@ -42,9 +42,9 @@ public: static const ClassInfo s_info; - static PassRefPtr<Structure> createStructure(JSValue prototype) + static PassRefPtr<Structure> createStructure(JSGlobalData& globalData, JSValue prototype) { - return Structure::create(prototype, TypeInfo(ObjectType, StructureFlags), AnonymousSlotCount, &s_info); + return Structure::create(globalData, prototype, TypeInfo(ObjectType, StructureFlags), AnonymousSlotCount, &s_info); } }; diff --git a/Source/WebCore/bridge/objc/objc_instance.mm b/Source/WebCore/bridge/objc/objc_instance.mm index e0b18f1..4f93cfa 100644 --- a/Source/WebCore/bridge/objc/objc_instance.mm +++ b/Source/WebCore/bridge/objc/objc_instance.mm @@ -184,9 +184,9 @@ public: ASSERT(inherits(&s_info)); } - static PassRefPtr<Structure> createStructure(JSValue prototype) + static PassRefPtr<Structure> createStructure(JSGlobalData& globalData, JSValue prototype) { - return Structure::create(prototype, TypeInfo(ObjectType, StructureFlags), AnonymousSlotCount, &s_info); + return Structure::create(globalData, prototype, TypeInfo(ObjectType, StructureFlags), AnonymousSlotCount, &s_info); } static const ClassInfo s_info; diff --git a/Source/WebCore/bridge/objc/objc_runtime.h b/Source/WebCore/bridge/objc/objc_runtime.h index 1cee85b..4ef0afd 100644 --- a/Source/WebCore/bridge/objc/objc_runtime.h +++ b/Source/WebCore/bridge/objc/objc_runtime.h @@ -103,9 +103,9 @@ public: return globalObject->objectPrototype(); } - static PassRefPtr<Structure> createStructure(JSValue prototype) + static PassRefPtr<Structure> createStructure(JSGlobalData& globalData, JSValue prototype) { - return Structure::create(prototype, TypeInfo(ObjectType, StructureFlags), AnonymousSlotCount, &s_info); + return Structure::create(globalData, prototype, TypeInfo(ObjectType, StructureFlags), AnonymousSlotCount, &s_info); } private: diff --git a/Source/WebCore/bridge/qt/qt_instance.cpp b/Source/WebCore/bridge/qt/qt_instance.cpp index 7af752d..91ae40f 100644 --- a/Source/WebCore/bridge/qt/qt_instance.cpp +++ b/Source/WebCore/bridge/qt/qt_instance.cpp @@ -59,9 +59,9 @@ public: instance->markAggregate(markStack); } - static PassRefPtr<Structure> createStructure(JSValue prototype) + static PassRefPtr<Structure> createStructure(JSGlobalData& globalData, JSValue prototype) { - return Structure::create(prototype, TypeInfo(ObjectType, StructureFlags), AnonymousSlotCount, &s_info); + return Structure::create(globalData, prototype, TypeInfo(ObjectType, StructureFlags), AnonymousSlotCount, &s_info); } protected: diff --git a/Source/WebCore/bridge/qt/qt_pixmapruntime.cpp b/Source/WebCore/bridge/qt/qt_pixmapruntime.cpp index 534e28e..da3e383 100644 --- a/Source/WebCore/bridge/qt/qt_pixmapruntime.cpp +++ b/Source/WebCore/bridge/qt/qt_pixmapruntime.cpp @@ -119,7 +119,7 @@ public: QByteArray byteArray; QBuffer buffer(&byteArray); instance->toImage().save(&buffer, "PNG"); - const QString encodedString = QString("data:image/png;base64,") + byteArray.toBase64(); + const QString encodedString = QLatin1String("data:image/png;base64,") + QLatin1String(byteArray.toBase64()); const UString ustring((UChar*)encodedString.utf16(), encodedString.length()); return jsString(exec, ustring); } @@ -150,9 +150,9 @@ public: static const ClassInfo s_info; - static PassRefPtr<Structure> createStructure(JSValue prototype) + static PassRefPtr<Structure> createStructure(JSGlobalData& globalData, JSValue prototype) { - return Structure::create(prototype, TypeInfo(ObjectType, StructureFlags), AnonymousSlotCount, &s_info); + return Structure::create(globalData, prototype, TypeInfo(ObjectType, StructureFlags), AnonymousSlotCount, &s_info); } protected: @@ -239,7 +239,7 @@ JSValue QtPixmapInstance::defaultValue(ExecState* exec, PreferredPrimitiveType p JSValue QtPixmapInstance::valueOf(ExecState* exec) const { - const QString stringValue = QString("[Qt Native Pixmap %1,%2]").arg(width()).arg(height()); + const QString stringValue = QString::fromLatin1("[Qt Native Pixmap %1,%2]").arg(width()).arg(height()); UString ustring((UChar*)stringValue.utf16(), stringValue.length()); return jsString(exec, ustring); } diff --git a/Source/WebCore/bridge/qt/qt_runtime.cpp b/Source/WebCore/bridge/qt/qt_runtime.cpp index 78821b9..87ee522 100644 --- a/Source/WebCore/bridge/qt/qt_runtime.cpp +++ b/Source/WebCore/bridge/qt/qt_runtime.cpp @@ -845,17 +845,13 @@ JSValue convertQVariantToValue(ExecState* exec, PassRefPtr<RootObject> root, con QRegExp re = variant.value<QRegExp>(); if (re.isValid()) { - UString uflags; - if (re.caseSensitivity() == Qt::CaseInsensitive) - uflags = "i"; // ### Can't do g or m - UString pattern((UChar*)re.pattern().utf16(), re.pattern().length()); + RegExpFlags flags = (re.caseSensitivity() == Qt::CaseInsensitive) ? FlagIgnoreCase : NoFlags; - RefPtr<JSC::RegExp> regExp = JSC::RegExp::create(&exec->globalData(), pattern, uflags); + RefPtr<JSC::RegExp> regExp = JSC::RegExp::create(&exec->globalData(), pattern, flags); if (regExp->isValid()) return new (exec) RegExpObject(exec->lexicalGlobalObject(), exec->lexicalGlobalObject()->regExpStructure(), regExp.release()); - else - return jsNull(); + return jsNull(); } } @@ -887,14 +883,14 @@ JSValue convertQVariantToValue(ExecState* exec, PassRefPtr<RootObject> root, con dt.isDST = -1; double ms = gregorianDateTimeToMS(exec, dt, time.msec(), /*inputIsUTC*/ false); - return new (exec) DateInstance(exec, trunc(ms)); + return new (exec) DateInstance(exec, exec->lexicalGlobalObject()->dateStructure(), trunc(ms)); } if (type == QMetaType::QByteArray) { QByteArray qtByteArray = variant.value<QByteArray>(); WTF::RefPtr<WTF::ByteArray> wtfByteArray = WTF::ByteArray::create(qtByteArray.length()); memcpy(wtfByteArray->data(), qtByteArray.constData(), qtByteArray.length()); - return new (exec) JSC::JSByteArray(exec, JSC::JSByteArray::createStructure(jsNull()), wtfByteArray.get()); + return new (exec) JSC::JSByteArray(exec, JSC::JSByteArray::createStructure(exec->globalData(), jsNull()), wtfByteArray.get()); } if (type == QMetaType::QObjectStar || type == QMetaType::QWidgetStar) { @@ -1832,7 +1828,7 @@ void QtConnectionObject::execute(void **argv) fimp = static_cast<JSFunction*>(m_funcObject.get()); JSObject* qt_sender = QtInstance::getQtInstance(sender(), ro, QScriptEngine::QtOwnership)->createRuntimeObject(exec); - JSObject* wrapper = constructEmptyObject(exec, createEmptyObjectStructure(jsNull())); + JSObject* wrapper = constructEmptyObject(exec, createEmptyObjectStructure(exec->globalData(), jsNull())); PutPropertySlot slot; wrapper->put(exec, Identifier(exec, "__qt_sender__"), qt_sender, slot); oldsc = fimp->scope(); diff --git a/Source/WebCore/bridge/qt/qt_runtime.h b/Source/WebCore/bridge/qt/qt_runtime.h index b86ccbe..85b34b8 100644 --- a/Source/WebCore/bridge/qt/qt_runtime.h +++ b/Source/WebCore/bridge/qt/qt_runtime.h @@ -153,9 +153,9 @@ public: return globalObject->functionPrototype(); } - static PassRefPtr<Structure> createStructure(JSValue prototype) + static PassRefPtr<Structure> createStructure(JSGlobalData& globalData, JSValue prototype) { - return Structure::create(prototype, TypeInfo(ObjectType, StructureFlags), AnonymousSlotCount, &s_info); + return Structure::create(globalData, prototype, TypeInfo(ObjectType, StructureFlags), AnonymousSlotCount, &s_info); } protected: diff --git a/Source/WebCore/bridge/runtime_array.h b/Source/WebCore/bridge/runtime_array.h index f4c74e2..9555545 100644 --- a/Source/WebCore/bridge/runtime_array.h +++ b/Source/WebCore/bridge/runtime_array.h @@ -33,6 +33,7 @@ namespace JSC { class RuntimeArray : public JSArray { public: + typedef Bindings::Array BindingsArray; RuntimeArray(ExecState*, Bindings::Array*); virtual ~RuntimeArray(); @@ -48,7 +49,7 @@ public: unsigned getLength() const { return getConcreteArray()->getLength(); } - Bindings::Array* getConcreteArray() const { return static_cast<Bindings::Array*>(subclassData()); } + Bindings::Array* getConcreteArray() const { return static_cast<BindingsArray*>(subclassData()); } static const ClassInfo s_info; @@ -57,9 +58,9 @@ public: return globalObject->arrayPrototype(); } - static PassRefPtr<Structure> createStructure(JSValue prototype) + static PassRefPtr<Structure> createStructure(JSGlobalData& globalData, JSValue prototype) { - return Structure::create(prototype, TypeInfo(ObjectType, StructureFlags), AnonymousSlotCount, &s_info); + return Structure::create(globalData, prototype, TypeInfo(ObjectType, StructureFlags), AnonymousSlotCount, &s_info); } protected: diff --git a/Source/WebCore/bridge/runtime_method.h b/Source/WebCore/bridge/runtime_method.h index c0c9f16..9df796e 100644 --- a/Source/WebCore/bridge/runtime_method.h +++ b/Source/WebCore/bridge/runtime_method.h @@ -45,9 +45,9 @@ public: return globalObject->functionPrototype(); } - static PassRefPtr<Structure> createStructure(JSValue prototype) + static PassRefPtr<Structure> createStructure(JSGlobalData& globalData, JSValue prototype) { - return Structure::create(prototype, TypeInfo(ObjectType, StructureFlags), AnonymousSlotCount, &s_info); + return Structure::create(globalData, prototype, TypeInfo(ObjectType, StructureFlags), AnonymousSlotCount, &s_info); } protected: diff --git a/Source/WebCore/bridge/runtime_object.h b/Source/WebCore/bridge/runtime_object.h index 0decd17..bb6d051 100644 --- a/Source/WebCore/bridge/runtime_object.h +++ b/Source/WebCore/bridge/runtime_object.h @@ -61,9 +61,9 @@ public: return globalObject->objectPrototype(); } - static PassRefPtr<Structure> createStructure(JSValue prototype) + static PassRefPtr<Structure> createStructure(JSGlobalData& globalData, JSValue prototype) { - return Structure::create(prototype, TypeInfo(ObjectType, StructureFlags), AnonymousSlotCount, &s_info); + return Structure::create(globalData, prototype, TypeInfo(ObjectType, StructureFlags), AnonymousSlotCount, &s_info); } protected: |