Merge "Cherry-pick WebKit change 53619 to fix style in JNIBridge"

3 files changed, 321 insertions, 292 deletions

diff --git a/WebCore/ChangeLog b/WebCore/ChangeLog
index f887e7a..bd21b51 100644
--- a/WebCore/ChangeLog
+++ b/WebCore/ChangeLog
@@ -1,3 +1,15 @@
+2010-01-21  Steve Block  <steveblock@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-20  Steve Block  <steveblock@google.com>
 
         Reviewed by David Levin.
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