[SCM] WebKit Debian packaging branch, webkit-1.1, updated. upstream/1.1.19-706-ge5415e9
steveblock at google.com
steveblock at google.com
Thu Feb 4 21:23:07 UTC 2010
The following commit has been merged in the webkit-1.1 branch:
commit 0f21ce6aecac18d2a9b9005f96d5160295ba4425
Author: steveblock at google.com <steveblock at google.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Date: Thu Jan 21 10:25:29 2010 +0000
Fixes style in WebCore/bridge/jni/JNIBridge
https://bugs.webkit.org/show_bug.cgi?id=33914
Reviewed by David Levin.
No new tests, style fixes only.
* bridge/jni/JNIBridge.cpp:
* bridge/jni/JNIBridge.h:
git-svn-id: http://svn.webkit.org/repository/webkit/trunk@53619 268f45cc-cd09-0410-ab3c-d52691b4dbfc
diff --git a/WebCore/ChangeLog b/WebCore/ChangeLog
index 2eca751..08969f2 100644
--- a/WebCore/ChangeLog
+++ b/WebCore/ChangeLog
@@ -1,3 +1,15 @@
+2010-01-21 Steve Block <steveblock at google.com>
+
+ Reviewed by David Levin.
+
+ Fixes style in WebCore/bridge/jni/JNIBridge
+ https://bugs.webkit.org/show_bug.cgi?id=33914
+
+ No new tests, style fixes only.
+
+ * bridge/jni/JNIBridge.cpp:
+ * bridge/jni/JNIBridge.h:
+
2010-01-13 Philippe Normand <pnormand at igalia.com>
Reviewed by Oliver Hunt.
diff --git a/WebCore/bridge/jni/JNIBridge.cpp b/WebCore/bridge/jni/JNIBridge.cpp
index 042e8dc..627d227 100644
--- a/WebCore/bridge/jni/JNIBridge.cpp
+++ b/WebCore/bridge/jni/JNIBridge.cpp
@@ -1,5 +1,6 @@
/*
- * Copyright (C) 2003 Apple Computer, Inc. All rights reserved.
+ * Copyright (C) 2003, 2004, 2005, 2007, 2009 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
@@ -20,7 +21,7 @@
* 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.
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "config.h"
@@ -42,7 +43,7 @@
#define JS_LOG(formatAndArgs...) ((void)0)
#else
#define JS_LOG(formatAndArgs...) { \
- fprintf (stderr, "%s:%d -- %s: ", __FILE__, __LINE__, __FUNCTION__); \
+ fprintf(stderr, "%s:%d -- %s: ", __FILE__, __LINE__, __FUNCTION__); \
fprintf(stderr, formatAndArgs); \
}
#endif
@@ -52,25 +53,25 @@ using namespace JSC::Bindings;
using namespace WebCore;
-JavaParameter::JavaParameter (JNIEnv *env, jstring type)
+JavaParameter::JavaParameter(JNIEnv* env, jstring type)
{
- _type = JavaString (env, type);
- _JNIType = JNITypeFromClassName (_type.UTF8String());
+ m_type = JavaString(env, type);
+ m_JNIType = JNITypeFromClassName(m_type.UTF8String());
}
-JavaField::JavaField (JNIEnv *env, jobject aField)
+JavaField::JavaField(JNIEnv* env, jobject aField)
{
// Get field type
jobject fieldType = callJNIMethod<jobject>(aField, "getType", "()Ljava/lang/Class;");
- jstring fieldTypeName = (jstring)callJNIMethod<jobject>(fieldType, "getName", "()Ljava/lang/String;");
- _type = JavaString(env, fieldTypeName);
- _JNIType = JNITypeFromClassName (_type.UTF8String());
+ jstring fieldTypeName = static_cast<jstring>(callJNIMethod<jobject>(fieldType, "getName", "()Ljava/lang/String;"));
+ m_type = JavaString(env, fieldTypeName);
+ m_JNIType = JNITypeFromClassName(m_type.UTF8String());
// Get field name
- jstring fieldName = (jstring)callJNIMethod<jobject>(aField, "getName", "()Ljava/lang/String;");
- _name = JavaString(env, fieldName);
+ jstring fieldName = static_cast<jstring>(callJNIMethod<jobject>(aField, "getName", "()Ljava/lang/String;"));
+ m_name = JavaString(env, fieldName);
- _field = new JObjectWrapper(aField);
+ m_field = new JObjectWrapper(aField);
}
JSValue JavaArray::convertJObjectToArray(ExecState* exec, jobject anObject, const char* type, PassRefPtr<RootObject> rootObject)
@@ -78,27 +79,26 @@ JSValue JavaArray::convertJObjectToArray(ExecState* exec, jobject anObject, cons
if (type[0] != '[')
return jsUndefined();
- return new (exec) RuntimeArray(exec, new JavaArray((jobject)anObject, type, rootObject));
+ return new (exec) RuntimeArray(exec, new JavaArray(anObject, type, rootObject));
}
-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, JNIType returnType) const
{
jobject jinstance = instance->javaInstance();
- jobject fieldJInstance = _field->m_instance;
- JNIEnv *env = getJNIEnv();
+ jobject fieldJInstance = m_field->m_instance;
+ JNIEnv* env = getJNIEnv();
jvalue result;
- bzero (&result, sizeof(jvalue));
+ bzero(&result, sizeof(jvalue));
jclass cls = env->GetObjectClass(fieldJInstance);
- if ( cls != NULL ) {
+ if (cls) {
jmethodID mid = env->GetMethodID(cls, name, sig);
- if ( mid != NULL )
- {
+ if (mid) {
RootObject* rootObject = instance->rootObject();
if (rootObject && rootObject->nativeHandle()) {
JSValue exceptionDescription;
jvalue args[1];
-
+
args[0].l = jinstance;
dispatchJNICall(exec, rootObject->nativeHandle(), fieldJInstance, false, returnType, mid, args, result, 0, exceptionDescription);
if (exceptionDescription)
@@ -109,79 +109,79 @@ jvalue JavaField::dispatchValueFromInstance(ExecState *exec, const JavaInstance
return result;
}
-JSValue JavaField::valueFromInstance(ExecState* exec, const Instance* i) const
+JSValue JavaField::valueFromInstance(ExecState* exec, const Instance* i) const
{
- const JavaInstance *instance = static_cast<const JavaInstance *>(i);
+ const JavaInstance* instance = static_cast<const JavaInstance*>(i);
JSValue jsresult = jsUndefined();
-
- switch (_JNIType) {
- case array_type:
- case object_type: {
- jvalue result = dispatchValueFromInstance (exec, instance, "get", "(Ljava/lang/Object;)Ljava/lang/Object;", object_type);
+
+ switch (m_JNIType) {
+ case array_type:
+ case object_type:
+ {
+ jvalue result = dispatchValueFromInstance(exec, instance, "get", "(Ljava/lang/Object;)Ljava/lang/Object;", object_type);
jobject anObject = result.l;
- const char *arrayType = type();
- if (arrayType[0] == '[') {
+ const char* arrayType = type();
+ if (arrayType[0] == '[')
jsresult = JavaArray::convertJObjectToArray(exec, anObject, arrayType, instance->rootObject());
- }
- else if (anObject != 0){
+ else if (anObject)
jsresult = JavaInstance::create(anObject, instance->rootObject())->createRuntimeObject(exec);
- }
}
break;
-
- case boolean_type:
- jsresult = jsBoolean(dispatchValueFromInstance(exec, instance, "getBoolean", "(Ljava/lang/Object;)Z", boolean_type).z);
- break;
-
- case byte_type:
- case char_type:
- case short_type:
-
- case int_type: {
+
+ case boolean_type:
+ jsresult = jsBoolean(dispatchValueFromInstance(exec, instance, "getBoolean", "(Ljava/lang/Object;)Z", boolean_type).z);
+ break;
+
+ case byte_type:
+ case char_type:
+ case short_type:
+
+ case int_type:
+ {
jint value;
- jvalue result = dispatchValueFromInstance (exec, instance, "getInt", "(Ljava/lang/Object;)I", int_type);
+ jvalue result = dispatchValueFromInstance(exec, instance, "getInt", "(Ljava/lang/Object;)I", int_type);
value = result.i;
- jsresult = jsNumber(exec, (int)value);
+ jsresult = jsNumber(exec, static_cast<int>(value));
}
break;
- case long_type:
- case float_type:
- case double_type: {
+ case long_type:
+ case float_type:
+ case double_type:
+ {
jdouble value;
- jvalue result = dispatchValueFromInstance (exec, instance, "getDouble", "(Ljava/lang/Object;)D", double_type);
+ jvalue result = dispatchValueFromInstance(exec, instance, "getDouble", "(Ljava/lang/Object;)D", double_type);
value = result.i;
- jsresult = jsNumber(exec, (double)value);
+ jsresult = jsNumber(exec, static_cast<double>(value));
}
break;
- default:
+ default:
break;
}
- JS_LOG ("getting %s = %s\n", UString(name()).UTF8String().c_str(), jsresult.toString(exec).ascii());
-
+ JS_LOG("getting %s = %s\n", UString(name()).UTF8String().c_str(), jsresult.toString(exec).ascii());
+
return jsresult;
}
-void JavaField::dispatchSetValueToInstance(ExecState *exec, const JavaInstance *instance, jvalue javaValue, const char *name, const char *sig) const
+void JavaField::dispatchSetValueToInstance(ExecState* exec, const JavaInstance* instance, jvalue javaValue, const char* name, const char* sig) const
{
jobject jinstance = instance->javaInstance();
- jobject fieldJInstance = _field->m_instance;
- JNIEnv *env = getJNIEnv();
+ jobject fieldJInstance = m_field->m_instance;
+ JNIEnv* env = getJNIEnv();
jclass cls = env->GetObjectClass(fieldJInstance);
- if ( cls != NULL ) {
+ if (cls) {
jmethodID mid = env->GetMethodID(cls, name, sig);
- if ( mid != NULL )
- {
+ if (mid) {
RootObject* rootObject = instance->rootObject();
if (rootObject && rootObject->nativeHandle()) {
JSValue exceptionDescription;
jvalue args[2];
jvalue result;
-
+
args[0].l = jinstance;
args[1] = javaValue;
dispatchJNICall(exec, rootObject->nativeHandle(), fieldJInstance, false, void_type, mid, args, result, 0, exceptionDescription);
@@ -194,107 +194,115 @@ 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, aValue, _JNIType, type());
+ const JavaInstance* instance = static_cast<const JavaInstance*>(i);
+ jvalue javaValue = convertValueToJValue(exec, aValue, m_JNIType, type());
- JS_LOG ("setting value %s to %s\n", UString(name()).UTF8String().c_str(), aValue.toString(exec).ascii());
+ JS_LOG("setting value %s to %s\n", UString(name()).UTF8String().c_str(), aValue.toString(exec).ascii());
- switch (_JNIType) {
- case array_type:
- case object_type: {
- dispatchSetValueToInstance (exec, instance, javaValue, "set", "(Ljava/lang/Object;Ljava/lang/Object;)V");
+ switch (m_JNIType) {
+ case array_type:
+ case object_type:
+ {
+ dispatchSetValueToInstance(exec, instance, javaValue, "set", "(Ljava/lang/Object;Ljava/lang/Object;)V");
}
break;
-
- case boolean_type: {
- dispatchSetValueToInstance (exec, instance, javaValue, "setBoolean", "(Ljava/lang/Object;Z)V");
+
+ case boolean_type:
+ {
+ dispatchSetValueToInstance(exec, instance, javaValue, "setBoolean", "(Ljava/lang/Object;Z)V");
}
break;
-
- case byte_type: {
- dispatchSetValueToInstance (exec, instance, javaValue, "setByte", "(Ljava/lang/Object;B)V");
+
+ case byte_type:
+ {
+ dispatchSetValueToInstance(exec, instance, javaValue, "setByte", "(Ljava/lang/Object;B)V");
}
break;
- case char_type: {
- dispatchSetValueToInstance (exec, instance, javaValue, "setChar", "(Ljava/lang/Object;C)V");
+ case char_type:
+ {
+ dispatchSetValueToInstance(exec, instance, javaValue, "setChar", "(Ljava/lang/Object;C)V");
}
break;
- case short_type: {
- dispatchSetValueToInstance (exec, instance, javaValue, "setShort", "(Ljava/lang/Object;S)V");
+ case short_type:
+ {
+ dispatchSetValueToInstance(exec, instance, javaValue, "setShort", "(Ljava/lang/Object;S)V");
}
break;
- case int_type: {
- dispatchSetValueToInstance (exec, instance, javaValue, "setInt", "(Ljava/lang/Object;I)V");
+ case int_type:
+ {
+ dispatchSetValueToInstance(exec, instance, javaValue, "setInt", "(Ljava/lang/Object;I)V");
}
break;
- case long_type: {
- dispatchSetValueToInstance (exec, instance, javaValue, "setLong", "(Ljava/lang/Object;J)V");
+ case long_type:
+ {
+ dispatchSetValueToInstance(exec, instance, javaValue, "setLong", "(Ljava/lang/Object;J)V");
}
break;
- case float_type: {
- dispatchSetValueToInstance (exec, instance, javaValue, "setFloat", "(Ljava/lang/Object;F)V");
+ case float_type:
+ {
+ dispatchSetValueToInstance(exec, instance, javaValue, "setFloat", "(Ljava/lang/Object;F)V");
}
break;
- case double_type: {
- dispatchSetValueToInstance (exec, instance, javaValue, "setDouble", "(Ljava/lang/Object;D)V");
+ case double_type:
+ {
+ dispatchSetValueToInstance(exec, instance, javaValue, "setDouble", "(Ljava/lang/Object;D)V");
}
break;
- default:
+ default:
break;
}
}
-JavaMethod::JavaMethod (JNIEnv *env, jobject aMethod)
+JavaMethod::JavaMethod(JNIEnv* env, jobject aMethod)
{
// Get return type
jobject returnType = callJNIMethod<jobject>(aMethod, "getReturnType", "()Ljava/lang/Class;");
- jstring returnTypeName = (jstring)callJNIMethod<jobject>(returnType, "getName", "()Ljava/lang/String;");
- _returnType =JavaString (env, returnTypeName);
- _JNIReturnType = JNITypeFromClassName (_returnType.UTF8String());
- env->DeleteLocalRef (returnType);
- env->DeleteLocalRef (returnTypeName);
+ jstring returnTypeName = static_cast<jstring>(callJNIMethod<jobject>(returnType, "getName", "()Ljava/lang/String;"));
+ m_returnType = JavaString(env, returnTypeName);
+ m_JNIReturnType = JNITypeFromClassName(m_returnType.UTF8String());
+ env->DeleteLocalRef(returnType);
+ env->DeleteLocalRef(returnTypeName);
// Get method name
- jstring methodName = (jstring)callJNIMethod<jobject>(aMethod, "getName", "()Ljava/lang/String;");
- _name = JavaString (env, methodName);
- env->DeleteLocalRef (methodName);
+ jstring methodName = static_cast<jstring>(callJNIMethod<jobject>(aMethod, "getName", "()Ljava/lang/String;"));
+ m_name = JavaString(env, methodName);
+ env->DeleteLocalRef(methodName);
// Get parameters
- jarray jparameters = (jarray)callJNIMethod<jobject>(aMethod, "getParameterTypes", "()[Ljava/lang/Class;");
- _numParameters = env->GetArrayLength (jparameters);
- _parameters = new JavaParameter[_numParameters];
-
- int i;
- for (i = 0; i < _numParameters; i++) {
- jobject aParameter = env->GetObjectArrayElement ((jobjectArray)jparameters, i);
- jstring parameterName = (jstring)callJNIMethod<jobject>(aParameter, "getName", "()Ljava/lang/String;");
- _parameters[i] = JavaParameter(env, parameterName);
- env->DeleteLocalRef (aParameter);
- env->DeleteLocalRef (parameterName);
+ jarray jparameters = static_cast<jarray>(callJNIMethod<jobject>(aMethod, "getParameterTypes", "()[Ljava/lang/Class;"));
+ m_numParameters = env->GetArrayLength(jparameters);
+ m_parameters = new JavaParameter[m_numParameters];
+
+ for (int i = 0; i < m_numParameters; i++) {
+ jobject aParameter = env->GetObjectArrayElement(static_cast<jobjectArray>(jparameters), i);
+ jstring parameterName = static_cast<jstring>(callJNIMethod<jobject>(aParameter, "getName", "()Ljava/lang/String;"));
+ m_parameters[i] = JavaParameter(env, parameterName);
+ env->DeleteLocalRef(aParameter);
+ env->DeleteLocalRef(parameterName);
}
- env->DeleteLocalRef (jparameters);
+ env->DeleteLocalRef(jparameters);
// Created lazily.
- _signature = 0;
- _methodID = 0;
-
+ m_signature = 0;
+ m_methodID = 0;
+
jclass modifierClass = env->FindClass("java/lang/reflect/Modifier");
int modifiers = callJNIMethod<jint>(aMethod, "getModifiers", "()I");
- _isStatic = (bool)callJNIStaticMethod<jboolean>(modifierClass, "isStatic", "(I)Z", modifiers);
+ m_isStatic = static_cast<bool>(callJNIStaticMethod<jboolean>(modifierClass, "isStatic", "(I)Z", modifiers));
env->DeleteLocalRef(modifierClass);
}
-JavaMethod::~JavaMethod()
+JavaMethod::~JavaMethod()
{
- if (_signature)
- free(_signature);
- delete [] _parameters;
+ if (m_signature)
+ free(m_signature);
+ delete[] m_parameters;
};
// JNI method signatures use '/' between components of a class name, but
@@ -302,244 +310,259 @@ JavaMethod::~JavaMethod()
static void appendClassName(StringBuilder& builder, const char* className)
{
ASSERT(JSLock::lockCount() > 0);
-
- char *result, *cp = strdup(className);
-
- result = cp;
- while (*cp) {
- if (*cp == '.')
- *cp = '/';
- cp++;
+
+ char* c = strdup(className);
+
+ char* result = c;
+ while (*c) {
+ if (*c == '.')
+ *c = '/';
+ c++;
}
-
+
builder.append(result);
free(result);
}
-const char *JavaMethod::signature() const
+const char* JavaMethod::signature() const
{
- if (!_signature) {
+ if (!m_signature) {
JSLock lock(SilenceAssertionsOnly);
StringBuilder signatureBuilder;
signatureBuilder.append("(");
- for (int i = 0; i < _numParameters; i++) {
+ for (int i = 0; i < m_numParameters; i++) {
JavaParameter* aParameter = parameterAt(i);
- JNIType _JNIType = aParameter->getJNIType();
- if (_JNIType == array_type)
+ JNIType type = aParameter->getJNIType();
+ if (type == array_type)
appendClassName(signatureBuilder, aParameter->type());
else {
- signatureBuilder.append(signatureFromPrimitiveType(_JNIType));
- if (_JNIType == object_type) {
+ signatureBuilder.append(signatureFromPrimitiveType(type));
+ if (type == object_type) {
appendClassName(signatureBuilder, aParameter->type());
signatureBuilder.append(";");
}
}
}
signatureBuilder.append(")");
-
- const char *returnType = _returnType.UTF8String();
- if (_JNIReturnType == array_type) {
+
+ const char* returnType = m_returnType.UTF8String();
+ if (m_JNIReturnType == array_type)
appendClassName(signatureBuilder, returnType);
- } else {
- signatureBuilder.append(signatureFromPrimitiveType(_JNIReturnType));
- if (_JNIReturnType == object_type) {
+ else {
+ signatureBuilder.append(signatureFromPrimitiveType(m_JNIReturnType));
+ if (m_JNIReturnType == object_type) {
appendClassName(signatureBuilder, returnType);
signatureBuilder.append(";");
}
}
-
+
String signatureString = signatureBuilder.toString();
- _signature = strdup(signatureString.utf8().data());
+ m_signature = strdup(signatureString.utf8().data());
}
-
- return _signature;
+
+ return m_signature;
}
JNIType JavaMethod::JNIReturnType() const
{
- return _JNIReturnType;
+ return m_JNIReturnType;
}
-jmethodID JavaMethod::methodID (jobject obj) const
+jmethodID JavaMethod::methodID(jobject obj) const
{
- if (_methodID == 0) {
- _methodID = getMethodID (obj, _name.UTF8String(), signature());
- }
- return _methodID;
+ if (!m_methodID)
+ m_methodID = getMethodID(obj, m_name.UTF8String(), signature());
+ return m_methodID;
}
JavaArray::JavaArray(jobject array, const char* type, PassRefPtr<RootObject> rootObject)
: Array(rootObject)
{
- _array = new JObjectWrapper(array);
+ m_array = new JObjectWrapper(array);
// Java array are fixed length, so we can cache length.
- JNIEnv *env = getJNIEnv();
- _length = env->GetArrayLength((jarray)_array->m_instance);
- _type = strdup(type);
+ JNIEnv* env = getJNIEnv();
+ m_length = env->GetArrayLength(static_cast<jarray>(m_array->m_instance));
+ m_type = strdup(type);
m_rootObject = rootObject;
}
-JavaArray::~JavaArray ()
+JavaArray::~JavaArray()
{
- free ((void *)_type);
+ free(const_cast<char*>(m_type));
}
-RootObject* JavaArray::rootObject() const
-{
+RootObject* JavaArray::rootObject() const
+{
return m_rootObject && m_rootObject->isValid() ? m_rootObject.get() : 0;
}
void JavaArray::setValueAt(ExecState* exec, unsigned index, JSValue aValue) const
{
- JNIEnv *env = getJNIEnv();
- char *javaClassName = 0;
-
- JNIType arrayType = JNITypeFromPrimitiveType(_type[1]);
- if (_type[1] == 'L'){
+ JNIEnv* env = getJNIEnv();
+ char* javaClassName = 0;
+
+ JNIType arrayType = JNITypeFromPrimitiveType(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
// for extra sanity checks.
- javaClassName = strdup(&_type[2]);
+ javaClassName = strdup(&m_type[2]);
javaClassName[strchr(javaClassName, ';')-javaClassName] = 0;
}
- jvalue aJValue = convertValueToJValue (exec, aValue, arrayType, javaClassName);
-
+ jvalue aJValue = convertValueToJValue(exec, aValue, arrayType, javaClassName);
+
switch (arrayType) {
- case object_type: {
- env->SetObjectArrayElement((jobjectArray)javaArray(), index, aJValue.l);
+ case object_type:
+ {
+ env->SetObjectArrayElement(static_cast<jobjectArray>(javaArray()), index, aJValue.l);
break;
}
-
- case boolean_type: {
- env->SetBooleanArrayRegion((jbooleanArray)javaArray(), index, 1, &aJValue.z);
+
+ case boolean_type:
+ {
+ env->SetBooleanArrayRegion(static_cast<jbooleanArray>(javaArray()), index, 1, &aJValue.z);
break;
}
-
- case byte_type: {
- env->SetByteArrayRegion((jbyteArray)javaArray(), index, 1, &aJValue.b);
+
+ case byte_type:
+ {
+ env->SetByteArrayRegion(static_cast<jbyteArray>(javaArray()), index, 1, &aJValue.b);
break;
}
-
- case char_type: {
- env->SetCharArrayRegion((jcharArray)javaArray(), index, 1, &aJValue.c);
+
+ case char_type:
+ {
+ env->SetCharArrayRegion(static_cast<jcharArray>(javaArray()), index, 1, &aJValue.c);
break;
}
-
- case short_type: {
- env->SetShortArrayRegion((jshortArray)javaArray(), index, 1, &aJValue.s);
+
+ case short_type:
+ {
+ env->SetShortArrayRegion(static_cast<jshortArray>(javaArray()), index, 1, &aJValue.s);
break;
}
-
- case int_type: {
- env->SetIntArrayRegion((jintArray)javaArray(), index, 1, &aJValue.i);
+
+ case int_type:
+ {
+ env->SetIntArrayRegion(static_cast<jintArray>(javaArray()), index, 1, &aJValue.i);
break;
}
-
- case long_type: {
- env->SetLongArrayRegion((jlongArray)javaArray(), index, 1, &aJValue.j);
+
+ case long_type:
+ {
+ env->SetLongArrayRegion(static_cast<jlongArray>(javaArray()), index, 1, &aJValue.j);
}
-
- case float_type: {
- env->SetFloatArrayRegion((jfloatArray)javaArray(), index, 1, &aJValue.f);
+
+ case float_type:
+ {
+ env->SetFloatArrayRegion(static_cast<jfloatArray>(javaArray()), index, 1, &aJValue.f);
break;
}
-
- case double_type: {
- env->SetDoubleArrayRegion((jdoubleArray)javaArray(), index, 1, &aJValue.d);
+
+ case double_type:
+ {
+ env->SetDoubleArrayRegion(static_cast<jdoubleArray>(javaArray()), index, 1, &aJValue.d);
break;
}
- default:
+ default:
break;
}
-
+
if (javaClassName)
- free ((void *)javaClassName);
+ free(const_cast<char*>(javaClassName));
}
JSValue JavaArray::valueAt(ExecState* exec, unsigned index) const
{
- JNIEnv *env = getJNIEnv();
- JNIType arrayType = JNITypeFromPrimitiveType(_type[1]);
+ JNIEnv* env = getJNIEnv();
+ JNIType arrayType = JNITypeFromPrimitiveType(m_type[1]);
switch (arrayType) {
- case object_type: {
- jobjectArray objectArray = (jobjectArray)javaArray();
+ case object_type:
+ {
+ jobjectArray objectArray = static_cast<jobjectArray>(javaArray());
jobject anObject;
anObject = env->GetObjectArrayElement(objectArray, index);
// No object?
- if (!anObject) {
+ if (!anObject)
return jsNull();
- }
-
+
// Nested array?
- if (_type[1] == '[') {
- return JavaArray::convertJObjectToArray(exec, anObject, _type+1, rootObject());
- }
+ if (m_type[1] == '[')
+ return JavaArray::convertJObjectToArray(exec, anObject, m_type + 1, rootObject());
// or array of other object type?
return JavaInstance::create(anObject, rootObject())->createRuntimeObject(exec);
}
-
- case boolean_type: {
- jbooleanArray booleanArray = (jbooleanArray)javaArray();
+
+ case boolean_type:
+ {
+ jbooleanArray booleanArray = static_cast<jbooleanArray>(javaArray());
jboolean aBoolean;
env->GetBooleanArrayRegion(booleanArray, index, 1, &aBoolean);
return jsBoolean(aBoolean);
}
-
- case byte_type: {
- jbyteArray byteArray = (jbyteArray)javaArray();
+
+ case byte_type:
+ {
+ jbyteArray byteArray = static_cast<jbyteArray>(javaArray());
jbyte aByte;
env->GetByteArrayRegion(byteArray, index, 1, &aByte);
return jsNumber(exec, aByte);
}
-
- case char_type: {
- jcharArray charArray = (jcharArray)javaArray();
+
+ case char_type:
+ {
+ jcharArray charArray = static_cast<jcharArray>(javaArray());
jchar aChar;
env->GetCharArrayRegion(charArray, index, 1, &aChar);
return jsNumber(exec, aChar);
break;
}
-
- case short_type: {
- jshortArray shortArray = (jshortArray)javaArray();
+
+ case short_type:
+ {
+ jshortArray shortArray = static_cast<jshortArray>(javaArray());
jshort aShort;
env->GetShortArrayRegion(shortArray, index, 1, &aShort);
return jsNumber(exec, aShort);
}
-
- case int_type: {
- jintArray intArray = (jintArray)javaArray();
+
+ case int_type:
+ {
+ jintArray intArray = static_cast<jintArray>(javaArray());
jint anInt;
env->GetIntArrayRegion(intArray, index, 1, &anInt);
return jsNumber(exec, anInt);
}
-
- case long_type: {
- jlongArray longArray = (jlongArray)javaArray();
+
+ case long_type:
+ {
+ jlongArray longArray = static_cast<jlongArray>(javaArray());
jlong aLong;
env->GetLongArrayRegion(longArray, index, 1, &aLong);
return jsNumber(exec, aLong);
}
-
- case float_type: {
- jfloatArray floatArray = (jfloatArray)javaArray();
+
+ case float_type:
+ {
+ jfloatArray floatArray = static_cast<jfloatArray>(javaArray());
jfloat aFloat;
env->GetFloatArrayRegion(floatArray, index, 1, &aFloat);
return jsNumber(exec, aFloat);
}
-
- case double_type: {
- jdoubleArray doubleArray = (jdoubleArray)javaArray();
+
+ case double_type:
+ {
+ jdoubleArray doubleArray = static_cast<jdoubleArray>(javaArray());
jdouble aDouble;
env->GetDoubleArrayRegion(doubleArray, index, 1, &aDouble);
return jsNumber(exec, aDouble);
}
- default:
+ default:
break;
}
return jsUndefined();
@@ -547,7 +570,7 @@ JSValue JavaArray::valueAt(ExecState* exec, unsigned index) const
unsigned int JavaArray::getLength() const
{
- return _length;
+ return m_length;
}
#endif // ENABLE(MAC_JAVA_BRIDGE)
diff --git a/WebCore/bridge/jni/JNIBridge.h b/WebCore/bridge/jni/JNIBridge.h
index f3942c5..ce129af 100644
--- a/WebCore/bridge/jni/JNIBridge.h
+++ b/WebCore/bridge/jni/JNIBridge.h
@@ -1,5 +1,6 @@
/*
- * Copyright (C) 2003 Apple Computer, Inc. All rights reserved.
+ * 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
@@ -20,7 +21,7 @@
* 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.
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef JNIBridge_h
@@ -35,16 +36,13 @@
#include "JavaStringJSC.h"
#endif
-namespace JSC
-{
+namespace JSC {
-namespace Bindings
-{
+namespace Bindings {
typedef const char* RuntimeType;
-class JavaString
-{
+class JavaString {
public:
JavaString()
{
@@ -72,95 +70,91 @@ private:
JavaStringImpl m_impl;
};
-class JavaParameter
-{
+class JavaParameter {
public:
- JavaParameter () : _JNIType(invalid_type) {};
- JavaParameter (JNIEnv *env, jstring type);
+ JavaParameter() : m_JNIType(invalid_type) { }
+ JavaParameter(JNIEnv*, jstring type);
virtual ~JavaParameter() { }
- RuntimeType type() const { return _type.UTF8String(); }
- JNIType getJNIType() const { return _JNIType; }
-
+ RuntimeType type() const { return m_type.UTF8String(); }
+ JNIType getJNIType() const { return m_JNIType; }
+
private:
- JavaString _type;
- JNIType _JNIType;
+ JavaString m_type;
+ JNIType m_JNIType;
};
-class JavaField : public Field
-{
+class JavaField : public Field {
public:
- JavaField (JNIEnv *env, jobject aField);
+ JavaField(JNIEnv*, jobject aField);
+
+ virtual JSValue valueFromInstance(ExecState*, const Instance*) const;
+ virtual void setValueToInstance(ExecState*, const Instance*, JSValue) const;
+
+ const JavaString& name() const { return m_name; }
+ virtual RuntimeType type() const { return m_type.UTF8String(); }
- virtual JSValue valueFromInstance(ExecState *exec, const Instance *instance) const;
- virtual void setValueToInstance(ExecState *exec, const Instance *instance, JSValue aValue) const;
-
- const JavaString& name() const { return _name; }
- virtual RuntimeType type() const { return _type.UTF8String(); }
+ JNIType getJNIType() const { return m_JNIType; }
- JNIType getJNIType() const { return _JNIType; }
-
private:
- void dispatchSetValueToInstance(ExecState *exec, const JavaInstance *instance, jvalue javaValue, const char *name, const char *sig) const;
- jvalue dispatchValueFromInstance(ExecState *exec, const JavaInstance *instance, const char *name, const char *sig, JNIType returnType) const;
+ 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;
- JavaString _name;
- JavaString _type;
- JNIType _JNIType;
- RefPtr<JObjectWrapper> _field;
+ JavaString m_name;
+ JavaString m_type;
+ JNIType m_JNIType;
+ RefPtr<JObjectWrapper> m_field;
};
-class JavaMethod : public Method
-{
+class JavaMethod : public Method {
public:
- JavaMethod(JNIEnv* env, jobject aMethod);
+ JavaMethod(JNIEnv*, jobject aMethod);
~JavaMethod();
- const JavaString& name() const { return _name; }
- RuntimeType returnType() const { return _returnType.UTF8String(); };
- JavaParameter* parameterAt(int i) const { return &_parameters[i]; };
- int numParameters() const { return _numParameters; };
-
- const char *signature() const;
+ const JavaString& name() const { return m_name; }
+ RuntimeType returnType() const { return m_returnType.UTF8String(); }
+ JavaParameter* parameterAt(int i) const { return &m_parameters[i]; }
+ int numParameters() const { return m_numParameters; }
+
+ const char* signature() const;
JNIType JNIReturnType() const;
- jmethodID methodID (jobject obj) const;
-
- bool isStatic() const { return _isStatic; }
+ jmethodID methodID(jobject obj) const;
+
+ bool isStatic() const { return m_isStatic; }
private:
- JavaParameter* _parameters;
- int _numParameters;
- JavaString _name;
- mutable char* _signature;
- JavaString _returnType;
- JNIType _JNIReturnType;
- mutable jmethodID _methodID;
- bool _isStatic;
+ JavaParameter* m_parameters;
+ int m_numParameters;
+ JavaString m_name;
+ mutable char* m_signature;
+ JavaString m_returnType;
+ JNIType m_JNIReturnType;
+ mutable jmethodID m_methodID;
+ bool m_isStatic;
};
-class JavaArray : public Array
-{
+class JavaArray : public Array {
public:
JavaArray(jobject array, const char* type, PassRefPtr<RootObject>);
virtual ~JavaArray();
RootObject* rootObject() const;
- virtual void setValueAt(ExecState *exec, unsigned int index, JSValue aValue) const;
- virtual JSValue valueAt(ExecState *exec, unsigned int index) const;
+ virtual void setValueAt(ExecState*, unsigned int index, JSValue) const;
+ virtual JSValue valueAt(ExecState*, unsigned int index) const;
virtual unsigned int getLength() const;
-
- jobject javaArray() const { return _array->m_instance; }
- static JSValue convertJObjectToArray (ExecState* exec, jobject anObject, const char* type, PassRefPtr<RootObject>);
+ jobject javaArray() const { return m_array->m_instance; }
+
+ static JSValue convertJObjectToArray(ExecState*, jobject, const char* type, PassRefPtr<RootObject>);
private:
- RefPtr<JObjectWrapper> _array;
- unsigned int _length;
- const char *_type;
+ RefPtr<JObjectWrapper> m_array;
+ unsigned int m_length;
+ const char* m_type;
};
} // namespace Bindings
--
WebKit Debian packaging
More information about the Pkg-webkit-commits
mailing list