modules/oji/src/nsJNI.cpp

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /* ***** BEGIN LICENSE BLOCK *****
   3  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   4  *
   5  * The contents of this file are subject to the Mozilla Public License Version
   6  * 1.1 (the "License"); you may not use this file except in compliance with
   7  * the License. You may obtain a copy of the License at
   8  * http://www.mozilla.org/MPL/
   9  *
  10  * Software distributed under the License is distributed on an "AS IS" basis,
  11  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12  * for the specific language governing rights and limitations under the
  13  * License.
  14  *
  15  * The Original Code is mozilla.org code.
  16  *
  17  * The Initial Developer of the Original Code is
  18  * Netscape Communications Corporation.
  19  * Portions created by the Initial Developer are Copyright (C) 1998
  20  * the Initial Developer. All Rights Reserved.
  21  *
  22  * Contributor(s):
  23  *
  24  * Alternatively, the contents of this file may be used under the terms of
  25  * either the GNU General Public License Version 2 or later (the "GPL"), or
  26  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  27  * in which case the provisions of the GPL or the LGPL are applicable instead
  28  * of those above. If you wish to allow use of your version of this file only
  29  * under the terms of either the GPL or the LGPL, and not to allow others to
  30  * use your version of this file under the terms of the MPL, indicate your
  31  * decision by deleting the provisions above and replace them with the notice
  32  * and other provisions required by the GPL or the LGPL. If you do not delete
  33  * the provisions above, a recipient may use your version of this file under
  34  * the terms of any one of the MPL, the GPL or the LGPL.
  35  *
  36  * ***** END LICENSE BLOCK ***** */
  37
  38 /*
  39  * Proxy JNI implementation.
  40  */
  41
  42 #include "jni.h"
  43 #include "nsISecureJNI2.h"
  44 #include "nsHashtable.h"
  45 #include "nsVoidArray.h"
  46 #include "plstr.h"
  47
  48 // Method Signature Processing.
  49
  50 static jni_type get_jni_type(char sig)
  51 {
  52         switch (sig) {
  53         case 'L':
  54         case '[':
  55                 return jobject_type;
  56         case 'Z':
  57                 return jboolean_type;
  58         case 'B':
  59                 return jbyte_type;
  60         case 'C':
  61                 return jchar_type;
  62         case 'S':
  63                 return jshort_type;
  64         case 'I':
  65                 return jint_type;
  66         case 'J':
  67                 return jlong_type;
  68         case 'F':
  69                 return jfloat_type;
  70         case 'D':
  71                 return jdouble_type;
  72         case 'V':
  73                 return jvoid_type;
  74         }
  75         return jvoid_type;
  76 }
  77
  78 static PRBool get_method_type(const char* sig, PRUint32& arg_count, jni_type*& arg_types, jni_type& return_type)
  79 {
  80         arg_count = 0;
  81         if (sig[0] == '(') {
  82                 nsVoidArray vec;
  83                 ++sig;
  84                 while (*sig != ')' && *sig) {
  85                         char arg_sig = *sig++;
  86                         jni_type arg_type = get_jni_type(arg_sig);
  87                         if (arg_type == jobject_type) {
  88                                 // could be an array or an object.
  89                                 while (*sig == '[') ++sig;
  90                                 if (*sig == 'L') {
  91                                         // skip over "className;"
  92                                         ++sig;
  93                                         while (*sig != ';') ++sig;
  94                                 }
  95                                 // skip over scalar or ';'.
  96                                 ++sig;
  97                         }
  98                         vec.AppendElement((void*)arg_type);
  99                 }
 100                 arg_count = vec.Count();
 101                 arg_types = new jni_type[arg_count];
 102                 for (int index = arg_count - 1; index >= 0; --index)
 103                         arg_types[index] = jni_type(vec.ElementAt(index));
 104                 if (*sig == ')') {
 105                         char return_sig = *++sig;
 106                         return_type = get_jni_type(return_sig);
 107                 }
 108         }
 109         return PR_FALSE;
 110 }
 111
 112 class JNIHashKey : public nsHashKey {
 113 public:
 114         JNIHashKey(void* key) : mKey(key) {}
 115
 116         virtual PRUint32 HashValue(void) const { return PRUint32(mKey); }
 117         virtual PRBool Equals(const nsHashKey *aKey) const { return mKey == ((JNIHashKey*)aKey)->mKey; }
 118         virtual nsHashKey *Clone(void) const { return new JNIHashKey(mKey); }
 119
 120 private:
 121         void* mKey;
 122 };
 123
 124 struct JNIMember {
 125         char* mName;
 126         char* mSignature;
 127
 128         JNIMember(const char* name, const char* sig);
 129         ~JNIMember();
 130 };
 131
 132 JNIMember::JNIMember(const char* name, const char* sig)
 133         : mName(NULL), mSignature(NULL)
 134 {
 135         mName = PL_strdup(name);
 136         mSignature = PL_strdup(sig);
 137 }
 138
 139 JNIMember::~JNIMember()
 140 {
 141         PL_strfree(mName);
 142         PL_strfree(mSignature);
 143 }
 144
 145 struct JNIField : JNIMember {
 146         jfieldID mFieldID;
 147         jni_type mFieldType;
 148
 149         JNIField(const char* name, const char* sig, jfieldID fieldID);
 150 };
 151
 152 JNIField::JNIField(const char* name, const char* sig, jfieldID fieldID)
 153         : JNIMember(name, sig), mFieldID(fieldID), mFieldType(get_jni_type(*sig))
 154 {
 155 }
 156
 157 struct JNIMethod : JNIMember {
 158         jmethodID mMethodID;
 159         PRUint32 mArgCount;
 160         jni_type* mArgTypes;
 161         jni_type mReturnType;
 162
 163         JNIMethod(const char* name, const char* sig, jmethodID methodID);
 164         ~JNIMethod();
 165
 166         jvalue* marshallArgs(va_list args);
 167 };
 168
 169 JNIMethod::JNIMethod(const char* name, const char* sig, jmethodID methodID)
 170         : JNIMember(name, sig), mMethodID(methodID), mArgCount(0), mArgTypes(NULL), mReturnType(jvoid_type)
 171 {
 172         get_method_type(sig, mArgCount, mArgTypes, mReturnType);
 173 }
 174
 175 JNIMethod::~JNIMethod()
 176 {
 177         if (mArgTypes != NULL)
 178                 delete[] mArgTypes;
 179 }
 180
 181 /**
 182  * Copies an argument list into a jvalue array.
 183  */
 184 jvalue* JNIMethod::marshallArgs(va_list args)
 185 {
 186         PRUint32 argCount = mArgCount;
 187         jni_type* argTypes = mArgTypes;
 188         jvalue* jargs = new jvalue[argCount];
 189         if (jargs != NULL) {
 190                 for (int i = 0; i < argCount; i++) {
 191                         switch (argTypes[i]) {
 192                         case jobject_type:
 193                                 jargs[i].l = va_arg(args, jobject);
 194                                 break;
 195                         case jboolean_type:
 196                                 jargs[i].z = va_arg(args, jboolean);
 197                                 break;
 198                         case jbyte_type:
 199                                 jargs[i].b = va_arg(args, jbyte);
 200                                 break;
 201                         case jchar_type:
 202                                 jargs[i].b = va_arg(args, jbyte);
 203                                 break;
 204                         case jshort_type:
 205                                 jargs[i].s = va_arg(args, jshort);
 206                                 break;
 207                         case jint_type:
 208                                 jargs[i].i = va_arg(args, jint);
 209                                 break;
 210                         case jlong_type:
 211                                 jargs[i].j = va_arg(args, jlong);
 212                                 break;
 213                         case jfloat_type:
 214                                 jargs[i].f = va_arg(args, jfloat);
 215                                 break;
 216                         case jdouble_type:
 217                                 jargs[i].d = va_arg(args, jdouble);
 218                                 break;
 219                         }
 220                 }
 221         }
 222         return jargs;
 223 }
 224
 225 /**
 226  * Marshalls a va_list into a jvalue array, and destructor automatically
 227  * deletes when the args go out of scope.
 228  */
 229 class MarshalledArgs {
 230 public:
 231         MarshalledArgs(JNIMethod* forMethod, va_list args) : mArgs(forMethod->marshallArgs(args)) {}
 232         ~MarshalledArgs() { delete[] mArgs; }
 233
 234         operator jvalue* () { return mArgs; }
 235
 236 private:
 237         jvalue* mArgs;
 238 };
 239
 240 class nsJNIEnv : public JNIEnv {
 241 private:
 242         static JNINativeInterface_ theFuncs;
 243         static nsHashtable* theIDTable;
 244         nsISecureJNI2* mSecureEnv;
 245         nsISecurityContext* mContext;
 246         jobject mJavaThread;
 247
 248         static nsJNIEnv& nsJNIEnvRef(JNIEnv* env) { return *(nsJNIEnv*)env; }
 249
 250         nsISecureJNI2* operator->() { return mSecureEnv; }
 251         nsISecurityContext* getContext() { return mContext; }
 252
 253         static jint JNICALL GetVersion(JNIEnv* env)
 254         {
 255                 nsJNIEnv& secureEnv = nsJNIEnvRef(env);
 256                 jint version = 0;
 257                 nsresult result =  secureEnv->GetVersion(&version);
 258                 return version;
 259         }
 260
 261         static jclass JNICALL DefineClass(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize len)
 262         {
 263                 nsJNIEnv& secureEnv = nsJNIEnvRef(env);
 264                 jclass outClass = NULL;
 265                 nsresult result = secureEnv->DefineClass(name, loader, buf, len, &outClass);
 266                 return outClass;
 267         }
 268
 269         static jclass JNICALL FindClass(JNIEnv *env, const char *name)
 270         {
 271                 nsJNIEnv& secureEnv = nsJNIEnvRef(env);
 272                 jclass outClass = NULL;
 273                 nsresult result = secureEnv->FindClass(name, &outClass);
 274                 return outClass;
 275         }
 276
 277         static jclass JNICALL GetSuperclass(JNIEnv *env, jclass sub)
 278         {
 279                 nsJNIEnv& secureEnv = nsJNIEnvRef(env);
 280                 jclass outSuper = NULL;
 281                 nsresult result = secureEnv->GetSuperclass(sub, &outSuper);
 282                 return outSuper;
 283         }
 284
 285         static jboolean JNICALL IsAssignableFrom(JNIEnv *env, jclass sub, jclass sup)
 286         {
 287                 nsJNIEnv& secureEnv = nsJNIEnvRef(env);
 288                 jboolean outIsAssignable = FALSE;
 289                 nsresult result = secureEnv->IsAssignableFrom(sub, sup, &outIsAssignable);
 290                 return outIsAssignable;
 291         }
 292
 293         static jint Throw(JNIEnv *env, jthrowable obj)
 294         {
 295                 nsJNIEnv& secureEnv = nsJNIEnvRef(env);
 296                 jint outStatus = FALSE;
 297                 nsresult result = secureEnv->Throw(obj, &outStatus);
 298                 return outStatus;
 299         }
 300
 301         static jint JNICALL ThrowNew(JNIEnv *env, jclass clazz, const char *msg)
 302         {
 303                 nsJNIEnv& secureEnv = nsJNIEnvRef(env);
 304                 jint outStatus = FALSE;
 305                 nsresult result = secureEnv->ThrowNew(clazz, msg, &outStatus);
 306                 return outStatus;
 307         }
 308
 309         static jthrowable JNICALL ExceptionOccurred(JNIEnv *env)
 310         {
 311                 nsJNIEnv& secureEnv = nsJNIEnvRef(env);
 312                 jthrowable outThrowable = NULL;
 313                 nsresult result = secureEnv->ExceptionOccurred(&outThrowable);
 314                 return outThrowable;
 315         }
 316
 317         static void JNICALL ExceptionDescribe(JNIEnv *env)
 318         {
 319                 nsJNIEnv& secureEnv = nsJNIEnvRef(env);
 320                 nsresult result = secureEnv->ExceptionDescribe();
 321         }
 322
 323         static void JNICALL ExceptionClear(JNIEnv *env)
 324         {
 325                 nsJNIEnv& secureEnv = nsJNIEnvRef(env);
 326                 nsresult result = secureEnv->ExceptionClear();
 327         }
 328
 329         static void JNICALL FatalError(JNIEnv *env, const char *msg)
 330         {
 331                 nsJNIEnv& secureEnv = nsJNIEnvRef(env);
 332                 nsresult result = secureEnv->FatalError(msg);
 333         }
 334
 335         static jobject JNICALL NewGlobalRef(JNIEnv *env, jobject lobj)
 336         {
 337                 nsJNIEnv& secureEnv = nsJNIEnvRef(env);
 338                 jobject outGlobalRef = NULL;
 339                 nsresult result = secureEnv->NewGlobalRef(lobj, &outGlobalRef);
 340                 return outGlobalRef;
 341         }
 342
 343         static void JNICALL DeleteGlobalRef(JNIEnv *env, jobject gref)
 344         {
 345                 nsJNIEnv& secureEnv = nsJNIEnvRef(env);
 346                 nsresult result = secureEnv->DeleteGlobalRef(gref);
 347         }
 348
 349         static void JNICALL DeleteLocalRef(JNIEnv *env, jobject obj)
 350         {
 351                 nsJNIEnv& secureEnv = nsJNIEnvRef(env);
 352                 nsresult result = secureEnv->DeleteLocalRef(obj);
 353         }
 354
 355         static jboolean JNICALL IsSameObject(JNIEnv *env, jobject obj1, jobject obj2)
 356         {
 357                 nsJNIEnv& secureEnv = nsJNIEnvRef(env);
 358                 jboolean outIsSameObject = FALSE;
 359                 nsresult result = secureEnv->IsSameObject(obj1, obj2, &outIsSameObject);
 360                 return outIsSameObject;
 361         }
 362
 363         static jobject JNICALL AllocObject(JNIEnv *env, jclass clazz)
 364         {
 365                 nsJNIEnv& secureEnv = nsJNIEnvRef(env);
 366                 jobject outObject = NULL;
 367                 nsresult result = secureEnv->AllocObject(clazz, &outObject);
 368                 return outObject;
 369         }
 370
 371         static jobject JNICALL NewObject(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
 372         {
 373                 va_list args; va_start(args, methodID);
 374                 jobject outObject = NewObjectV(env, clazz, methodID, args);
 375                 va_end(args);
 376                 return outObject;
 377         }
 378
 379         static jobject JNICALL NewObjectV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
 380         {
 381                 jobject outObject = NULL;
 382
 383                 // convert the va_list into an array of jvalues.
 384                 JNIMethod* method = (JNIMethod*)methodID;
 385                 MarshalledArgs jargs(method, args);
 386                 nsJNIEnv& secureEnv = nsJNIEnvRef(env);
 387                 nsresult result = secureEnv->NewObject(clazz, method->mMethodID, jargs, &outObject, secureEnv.getContext());
 388
 389                 return outObject;
 390         }
 391
 392         static jobject JNICALL NewObjectA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
 393         {
 394                 jobject outObject = NULL;
 395                 nsJNIEnv& secureEnv = nsJNIEnvRef(env);
 396                 JNIMethod* method = (JNIMethod*)methodID;
 397                 nsresult result = secureEnv->NewObject(clazz, method->mMethodID, args, &outObject, secureEnv.getContext());
 398                 return outObject;
 399         }
 400
 401         static jclass JNICALL GetObjectClass(JNIEnv *env, jobject obj)
 402         {
 403                 jclass outClass = NULL;
 404                 nsJNIEnv& secureEnv = nsJNIEnvRef(env);
 405                 nsresult result = secureEnv->GetObjectClass(obj, &outClass);
 406                 return outClass;
 407         }
 408
 409         static jboolean JNICALL IsInstanceOf(JNIEnv *env, jobject obj, jclass clazz)
 410         {
 411                 nsJNIEnv& secureEnv = nsJNIEnvRef(env);
 412                 jboolean outIsInstanceOf = FALSE;
 413                 nsresult result = secureEnv->IsInstanceOf(obj, clazz, &outIsInstanceOf);
 414                 return outIsInstanceOf;
 415         }
 416
 417         static jmethodID JNICALL GetMethodID(JNIEnv *env, jclass clazz, const char *name, const char *sig)
 418         {
 419                 nsJNIEnv& secureEnv = nsJNIEnvRef(env);
 420                 jmethodID outMethodID = NULL;
 421                 nsresult result = secureEnv->GetMethodID(clazz, name, sig, &outMethodID);
 422                 if (result == NS_OK) {
 423                         JNIHashKey key(outMethodID);
 424                         JNIMethod* method = (JNIMethod*) theIDTable->Get(&key);
 425                         if (method == NULL) {
 426                                 method = new JNIMethod(name, sig, outMethodID);
 427                                 theIDTable->Put(&key, method);
 428                         }
 429                         outMethodID = jmethodID(method);
 430                 }
 431                 return outMethodID;
 432         }
 433
 434         /**
 435          * Bottleneck methods called by method families below.
 436          */
 437
 438         // Virtual Invokers.
 439
 440         static jvalue InvokeMethod(JNIEnv *env, jobject obj, JNIMethod* method, jvalue* args)
 441         {
 442                 jvalue outValue = { NULL };
 443                 nsJNIEnv& secureEnv = nsJNIEnvRef(env);
 444                 nsresult result = secureEnv->CallMethod(method->mReturnType, obj, method->mMethodID, args, &outValue, secureEnv.getContext());
 445                 return outValue;
 446         }
 447
 448         static jvalue InvokeMethod(JNIEnv *env, jobject obj, JNIMethod* method, va_list args)
 449         {
 450                 // convert the va_list into an array of jvalues.
 451                 MarshalledArgs jargs(method, args);
 452                 return InvokeMethod(env, obj, method, jargs);
 453         }
 454
 455         static void InvokeVoidMethod(JNIEnv *env, jobject obj, JNIMethod* method, jvalue* args)
 456         {
 457                 jvalue unusedValue;
 458                 nsJNIEnv& secureEnv = nsJNIEnvRef(env);
 459                 nsresult result = secureEnv->CallMethod(jvoid_type, obj, method->mMethodID, args, &unusedValue, secureEnv.getContext());
 460         }
 461
 462         static void InvokeVoidMethod(JNIEnv *env, jobject obj, JNIMethod* method, va_list args)
 463         {
 464                 // convert the va_list into an array of jvalues.
 465                 MarshalledArgs jargs(method, args);
 466                 InvokeVoidMethod(env, obj, method, jargs);
 467         }
 468
 469 #define IMPLEMENT_METHOD_FAMILY(methodName, returnType, jvalueField) \
 470         static returnType JNICALL methodName(JNIEnv *env, jobject obj, jmethodID methodID, ...)                                 \
 471         {                                                                                                                                                                                                               \
 472                 va_list args; va_start(args, methodID);                                                                                                                         \
 473                 returnType result = InvokeMethod(env, obj, (JNIMethod*)methodID, args).jvalueField;                                     \
 474                 va_end(args);                                                                                                                                                                           \
 475                 return result;                                                                                                                                                                          \
 476         }                                                                                                                                                                                                               \
 477                                                                                                                                                                                                                         \
 478         static returnType JNICALL methodName##V(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)             \
 479         {                                                                                                                                                                                                               \
 480                 return InvokeMethod(env, obj, (JNIMethod*)methodID, args).jvalueField;                                                          \
 481         }                                                                                                                                                                                                               \
 482                                                                                                                                                                                                                         \
 483         static returnType JNICALL methodName##A(JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args)    \
 484         {                                                                                                                                                                                                               \
 485                 return InvokeMethod(env, obj, (JNIMethod*)methodID, args).jvalueField;                                                          \
 486         }                                                                                                                                                                                                               \
 487
 488         // Pattern on which IMPLEMENT_METHOD_FAMILY is based.
 489         /*
 490         static jobject JNICALL CallObjectMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
 491         {
 492                 va_list args; va_start(args, methodID);
 493                 jobject outObject = InvokeMethod(env, obj, (JNIMethod*)methodID, args).l;
 494                 va_end(args);
 495                 return outObject;
 496         }
 497
 498         static jobject JNICALL CallObjectMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
 499         {
 500                 return InvokeMethod(env, obj, (JNIMethod*)methodID, args).l;
 501         }
 502
 503         static jobject JNICALL CallObjectMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args)
 504         {
 505                 return InvokeMethod(env, obj, (JNIMethod*)methodID, args).l;
 506         }
 507         */
 508
 509         IMPLEMENT_METHOD_FAMILY(CallObjectMethod, jobject, l)
 510         IMPLEMENT_METHOD_FAMILY(CallBooleanMethod, jboolean, z)
 511         IMPLEMENT_METHOD_FAMILY(CallByteMethod, jbyte, b)
 512         IMPLEMENT_METHOD_FAMILY(CallCharMethod, jchar, c)
 513         IMPLEMENT_METHOD_FAMILY(CallShortMethod, jshort, s)
 514         IMPLEMENT_METHOD_FAMILY(CallIntMethod, jint, i)
 515         IMPLEMENT_METHOD_FAMILY(CallLongMethod, jlong, j)
 516         IMPLEMENT_METHOD_FAMILY(CallFloatMethod, jfloat, f)
 517         IMPLEMENT_METHOD_FAMILY(CallDoubleMethod, jdouble, d)
 518
 519 #undef IMPLEMENT_METHOD_FAMILY
 520
 521         static void JNICALL CallVoidMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
 522         {
 523                 va_list args; va_start(args, methodID);
 524                 InvokeVoidMethod(env, obj, (JNIMethod*)methodID, args);
 525                 va_end(args);
 526         }
 527
 528         static void JNICALL CallVoidMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
 529         {
 530                 InvokeVoidMethod(env, obj, (JNIMethod*)methodID, args);
 531         }
 532
 533         static void JNICALL CallVoidMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args)
 534         {
 535                 InvokeVoidMethod(env, obj, (JNIMethod*)methodID, args);
 536         }
 537
 538         // Non-virtual Invokers.
 539
 540         static jvalue InvokeNonVirtualMethod(JNIEnv *env, jobject obj, jclass clazz, JNIMethod* method, jvalue* args)
 541         {
 542                 jvalue outValue = { NULL };
 543                 nsJNIEnv& secureEnv = nsJNIEnvRef(env);
 544                 nsresult result = secureEnv->CallNonvirtualMethod(method->mReturnType, obj, clazz, method->mMethodID, args, &outValue, secureEnv.getContext());
 545                 return outValue;
 546         }
 547
 548         static jvalue InvokeNonVirtualMethod(JNIEnv *env, jobject obj, jclass clazz, JNIMethod* method, va_list args)
 549         {
 550                 // convert the va_list into an array of jvalues.
 551                 MarshalledArgs jargs(method, args);
 552                 return InvokeNonVirtualMethod(env, obj, clazz, method, jargs);
 553         }
 554
 555         static void InvokeNonVirtualVoidMethod(JNIEnv *env, jobject obj, jclass clazz, JNIMethod* method, jvalue* args)
 556         {
 557                 jvalue unusedValue;
 558                 nsJNIEnv& secureEnv = nsJNIEnvRef(env);
 559                 nsresult result = secureEnv->CallNonvirtualMethod(jvoid_type, obj, clazz, method->mMethodID, args, &unusedValue, secureEnv.getContext());
 560         }
 561
 562         static void InvokeNonVirtualVoidMethod(JNIEnv *env, jobject obj, jclass clazz, JNIMethod* method, va_list args)
 563         {
 564                 // convert the va_list into an array of jvalues.
 565                 MarshalledArgs jargs(method, args);
 566                 InvokeNonVirtualVoidMethod(env, obj, clazz, method, jargs);
 567         }
 568
 569 #define IMPLEMENT_METHOD_FAMILY(methodName, returnType, jvalueField) \
 570         static returnType JNICALL methodName(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)                           \
 571         {                                                                                                                                                                                                                                       \
 572                 va_list args; va_start(args, methodID);                                                                                                                                                 \
 573                 returnType result = InvokeNonVirtualMethod(env, obj, clazz, (JNIMethod*)methodID, args).jvalueField;                    \
 574                 va_end(args);                                                                                                                                                                                                   \
 575                 return result;                                                                                                                                                                                                  \
 576         }                                                                                                                                                                                                                                       \
 577                                                                                                                                                                                                                                                 \
 578         static returnType JNICALL methodName##V(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)       \
 579         {                                                                                                                                                                                                                                       \
 580                 return InvokeNonVirtualMethod(env, obj, clazz, (JNIMethod*)methodID, args).jvalueField;                                                 \
 581         }                                                                                                                                                                                                                                       \
 582                                                                                                                                                                                                                                                 \
 583         static returnType JNICALL methodName##A(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue * args)      \
 584         {                                                                                                                                                                                                                                       \
 585                 return InvokeNonVirtualMethod(env, obj, clazz, (JNIMethod*)methodID, args).jvalueField;                                                 \
 586         }                                                                                                                                                                                                                                       \
 587
 588         IMPLEMENT_METHOD_FAMILY(CallNonvirtualObjectMethod, jobject, l)
 589         IMPLEMENT_METHOD_FAMILY(CallNonvirtualBooleanMethod, jboolean, z)
 590         IMPLEMENT_METHOD_FAMILY(CallNonvirtualByteMethod, jbyte, b)
 591         IMPLEMENT_METHOD_FAMILY(CallNonvirtualCharMethod, jchar, c)
 592         IMPLEMENT_METHOD_FAMILY(CallNonvirtualShortMethod, jshort, s)
 593         IMPLEMENT_METHOD_FAMILY(CallNonvirtualIntMethod, jint, i)
 594         IMPLEMENT_METHOD_FAMILY(CallNonvirtualLongMethod, jlong, j)
 595         IMPLEMENT_METHOD_FAMILY(CallNonvirtualFloatMethod, jfloat, f)
 596         IMPLEMENT_METHOD_FAMILY(CallNonvirtualDoubleMethod, jdouble, d)
 597
 598 #undef IMPLEMENT_METHOD_FAMILY
 599
 600         static void JNICALL CallNonvirtualVoidMethod(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
 601         {
 602                 va_list args; va_start(args, methodID);
 603                 InvokeNonVirtualVoidMethod(env, obj, clazz, (JNIMethod*)methodID, args);
 604                 va_end(args);
 605         }
 606
 607         static void JNICALL CallNonvirtualVoidMethodV(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
 608         {
 609                 InvokeNonVirtualVoidMethod(env, obj, clazz, (JNIMethod*)methodID, args);
 610         }
 611
 612         static void JNICALL CallNonvirtualVoidMethodA(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue * args)
 613         {
 614                 InvokeNonVirtualVoidMethod(env, obj, clazz, (JNIMethod*)methodID, args);
 615         }
 616
 617         // Instance Fields
 618
 619         static jfieldID JNICALL GetFieldID(JNIEnv *env, jclass clazz, const char *name, const char *sig)
 620         {
 621                 nsJNIEnv& secureEnv = nsJNIEnvRef(env);
 622                 jfieldID outFieldID = NULL;
 623                 nsresult result = secureEnv->GetFieldID(clazz, name, sig, &outFieldID);
 624                 if (result == NS_OK) {
 625                         JNIHashKey key(outFieldID);
 626                         JNIField* field = (JNIField*) theIDTable->Get(&key);
 627                         if (field == NULL) {
 628                                 field = new JNIField(name, sig, outFieldID);
 629                                 theIDTable->Put(&key, field);
 630                         }
 631                         outFieldID = jfieldID(field);
 632                 }
 633                 return outFieldID;
 634         }
 635
 636         static jvalue GetField(JNIEnv* env, jobject obj, JNIField* field)
 637         {
 638                 jvalue outValue = { NULL };
 639                 nsJNIEnv& secureEnv = nsJNIEnvRef(env);
 640                 nsresult result = secureEnv->GetField(field->mFieldType, obj, field->mFieldID, &outValue, secureEnv.getContext());
 641                 return outValue;
 642         }
 643
 644 #define IMPLEMENT_GET_FIELD(methodName, returnType, jvalueField)                                                        \
 645         static returnType JNICALL methodName(JNIEnv *env, jobject obj, jfieldID fieldID)                \
 646         {                                                                                                                                                                               \
 647                 return GetField(env, obj, (JNIField*)fieldID).jvalueField;                                                      \
 648         }                                                                                                                                                                               \
 649
 650         IMPLEMENT_GET_FIELD(GetObjectField, jobject, l)
 651         IMPLEMENT_GET_FIELD(GetBooleanField, jboolean, z)
 652         IMPLEMENT_GET_FIELD(GetByteField, jbyte, b)
 653         IMPLEMENT_GET_FIELD(GetCharField, jchar, c)
 654         IMPLEMENT_GET_FIELD(GetShortField, jshort, s)
 655         IMPLEMENT_GET_FIELD(GetIntField, jint, i)
 656         IMPLEMENT_GET_FIELD(GetLongField, jlong, j)
 657         IMPLEMENT_GET_FIELD(GetFloatField, jfloat, f)
 658         IMPLEMENT_GET_FIELD(GetDoubleField, jdouble, d)
 659
 660 #undef IMPLEMENT_GET_FIELD
 661
 662         static void SetField(JNIEnv* env, jobject obj, JNIField* field, jvalue value)
 663         {
 664                 nsJNIEnv& secureEnv = nsJNIEnvRef(env);
 665                 nsresult result = secureEnv->SetField(field->mFieldType, obj, field->mFieldID, value, secureEnv.getContext());
 666         }
 667
 668 #define IMPLEMENT_SET_FIELD(methodName, fieldType, jvalueField)                                                                         \
 669         static void JNICALL methodName(JNIEnv *env, jobject obj, jfieldID fieldID, fieldType value)             \
 670         {                                                                                                                                                                                               \
 671                 jvalue fieldValue;                                                                                                                                                      \
 672                 fieldValue.jvalueField = value;                                                                                                                         \
 673                 SetField(env, obj, (JNIField*)fieldID, fieldValue);                                                                                     \
 674         }                                                                                                                                                                                               \
 675
 676         IMPLEMENT_SET_FIELD(SetObjectField, jobject, l)
 677         IMPLEMENT_SET_FIELD(SetBooleanField, jboolean, z)
 678         IMPLEMENT_SET_FIELD(SetByteField, jbyte, b)
 679         IMPLEMENT_SET_FIELD(SetCharField, jchar, c)
 680         IMPLEMENT_SET_FIELD(SetShortField, jshort, s)
 681         IMPLEMENT_SET_FIELD(SetIntField, jint, i)
 682         IMPLEMENT_SET_FIELD(SetLongField, jlong, j)
 683         IMPLEMENT_SET_FIELD(SetFloatField, jfloat, f)
 684         IMPLEMENT_SET_FIELD(SetDoubleField, jdouble, d)
 685
 686 #undef IMPLEMENT_SET_FIELD
 687
 688         // Static Methods
 689
 690         static jmethodID JNICALL GetStaticMethodID(JNIEnv *env, jclass clazz, const char *name, const char *sig)
 691         {
 692                 nsJNIEnv& secureEnv = nsJNIEnvRef(env);
 693                 jmethodID outMethodID = NULL;
 694                 nsresult result = secureEnv->GetStaticMethodID(clazz, name, sig, &outMethodID);
 695                 if (result == NS_OK) {
 696                         JNIHashKey key(outMethodID);
 697                         JNIMethod* method = (JNIMethod*) theIDTable->Get(&key);
 698                         if (method == NULL) {
 699                                 method = new JNIMethod(name, sig, outMethodID);
 700                                 theIDTable->Put(&key, method);
 701                         }
 702                         outMethodID = jmethodID(method);
 703                 }
 704                 return outMethodID;
 705         }
 706
 707         // jobject (JNICALL *CallStaticObjectMethod) (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
 708
 709         // Static Invokers.
 710
 711         static jvalue InvokeStaticMethod(JNIEnv *env, jclass clazz, JNIMethod* method, jvalue* args)
 712         {
 713                 jvalue outValue = { NULL };
 714                 nsJNIEnv& secureEnv = nsJNIEnvRef(env);
 715                 nsresult result = secureEnv->CallStaticMethod(method->mReturnType, clazz, method->mMethodID, args, &outValue, secureEnv.getContext());
 716                 return outValue;
 717         }
 718
 719         static jvalue InvokeStaticMethod(JNIEnv *env, jclass clazz, JNIMethod* method, va_list args)
 720         {
 721                 // convert the va_list into an array of jvalues.
 722                 MarshalledArgs jargs(method, args);
 723                 return InvokeStaticMethod(env, clazz, method, jargs);
 724         }
 725
 726         static void InvokeStaticVoidMethod(JNIEnv *env, jclass clazz, JNIMethod* method, jvalue* args)
 727         {
 728                 jvalue unusedValue;
 729                 nsJNIEnv& secureEnv = nsJNIEnvRef(env);
 730                 nsresult result = secureEnv->CallStaticMethod(jvoid_type, clazz, method->mMethodID, args, &unusedValue, secureEnv.getContext());
 731         }
 732
 733         static void InvokeStaticVoidMethod(JNIEnv *env, jclass clazz, JNIMethod* method, va_list args)
 734         {
 735                 // convert the va_list into an array of jvalues.
 736                 MarshalledArgs jargs(method, args);
 737                 InvokeStaticVoidMethod(env, clazz, method, jargs);
 738         }
 739
 740 #define IMPLEMENT_METHOD_FAMILY(methodName, returnType, jvalueField) \
 741         static returnType JNICALL methodName(JNIEnv *env, jclass clazz, jmethodID methodID, ...)                                \
 742         {                                                                                                                                                                                                               \
 743                 va_list args; va_start(args, methodID);                                                                                                                         \
 744                 returnType result = InvokeStaticMethod(env, clazz, (JNIMethod*)methodID, args).jvalueField;                     \
 745                 va_end(args);                                                                                                                                                                           \
 746                 return result;                                                                                                                                                                          \
 747         }                                                                                                                                                                                                               \
 748                                                                                                                                                                                                                         \
 749         static returnType JNICALL methodName##V(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)    \
 750         {                                                                                                                                                                                                               \
 751                 return InvokeStaticMethod(env, clazz, (JNIMethod*)methodID, args).jvalueField;                                          \
 752         }                                                                                                                                                                                                               \
 753                                                                                                                                                                                                                         \
 754         static returnType JNICALL methodName##A(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue * args)   \
 755         {                                                                                                                                                                                                               \
 756                 return InvokeStaticMethod(env, clazz, (JNIMethod*)methodID, args).jvalueField;                                          \
 757         }                                                                                                                                                                                                               \
 758
 759         IMPLEMENT_METHOD_FAMILY(CallStaticObjectMethod, jobject, l)
 760         IMPLEMENT_METHOD_FAMILY(CallStaticBooleanMethod, jboolean, z)
 761         IMPLEMENT_METHOD_FAMILY(CallStaticByteMethod, jbyte, b)
 762         IMPLEMENT_METHOD_FAMILY(CallStaticCharMethod, jchar, c)
 763         IMPLEMENT_METHOD_FAMILY(CallStaticShortMethod, jshort, s)
 764         IMPLEMENT_METHOD_FAMILY(CallStaticIntMethod, jint, i)
 765         IMPLEMENT_METHOD_FAMILY(CallStaticLongMethod, jlong, j)
 766         IMPLEMENT_METHOD_FAMILY(CallStaticFloatMethod, jfloat, f)
 767         IMPLEMENT_METHOD_FAMILY(CallStaticDoubleMethod, jdouble, d)
 768
 769 #undef IMPLEMENT_METHOD_FAMILY
 770
 771         static void JNICALL CallStaticVoidMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
 772         {
 773                 va_list args; va_start(args, methodID);
 774                 InvokeStaticVoidMethod(env, clazz, (JNIMethod*)methodID, args);
 775                 va_end(args);
 776         }
 777
 778         static void JNICALL CallStaticVoidMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
 779         {
 780                 InvokeStaticVoidMethod(env, clazz, (JNIMethod*)methodID, args);
 781         }
 782
 783         static void JNICALL CallStaticVoidMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue * args)
 784         {
 785                 InvokeStaticVoidMethod(env, clazz, (JNIMethod*)methodID, args);
 786         }
 787
 788         // Static Fields
 789
 790         static jfieldID JNICALL GetStaticFieldID(JNIEnv *env, jclass clazz, const char *name, const char *sig)
 791         {
 792                 nsJNIEnv& secureEnv = nsJNIEnvRef(env);
 793                 jfieldID outFieldID = NULL;
 794                 nsresult result = secureEnv->GetStaticFieldID(clazz, name, sig, &outFieldID);
 795                 if (result == NS_OK) {
 796                         JNIHashKey key(outFieldID);
 797                         JNIField* field = (JNIField*) theIDTable->Get(&key);
 798                         if (field == NULL) {
 799                                 field = new JNIField(name, sig, outFieldID);
 800                                 theIDTable->Put(&key, field);
 801                         }
 802                         outFieldID = jfieldID(field);
 803                 }
 804                 return outFieldID;
 805         }
 806
 807         static jvalue GetStaticField(JNIEnv* env, jclass clazz, JNIField* field)
 808         {
 809                 jvalue outValue = { NULL };
 810                 nsJNIEnv& secureEnv = nsJNIEnvRef(env);
 811                 nsresult result = secureEnv->GetStaticField(field->mFieldType, clazz, field->mFieldID, &outValue, secureEnv.getContext());
 812                 return outValue;
 813         }
 814
 815 #define IMPLEMENT_GET_FIELD(methodName, returnType, jvalueField)                                                        \
 816         static returnType JNICALL methodName(JNIEnv *env, jclass clazz, jfieldID fieldID)               \
 817         {                                                                                                                                                                               \
 818                 return GetStaticField(env, clazz, (JNIField*)fieldID).jvalueField;                                      \
 819         }                                                                                                                                                                               \
 820
 821         IMPLEMENT_GET_FIELD(GetStaticObjectField, jobject, l)
 822         IMPLEMENT_GET_FIELD(GetStaticBooleanField, jboolean, z)
 823         IMPLEMENT_GET_FIELD(GetStaticByteField, jbyte, b)
 824         IMPLEMENT_GET_FIELD(GetStaticCharField, jchar, c)
 825         IMPLEMENT_GET_FIELD(GetStaticShortField, jshort, s)
 826         IMPLEMENT_GET_FIELD(GetStaticIntField, jint, i)
 827         IMPLEMENT_GET_FIELD(GetStaticLongField, jlong, j)
 828         IMPLEMENT_GET_FIELD(GetStaticFloatField, jfloat, f)
 829         IMPLEMENT_GET_FIELD(GetStaticDoubleField, jdouble, d)
 830
 831 #undef IMPLEMENT_GET_FIELD
 832
 833         static void SetStaticField(JNIEnv* env, jclass clazz, JNIField* field, jvalue value)
 834         {
 835                 nsJNIEnv& secureEnv = nsJNIEnvRef(env);
 836                 nsresult result = secureEnv->SetStaticField(field->mFieldType, clazz, field->mFieldID, value, secureEnv.getContext());
 837         }
 838
 839 #define IMPLEMENT_SET_FIELD(methodName, fieldType, jvalueField)                                                                         \
 840         static void JNICALL methodName(JNIEnv *env, jclass clazz, jfieldID fieldID, fieldType value)    \
 841         {                                                                                                                                                                                               \
 842                 jvalue fieldValue;                                                                                                                                                      \
 843                 fieldValue.jvalueField = value;                                                                                                                         \
 844                 SetStaticField(env, clazz, (JNIField*)fieldID, fieldValue);                                                                     \
 845         }                                                                                                                                                                                               \
 846
 847         IMPLEMENT_SET_FIELD(SetStaticObjectField, jobject, l)
 848         IMPLEMENT_SET_FIELD(SetStaticBooleanField, jboolean, z)
 849         IMPLEMENT_SET_FIELD(SetStaticByteField, jbyte, b)
 850         IMPLEMENT_SET_FIELD(SetStaticCharField, jchar, c)
 851         IMPLEMENT_SET_FIELD(SetStaticShortField, jshort, s)
 852         IMPLEMENT_SET_FIELD(SetStaticIntField, jint, i)
 853         IMPLEMENT_SET_FIELD(SetStaticLongField, jlong, j)
 854         IMPLEMENT_SET_FIELD(SetStaticFloatField, jfloat, f)
 855         IMPLEMENT_SET_FIELD(SetStaticDoubleField, jdouble, d)
 856
 857 #undef IMPLEMENT_SET_FIELD
 858
 859         static jstring JNICALL NewString(JNIEnv *env, const jchar *unicode, jsize len)
 860         {
 861                 jstring outString;
 862                 nsJNIEnv& secureEnv = nsJNIEnvRef(env);
 863                 nsresult result = secureEnv->NewString(unicode, len, &outString);
 864                 return outString;
 865         }
 866
 867         static jsize JNICALL GetStringLength(JNIEnv *env, jstring str)
 868         {
 869                 jsize outLength;
 870                 nsJNIEnv& secureEnv = nsJNIEnvRef(env);
 871                 nsresult result = secureEnv->GetStringLength(str, &outLength);
 872                 return outLength;
 873         }
 874
 875         static const jchar* JNICALL GetStringChars(JNIEnv *env, jstring str, jboolean *isCopy)
 876         {
 877                 jchar* outChars = NULL;
 878                 nsJNIEnv& secureEnv = nsJNIEnvRef(env);
 879                 nsresult result = secureEnv->GetStringChars(str, isCopy, &outChars);
 880                 return outChars;
 881         }
 882
 883         static void JNICALL ReleaseStringChars(JNIEnv *env, jstring str, const jchar *chars)
 884         {
 885                 nsJNIEnv& secureEnv = nsJNIEnvRef(env);
 886                 nsresult result = secureEnv->ReleaseStringChars(str, chars);
 887         }
 888
 889         static jstring JNICALL NewStringUTF(JNIEnv *env, const char *utf)
 890         {
 891                 jstring outString;
 892                 nsJNIEnv& secureEnv = nsJNIEnvRef(env);
 893                 nsresult result = secureEnv->NewStringUTF(utf, &outString);
 894                 return outString;
 895         }
 896
 897         static jsize JNICALL GetStringUTFLength(JNIEnv *env, jstring str)
 898         {
 899                 jsize outLength;
 900                 nsJNIEnv& secureEnv = nsJNIEnvRef(env);
 901                 nsresult result = secureEnv->GetStringUTFLength(str, &outLength);
 902                 return outLength;
 903         }
 904
 905         static const char* JNICALL GetStringUTFChars(JNIEnv *env, jstring str, jboolean *isCopy)
 906         {
 907                 const char* outChars = NULL;
 908                 nsJNIEnv& secureEnv = nsJNIEnvRef(env);
 909                 nsresult result = secureEnv->GetStringUTFChars(str, isCopy, &outChars);
 910                 return outChars;
 911         }
 912
 913         static void JNICALL ReleaseStringUTFChars(JNIEnv *env, jstring str, const char* chars)
 914         {
 915                 nsJNIEnv& secureEnv = nsJNIEnvRef(env);
 916                 nsresult result = secureEnv->ReleaseStringUTFChars(str, chars);
 917         }
 918
 919         static jsize JNICALL GetArrayLength(JNIEnv *env, jarray array)
 920         {
 921                 jsize outLength;
 922                 nsJNIEnv& secureEnv = nsJNIEnvRef(env);
 923                 nsresult result = secureEnv->GetArrayLength(array, &outLength);
 924                 return outLength;
 925         }
 926
 927         static jobjectArray JNICALL NewObjectArray(JNIEnv *env, jsize len, jclass clazz, jobject initVal)
 928         {
 929                 jobjectArray outArray = NULL;
 930                 nsJNIEnv& secureEnv = nsJNIEnvRef(env);
 931                 nsresult result = secureEnv->NewObjectArray(len, clazz, initVal, &outArray);
 932                 return outArray;
 933         }
 934
 935         static jobject JNICALL GetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index)
 936         {
 937                 jobject outObject = NULL;
 938                 nsJNIEnv& secureEnv = nsJNIEnvRef(env);
 939                 nsresult result = secureEnv->GetObjectArrayElement(array, index, &outObject);
 940                 return outObject;
 941         }
 942
 943         static void JNICALL SetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index, jobject val)
 944         {
 945                 nsJNIEnv& secureEnv = nsJNIEnvRef(env);
 946                 nsresult result = secureEnv->SetObjectArrayElement(array, index, val);
 947         }
 948
 949 #define IMPLEMENT_NEW_ARRAY(methodName, type)                                                                                                           \
 950         static type##Array JNICALL methodName(JNIEnv *env, jsize len)                                                                   \
 951         {                                                                                                                                                                                               \
 952                 type##Array outArray = NULL;                                                                                                                            \
 953                 nsJNIEnv& secureEnv = nsJNIEnvRef(env);                                                                                                         \
 954                 nsresult result = secureEnv->NewArray(type##_type, len, (jarray*)&outArray);                            \
 955                 return outArray;                                                                                                                                                        \
 956         }                                                                                                                                                                                               \
 957
 958         IMPLEMENT_NEW_ARRAY(NewBooleanArray, jboolean)
 959         IMPLEMENT_NEW_ARRAY(NewByteArray, jbyte)
 960         IMPLEMENT_NEW_ARRAY(NewCharArray, jchar)
 961         IMPLEMENT_NEW_ARRAY(NewShortArray, jshort)
 962         IMPLEMENT_NEW_ARRAY(NewIntArray, jint)
 963         IMPLEMENT_NEW_ARRAY(NewLongArray, jlong)
 964         IMPLEMENT_NEW_ARRAY(NewFloatArray, jfloat)
 965         IMPLEMENT_NEW_ARRAY(NewDoubleArray, jdouble)
 966
 967 #undef IMPLEMENT_NEW_ARRAY
 968
 969 #define IMPLEMENT_GET_ARRAY_ELEMENTS(methodName, type)                                                                                                          \
 970         static type* JNICALL methodName(JNIEnv *env, type##Array array, jboolean *isCopy)                                               \
 971         {                                                                                                                                                                                                               \
 972                 type* outElements = NULL;                                                                                                                                                       \
 973                 nsJNIEnv& secureEnv = nsJNIEnvRef(env);                                                                                                                         \
 974                 nsresult result = secureEnv->GetArrayElements(type##_type, array, isCopy, &outElements);                        \
 975                 return outElements;                                                                                                                                                                     \
 976         }                                                                                                                                                                                                               \
 977
 978         IMPLEMENT_GET_ARRAY_ELEMENTS(GetBooleanArrayElements, jboolean)
 979         IMPLEMENT_GET_ARRAY_ELEMENTS(GetByteArrayElements, jbyte)
 980         IMPLEMENT_GET_ARRAY_ELEMENTS(GetCharArrayElements, jchar)
 981         IMPLEMENT_GET_ARRAY_ELEMENTS(GetShortArrayElements, jshort)
 982         IMPLEMENT_GET_ARRAY_ELEMENTS(GetIntArrayElements, jint)
 983         IMPLEMENT_GET_ARRAY_ELEMENTS(GetLongArrayElements, jlong)
 984         IMPLEMENT_GET_ARRAY_ELEMENTS(GetFloatArrayElements, jfloat)
 985         IMPLEMENT_GET_ARRAY_ELEMENTS(GetDoubleArrayElements, jdouble)
 986
 987 #undef IMPLEMENT_GET_ARRAY_ELEMENTS
 988
 989 #define IMPLEMENT_RELEASE_ARRAY_ELEMENTS(methodName, type)                                                                                                      \
 990         static void JNICALL methodName(JNIEnv *env, type##Array array, type* elems, jint mode)                                  \
 991         {                                                                                                                                                                                                               \
 992                 nsJNIEnv& secureEnv = nsJNIEnvRef(env);                                                                                                                         \
 993                 nsresult result = secureEnv->ReleaseArrayElements(type##_type, array, elems, mode);                                     \
 994         }                                                                                                                                                                                                               \
 995
 996         IMPLEMENT_RELEASE_ARRAY_ELEMENTS(ReleaseBooleanArrayElements, jboolean)
 997         IMPLEMENT_RELEASE_ARRAY_ELEMENTS(ReleaseByteArrayElements, jbyte)
 998         IMPLEMENT_RELEASE_ARRAY_ELEMENTS(ReleaseCharArrayElements, jchar)
 999         IMPLEMENT_RELEASE_ARRAY_ELEMENTS(ReleaseShortArrayElements, jshort)
1000         IMPLEMENT_RELEASE_ARRAY_ELEMENTS(ReleaseIntArrayElements, jint)
1001         IMPLEMENT_RELEASE_ARRAY_ELEMENTS(ReleaseLongArrayElements, jlong)
1002         IMPLEMENT_RELEASE_ARRAY_ELEMENTS(ReleaseFloatArrayElements, jfloat)
1003         IMPLEMENT_RELEASE_ARRAY_ELEMENTS(ReleaseDoubleArrayElements, jdouble)
1004
1005 #undef IMPLEMENT_RELEASE_ARRAY_ELEMENTS
1006
1007 #define IMPLEMENT_GET_ARRAY_REGION(methodName, type)                                                                                                            \
1008         static void JNICALL methodName(JNIEnv *env, type##Array array, jsize start, jsize len, type* buf)               \
1009         {                                                                                                                                                                                                               \
1010                 nsJNIEnv& secureEnv = nsJNIEnvRef(env);                                                                                                                         \
1011                 nsresult result = secureEnv->GetArrayRegion(type##_type, array, start, len, buf);                                       \
1012         }                                                                                                                                                                                                               \
1013
1014         IMPLEMENT_GET_ARRAY_REGION(GetBooleanArrayRegion, jboolean)
1015         IMPLEMENT_GET_ARRAY_REGION(GetByteArrayRegion, jbyte)
1016         IMPLEMENT_GET_ARRAY_REGION(GetCharArrayRegion, jchar)
1017         IMPLEMENT_GET_ARRAY_REGION(GetShortArrayRegion, jshort)
1018         IMPLEMENT_GET_ARRAY_REGION(GetIntArrayRegion, jint)
1019         IMPLEMENT_GET_ARRAY_REGION(GetLongArrayRegion, jlong)
1020         IMPLEMENT_GET_ARRAY_REGION(GetFloatArrayRegion, jfloat)
1021         IMPLEMENT_GET_ARRAY_REGION(GetDoubleArrayRegion, jdouble)
1022
1023 #undef IMPLEMENT_GET_ARRAY_REGION
1024
1025 #define IMPLEMENT_SET_ARRAY_REGION(methodName, type)                                                                                                            \
1026         static void JNICALL methodName(JNIEnv *env, type##Array array, jsize start, jsize len, type* buf)               \
1027         {                                                                                                                                                                                                               \
1028                 nsJNIEnv& secureEnv = nsJNIEnvRef(env);                                                                                                                         \
1029                 nsresult result = secureEnv->SetArrayRegion(type##_type, array, start, len, buf);                                       \
1030         }                                                                                                                                                                                                               \
1031
1032         IMPLEMENT_SET_ARRAY_REGION(SetBooleanArrayRegion, jboolean)
1033         IMPLEMENT_SET_ARRAY_REGION(SetByteArrayRegion, jbyte)
1034         IMPLEMENT_SET_ARRAY_REGION(SetCharArrayRegion, jchar)
1035         IMPLEMENT_SET_ARRAY_REGION(SetShortArrayRegion, jshort)
1036         IMPLEMENT_SET_ARRAY_REGION(SetIntArrayRegion, jint)
1037         IMPLEMENT_SET_ARRAY_REGION(SetLongArrayRegion, jlong)
1038         IMPLEMENT_SET_ARRAY_REGION(SetFloatArrayRegion, jfloat)
1039         IMPLEMENT_SET_ARRAY_REGION(SetDoubleArrayRegion, jdouble)
1040
1041 #undef IMPLEMENT_SET_ARRAY_REGION
1042
1043         static jint JNICALL RegisterNatives(JNIEnv *env, jclass clazz, const JNINativeMethod *methods, jint nMethods)
1044         {
1045                 jint outStatus = 0;
1046                 nsJNIEnv& secureEnv = nsJNIEnvRef(env);
1047                 nsresult result = secureEnv->RegisterNatives(clazz, methods, nMethods, &outStatus);
1048                 return outStatus;
1049         }
1050
1051         static jint JNICALL UnregisterNatives(JNIEnv *env, jclass clazz)
1052         {
1053                 jint outStatus = 0;
1054                 nsJNIEnv& secureEnv = nsJNIEnvRef(env);
1055                 nsresult result = secureEnv->UnregisterNatives(clazz, &outStatus);
1056                 return outStatus;
1057         }
1058
1059         static jint JNICALL MonitorEnter(JNIEnv *env, jobject obj)
1060         {
1061                 jint outStatus = 0;
1062                 nsJNIEnv& secureEnv = nsJNIEnvRef(env);
1063                 nsresult result = secureEnv->MonitorEnter(obj, &outStatus);
1064                 return outStatus;
1065         }
1066
1067         static jint JNICALL JNICALL MonitorExit(JNIEnv *env, jobject obj)
1068         {
1069                 jint outStatus = 0;
1070                 nsJNIEnv& secureEnv = nsJNIEnvRef(env);
1071                 nsresult result = secureEnv->MonitorExit(obj, &outStatus);
1072                 return outStatus;
1073         }
1074
1075         static jint JNICALL GetJavaVM(JNIEnv *env, JavaVM **vm)
1076         {
1077                 jint outStatus = 0;
1078                 nsJNIEnv& secureEnv = nsJNIEnvRef(env);
1079                 nsresult result = secureEnv->GetJavaVM(vm, &outStatus);
1080                 return outStatus;
1081         }
1082
1083 public:
1084         nsJNIEnv(nsISecureJNI2* secureEnv);
1085         ~nsJNIEnv();
1086 };
1087
1088 JNINativeInterface_ nsJNIEnv::theFuncs = {
1089         NULL,   // void *reserved0;
1090         NULL,   // void *reserved1;
1091         NULL,   // void *reserved2;
1092
1093         NULL,   // void *reserved3;
1094
1095         // jint (JNICALL *GetVersion)(JNIEnv *env);
1096         &GetVersion,
1097
1098         // jclass (JNICALL *DefineClass) (JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize len);
1099         &DefineClass,
1100
1101         // jclass (JNICALL *FindClass) (JNIEnv *env, const char *name);
1102         &FindClass,
1103
1104         NULL,   // void *reserved4;
1105         NULL,   // void *reserved5;
1106         NULL,   // void *reserved6;
1107
1108         // jclass (JNICALL *GetSuperclass) (JNIEnv *env, jclass sub);
1109         &GetSuperclass,
1110
1111         // jboolean (JNICALL *IsAssignableFrom) (JNIEnv *env, jclass sub, jclass sup);
1112         &IsAssignableFrom,
1113
1114         NULL, // void *reserved7;
1115
1116         // jint (JNICALL *Throw) (JNIEnv *env, jthrowable obj);
1117         &Throw,
1118
1119         // jint (JNICALL *ThrowNew) (JNIEnv *env, jclass clazz, const char *msg);
1120         &ThrowNew,
1121
1122         // jthrowable (JNICALL *ExceptionOccurred) (JNIEnv *env);
1123         &ExceptionOccurred,
1124
1125         // void (JNICALL *ExceptionDescribe) (JNIEnv *env);
1126         &ExceptionDescribe,
1127
1128         // void (JNICALL *ExceptionClear) (JNIEnv *env);
1129         &ExceptionClear,
1130
1131         // void (JNICALL *FatalError) (JNIEnv *env, const char *msg);
1132         &FatalError,
1133
1134         NULL, // void *reserved8;
1135         NULL, // void *reserved9;
1136
1137         // jobject (JNICALL *NewGlobalRef) (JNIEnv *env, jobject lobj);
1138         &NewGlobalRef,
1139
1140         // void (JNICALL *DeleteGlobalRef) (JNIEnv *env, jobject gref);
1141         &DeleteGlobalRef,
1142
1143         // void (JNICALL *DeleteLocalRef) (JNIEnv *env, jobject obj);
1144         &DeleteLocalRef,
1145
1146         // jboolean (JNICALL *IsSameObject) (JNIEnv *env, jobject obj1, jobject obj2);
1147         &IsSameObject,
1148
1149         NULL, // void *reserved10;
1150         NULL, // void *reserved11;
1151
1152         // jobject (JNICALL *AllocObject) (JNIEnv *env, jclass clazz);
1153         &AllocObject,
1154
1155 #define REFERENCE_METHOD_FAMILY(methodName) &methodName, &methodName##V, &methodName##A,
1156
1157         // jobject (JNICALL *NewObject) (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
1158         // jobject (JNICALL *NewObjectV) (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
1159         // jobject (JNICALL *NewObjectA) (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
1160         REFERENCE_METHOD_FAMILY(NewObject)
1161
1162         // jclass (JNICALL *GetObjectClass) (JNIEnv *env, jobject obj);
1163         &GetObjectClass,
1164
1165         // jboolean (JNICALL *IsInstanceOf) (JNIEnv *env, jobject obj, jclass clazz);
1166         &IsInstanceOf,
1167
1168         // jmethodID (JNICALL *GetMethodID)(JNIEnv *env, jclass clazz, const char *name, const char *sig);
1169         &GetMethodID,
1170
1171         // jobject (JNICALL *CallObjectMethod) (JNIEnv *env, jobject obj, jmethodID methodID, ...);
1172         // jobject (JNICALL *CallObjectMethodV) (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
1173         // jobject (JNICALL *CallObjectMethodA) (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args);
1174         REFERENCE_METHOD_FAMILY(CallObjectMethod)
1175
1176         // jboolean (JNICALL *CallBooleanMethod) (JNIEnv *env, jobject obj, jmethodID methodID, ...);
1177         // jboolean (JNICALL *CallBooleanMethodV) (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
1178         // jboolean (JNICALL *CallBooleanMethodA) (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args);
1179         REFERENCE_METHOD_FAMILY(CallBooleanMethod)
1180
1181         // jbyte (JNICALL *CallByteMethod) (JNIEnv *env, jobject obj, jmethodID methodID, ...);
1182         // jbyte (JNICALL *CallByteMethodV) (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
1183         // jbyte (JNICALL *CallByteMethodA) (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
1184         REFERENCE_METHOD_FAMILY(CallByteMethod)
1185
1186         // jchar (JNICALL *CallCharMethod) (JNIEnv *env, jobject obj, jmethodID methodID, ...);
1187         // jchar (JNICALL *CallCharMethodV) (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
1188         // jchar (JNICALL *CallCharMethodA) (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
1189         REFERENCE_METHOD_FAMILY(CallCharMethod)
1190
1191         // jshort (JNICALL *CallShortMethod) (JNIEnv *env, jobject obj, jmethodID methodID, ...);
1192         // jshort (JNICALL *CallShortMethodV) (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
1193         // jshort (JNICALL *CallShortMethodA) (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
1194         REFERENCE_METHOD_FAMILY(CallShortMethod)
1195
1196         // jint (JNICALL *CallIntMethod) (JNIEnv *env, jobject obj, jmethodID methodID, ...);
1197         // jint (JNICALL *CallIntMethodV) (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
1198         // jint (JNICALL *CallIntMethodA) (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
1199         REFERENCE_METHOD_FAMILY(CallIntMethod)
1200
1201         // jlong (JNICALL *CallLongMethod) (JNIEnv *env, jobject obj, jmethodID methodID, ...);
1202         // jlong (JNICALL *CallLongMethodV) (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
1203         // jlong (JNICALL *CallLongMethodA) (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
1204         REFERENCE_METHOD_FAMILY(CallLongMethod)
1205
1206         // jfloat (JNICALL *CallFloatMethod) (JNIEnv *env, jobject obj, jmethodID methodID, ...);
1207         // jfloat (JNICALL *CallFloatMethodV) (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
1208         // jfloat (JNICALL *CallFloatMethodA) (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
1209         REFERENCE_METHOD_FAMILY(CallFloatMethod)
1210
1211         // jdouble (JNICALL *CallDoubleMethod) (JNIEnv *env, jobject obj, jmethodID methodID, ...);
1212         // jdouble (JNICALL *CallDoubleMethodV) (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
1213         // jdouble (JNICALL *CallDoubleMethodA) (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
1214         REFERENCE_METHOD_FAMILY(CallDoubleMethod)
1215
1216         // void (JNICALL *CallVoidMethod) (JNIEnv *env, jobject obj, jmethodID methodID, ...);
1217         // void (JNICALL *CallVoidMethodV) (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
1218         // void (JNICALL *CallVoidMethodA) (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args);
1219         REFERENCE_METHOD_FAMILY(CallVoidMethod)
1220
1221         // jobject (JNICALL *CallNonvirtualObjectMethod) (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
1222         // jobject (JNICALL *CallNonvirtualObjectMethodV) (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args);
1223         // jobject (JNICALL *CallNonvirtualObjectMethodA) (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue * args);
1224         REFERENCE_METHOD_FAMILY(CallNonvirtualObjectMethod)
1225
1226         // jboolean (JNICALL *CallNonvirtualBooleanMethod) (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
1227         // jboolean (JNICALL *CallNonvirtualBooleanMethodV) (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args);
1228         // jboolean (JNICALL *CallNonvirtualBooleanMethodA) (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue * args);
1229         REFERENCE_METHOD_FAMILY(CallNonvirtualBooleanMethod)
1230
1231         // jbyte (JNICALL *CallNonvirtualByteMethod) (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
1232         // jbyte (JNICALL *CallNonvirtualByteMethodV) (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args);
1233         // jbyte (JNICALL *CallNonvirtualByteMethodA) (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args);
1234         REFERENCE_METHOD_FAMILY(CallNonvirtualByteMethod)
1235
1236         // jchar (JNICALL *CallNonvirtualCharMethod) (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
1237         // jchar (JNICALL *CallNonvirtualCharMethodV) (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args);
1238         // jchar (JNICALL *CallNonvirtualCharMethodA) (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args);
1239         REFERENCE_METHOD_FAMILY(CallNonvirtualCharMethod)
1240
1241         // jshort (JNICALL *CallNonvirtualShortMethod) (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
1242         // jshort (JNICALL *CallNonvirtualShortMethodV) (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args);
1243         // jshort (JNICALL *CallNonvirtualShortMethodA) (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args);
1244         REFERENCE_METHOD_FAMILY(CallNonvirtualShortMethod)
1245
1246         // jint (JNICALL *CallNonvirtualIntMethod) (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
1247         // jint (JNICALL *CallNonvirtualIntMethodV) (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args);
1248         // jint (JNICALL *CallNonvirtualIntMethodA) (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args);
1249         REFERENCE_METHOD_FAMILY(CallNonvirtualIntMethod)
1250
1251         // jlong (JNICALL *CallNonvirtualLongMethod) (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
1252         // jlong (JNICALL *CallNonvirtualLongMethodV) (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args);
1253         // jlong (JNICALL *CallNonvirtualLongMethodA) (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args);
1254         REFERENCE_METHOD_FAMILY(CallNonvirtualLongMethod)
1255
1256         // jfloat (JNICALL *CallNonvirtualFloatMethod) (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
1257         // jfloat (JNICALL *CallNonvirtualFloatMethodV) (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args);
1258         // jfloat (JNICALL *CallNonvirtualFloatMethodA) (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args);
1259         REFERENCE_METHOD_FAMILY(CallNonvirtualFloatMethod)
1260
1261         // jdouble (JNICALL *CallNonvirtualDoubleMethod) (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
1262         // jdouble (JNICALL *CallNonvirtualDoubleMethodV) (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args);
1263         // jdouble (JNICALL *CallNonvirtualDoubleMethodA) (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args);
1264         REFERENCE_METHOD_FAMILY(CallNonvirtualDoubleMethod)
1265
1266         // void (JNICALL *CallNonvirtualVoidMethod) (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
1267         // void (JNICALL *CallNonvirtualVoidMethodV) (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args);
1268         // void (JNICALL *CallNonvirtualVoidMethodA) (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue * args);
1269         REFERENCE_METHOD_FAMILY(CallNonvirtualVoidMethod)
1270
1271         // jfieldID (JNICALL *GetFieldID) (JNIEnv *env, jclass clazz, const char *name, const char *sig);
1272         &GetFieldID,
1273
1274         // jobject (JNICALL *GetObjectField) (JNIEnv *env, jobject obj, jfieldID fieldID);
1275         // jboolean (JNICALL *GetBooleanField) (JNIEnv *env, jobject obj, jfieldID fieldID);
1276         // jbyte (JNICALL *GetByteField) (JNIEnv *env, jobject obj, jfieldID fieldID);
1277         // jchar (JNICALL *GetCharField) (JNIEnv *env, jobject obj, jfieldID fieldID);
1278         // jshort (JNICALL *GetShortField) (JNIEnv *env, jobject obj, jfieldID fieldID);
1279         // jint (JNICALL *GetIntField) (JNIEnv *env, jobject obj, jfieldID fieldID);
1280         // jlong (JNICALL *GetLongField) (JNIEnv *env, jobject obj, jfieldID fieldID);
1281         // jfloat (JNICALL *GetFloatField) (JNIEnv *env, jobject obj, jfieldID fieldID);
1282         // jdouble (JNICALL *GetDoubleField) (JNIEnv *env, jobject obj, jfieldID fieldID);
1283         &GetObjectField, &GetBooleanField, &GetByteField, &GetCharField, &GetShortField, &GetIntField, &GetLongField,
1284         &GetFloatField, &GetDoubleField,
1285
1286         // void (JNICALL *SetObjectField) (JNIEnv *env, jobject obj, jfieldID fieldID, jobject val);
1287         // void (JNICALL *SetBooleanField) (JNIEnv *env, jobject obj, jfieldID fieldID, jboolean val);
1288         // void (JNICALL *SetByteField) (JNIEnv *env, jobject obj, jfieldID fieldID, jbyte val);
1289         // void (JNICALL *SetCharField) (JNIEnv *env, jobject obj, jfieldID fieldID, jchar val);
1290         // void (JNICALL *SetShortField) (JNIEnv *env, jobject obj, jfieldID fieldID, jshort val);
1291         // void (JNICALL *SetIntField) (JNIEnv *env, jobject obj, jfieldID fieldID, jint val);
1292         // void (JNICALL *SetLongField) (JNIEnv *env, jobject obj, jfieldID fieldID, jlong val);
1293         // void (JNICALL *SetFloatField) (JNIEnv *env, jobject obj, jfieldID fieldID, jfloat val);
1294         // void (JNICALL *SetDoubleField) (JNIEnv *env, jobject obj, jfieldID fieldID, jdouble val);
1295         &SetObjectField, &SetBooleanField, &SetByteField, &SetCharField, &SetShortField, &SetIntField, &SetLongField,
1296         &SetFloatField, &SetDoubleField,
1297
1298         // jmethodID (JNICALL *GetStaticMethodID) (JNIEnv *env, jclass clazz, const char *name, const char *sig);
1299         &GetStaticMethodID,
1300
1301         // jobject (JNICALL *CallStaticObjectMethod) (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
1302         // jobject (JNICALL *CallStaticObjectMethodV) (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
1303         // jobject (JNICALL *CallStaticObjectMethodA) (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
1304         REFERENCE_METHOD_FAMILY(CallStaticObjectMethod)
1305
1306         // jboolean (JNICALL *CallStaticBooleanMethod) (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
1307         // jboolean (JNICALL *CallStaticBooleanMethodV) (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
1308         // jboolean (JNICALL *CallStaticBooleanMethodA) (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
1309         REFERENCE_METHOD_FAMILY(CallStaticBooleanMethod)
1310
1311         // jbyte (JNICALL *CallStaticByteMethod) (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
1312         // jbyte (JNICALL *CallStaticByteMethodV) (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
1313         // jbyte (JNICALL *CallStaticByteMethodA) (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
1314         REFERENCE_METHOD_FAMILY(CallStaticByteMethod)
1315
1316         // jchar (JNICALL *CallStaticCharMethod) (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
1317         // jchar (JNICALL *CallStaticCharMethodV) (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
1318         // jchar (JNICALL *CallStaticCharMethodA) (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
1319         REFERENCE_METHOD_FAMILY(CallStaticCharMethod)
1320
1321         // jshort (JNICALL *CallStaticShortMethod) (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
1322         // jshort (JNICALL *CallStaticShortMethodV) (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
1323         // jshort (JNICALL *CallStaticShortMethodA) (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
1324         REFERENCE_METHOD_FAMILY(CallStaticShortMethod)
1325
1326         // jint (JNICALL *CallStaticIntMethod) (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
1327         // jint (JNICALL *CallStaticIntMethodV) (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
1328         // jint (JNICALL *CallStaticIntMethodA) (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
1329         REFERENCE_METHOD_FAMILY(CallStaticIntMethod)
1330
1331         // jlong (JNICALL *CallStaticLongMethod) (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
1332         // jlong (JNICALL *CallStaticLongMethodV) (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
1333         // jlong (JNICALL *CallStaticLongMethodA) (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
1334         REFERENCE_METHOD_FAMILY(CallStaticLongMethod)
1335
1336         // jfloat (JNICALL *CallStaticFloatMethod) (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
1337         // jfloat (JNICALL *CallStaticFloatMethodV) (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
1338         // jfloat (JNICALL *CallStaticFloatMethodA) (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
1339         REFERENCE_METHOD_FAMILY(CallStaticFloatMethod)
1340
1341         // jdouble (JNICALL *CallStaticDoubleMethod) (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
1342         // jdouble (JNICALL *CallStaticDoubleMethodV) (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
1343         // jdouble (JNICALL *CallStaticDoubleMethodA) (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
1344         REFERENCE_METHOD_FAMILY(CallStaticDoubleMethod)
1345
1346         // void (JNICALL *CallStaticVoidMethod) (JNIEnv *env, jclass cls, jmethodID methodID, ...);
1347         // void (JNICALL *CallStaticVoidMethodV) (JNIEnv *env, jclass cls, jmethodID methodID, va_list args);
1348         // void (JNICALL *CallStaticVoidMethodA) (JNIEnv *env, jclass cls, jmethodID methodID, jvalue * args);
1349         REFERENCE_METHOD_FAMILY(CallStaticVoidMethod)
1350
1351         // jfieldID (JNICALL *GetStaticFieldID) (JNIEnv *env, jclass clazz, const char *name, const char *sig);
1352         &GetStaticFieldID,
1353
1354         // jobject (JNICALL *GetStaticObjectField) (JNIEnv *env, jclass clazz, jfieldID fieldID);
1355         // jboolean (JNICALL *GetStaticBooleanField) (JNIEnv *env, jclass clazz, jfieldID fieldID);
1356         // jbyte (JNICALL *GetStaticByteField) (JNIEnv *env, jclass clazz, jfieldID fieldID);
1357         // jchar (JNICALL *GetStaticCharField) (JNIEnv *env, jclass clazz, jfieldID fieldID);
1358         // jshort (JNICALL *GetStaticShortField) (JNIEnv *env, jclass clazz, jfieldID fieldID);
1359         // jint (JNICALL *GetStaticIntField) (JNIEnv *env, jclass clazz, jfieldID fieldID);
1360         // jlong (JNICALL *GetStaticLongField) (JNIEnv *env, jclass clazz, jfieldID fieldID);
1361         // jfloat (JNICALL *GetStaticFloatField) (JNIEnv *env, jclass clazz, jfieldID fieldID);
1362         // jdouble (JNICALL *GetStaticDoubleField) (JNIEnv *env, jclass clazz, jfieldID fieldID);
1363         &GetStaticObjectField, &GetStaticBooleanField, &GetStaticByteField, &GetStaticCharField, &GetStaticShortField,
1364         &GetStaticIntField, &GetStaticLongField, &GetStaticFloatField, &GetStaticDoubleField,
1365
1366         // void (JNICALL *SetStaticObjectField) (JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value);
1367         // void (JNICALL *SetStaticBooleanField) (JNIEnv *env, jclass clazz, jfieldID fieldID, jboolean value);
1368         // void (JNICALL *SetStaticByteField) (JNIEnv *env, jclass clazz, jfieldID fieldID, jbyte value);
1369         // void (JNICALL *SetStaticCharField) (JNIEnv *env, jclass clazz, jfieldID fieldID, jchar value);
1370         // void (JNICALL *SetStaticShortField) (JNIEnv *env, jclass clazz, jfieldID fieldID, jshort value);
1371         // void (JNICALL *SetStaticIntField) (JNIEnv *env, jclass clazz, jfieldID fieldID, jint value);
1372         // void (JNICALL *SetStaticLongField) (JNIEnv *env, jclass clazz, jfieldID fieldID, jlong value);
1373         // void (JNICALL *SetStaticFloatField) (JNIEnv *env, jclass clazz, jfieldID fieldID, jfloat value);
1374         // void (JNICALL *SetStaticDoubleField) (JNIEnv *env, jclass clazz, jfieldID fieldID, jdouble value);
1375         &SetStaticObjectField, &SetStaticBooleanField, &SetStaticByteField, &SetStaticCharField, &SetStaticShortField,
1376         &SetStaticIntField, &SetStaticLongField, &SetStaticFloatField, &SetStaticDoubleField,
1377
1378         // jstring (JNICALL *NewString) (JNIEnv *env, const jchar *unicode, jsize len);
1379         // jsize (JNICALL *GetStringLength) (JNIEnv *env, jstring str);
1380         // const jchar *(JNICALL *GetStringChars) (JNIEnv *env, jstring str, jboolean *isCopy);
1381         // void (JNICALL *ReleaseStringChars) (JNIEnv *env, jstring str, const jchar *chars);
1382         &NewString, &GetStringLength, &GetStringChars, &ReleaseStringChars,
1383
1384         // jstring (JNICALL *NewStringUTF) (JNIEnv *env, const char *utf);
1385         // jsize (JNICALL *GetStringUTFLength) (JNIEnv *env, jstring str);
1386         // const char* (JNICALL *GetStringUTFChars) (JNIEnv *env, jstring str, jboolean *isCopy);
1387         // void (JNICALL *ReleaseStringUTFChars) (JNIEnv *env, jstring str, const char* chars);
1388         &NewStringUTF, &GetStringUTFLength, &GetStringUTFChars, &ReleaseStringUTFChars,
1389
1390         // jsize (JNICALL *GetArrayLength) (JNIEnv *env, jarray array);
1391         &GetArrayLength,
1392
1393         // jobjectArray (JNICALL *NewObjectArray) (JNIEnv *env, jsize len, jclass clazz, jobject init);
1394         // jobject (JNICALL *GetObjectArrayElement) (JNIEnv *env, jobjectArray array, jsize index);
1395         // void (JNICALL *SetObjectArrayElement) (JNIEnv *env, jobjectArray array, jsize index, jobject val);
1396         &NewObjectArray, &GetObjectArrayElement, &SetObjectArrayElement,
1397
1398         // jbooleanArray (JNICALL *NewBooleanArray) (JNIEnv *env, jsize len);
1399         // jbyteArray (JNICALL *NewByteArray) (JNIEnv *env, jsize len);
1400         // jcharArray (JNICALL *NewCharArray) (JNIEnv *env, jsize len);
1401         // jshortArray (JNICALL *NewShortArray) (JNIEnv *env, jsize len);
1402         // jintArray (JNICALL *NewIntArray) (JNIEnv *env, jsize len);
1403         // jlongArray (JNICALL *NewLongArray) (JNIEnv *env, jsize len);
1404         // jfloatArray (JNICALL *NewFloatArray) (JNIEnv *env, jsize len);
1405         // jdoubleArray (JNICALL *NewDoubleArray) (JNIEnv *env, jsize len);
1406         &NewBooleanArray, &NewByteArray, &NewCharArray, &NewShortArray,
1407         &NewIntArray, &NewLongArray, &NewFloatArray, &NewDoubleArray,
1408
1409         // jboolean * (JNICALL *GetBooleanArrayElements) (JNIEnv *env, jbooleanArray array, jboolean *isCopy);
1410         // jbyte * (JNICALL *GetByteArrayElements) (JNIEnv *env, jbyteArray array, jboolean *isCopy);
1411         // jchar * (JNICALL *GetCharArrayElements) (JNIEnv *env, jcharArray array, jboolean *isCopy);
1412         // jshort * (JNICALL *GetShortArrayElements) (JNIEnv *env, jshortArray array, jboolean *isCopy);
1413         // jint * (JNICALL *GetIntArrayElements) (JNIEnv *env, jintArray array, jboolean *isCopy);
1414         // jlong * (JNICALL *GetLongArrayElements) (JNIEnv *env, jlongArray array, jboolean *isCopy);
1415         // jfloat * (JNICALL *GetFloatArrayElements) (JNIEnv *env, jfloatArray array, jboolean *isCopy);
1416         // jdouble * (JNICALL *GetDoubleArrayElements) (JNIEnv *env, jdoubleArray array, jboolean *isCopy);
1417         &GetBooleanArrayElements, &GetByteArrayElements, &GetCharArrayElements, &GetShortArrayElements,
1418         &GetIntArrayElements, &GetLongArrayElements, &GetFloatArrayElements, &GetDoubleArrayElements,
1419
1420         // void (JNICALL *ReleaseBooleanArrayElements)(JNIEnv *env, jbooleanArray array, jboolean *elems, jint mode);
1421         // void (JNICALL *ReleaseByteArrayElements) (JNIEnv *env, jbyteArray array, jbyte *elems, jint mode);
1422         // void (JNICALL *ReleaseCharArrayElements) (JNIEnv *env, jcharArray array, jchar *elems, jint mode);
1423         // void (JNICALL *ReleaseShortArrayElements) (JNIEnv *env, jshortArray array, jshort *elems, jint mode);
1424         // void (JNICALL *ReleaseIntArrayElements) (JNIEnv *env, jintArray array, jint *elems, jint mode);
1425         // void (JNICALL *ReleaseLongArrayElements) (JNIEnv *env, jlongArray array, jlong *elems, jint mode);
1426         // void (JNICALL *ReleaseFloatArrayElements) (JNIEnv *env, jfloatArray array, jfloat *elems, jint mode);
1427         // void (JNICALL *ReleaseDoubleArrayElements) (JNIEnv *env, jdoubleArray array, jdouble *elems, jint mode);
1428         &ReleaseBooleanArrayElements, &ReleaseByteArrayElements, &ReleaseCharArrayElements, &ReleaseShortArrayElements,
1429         &ReleaseIntArrayElements, &ReleaseLongArrayElements, &ReleaseFloatArrayElements, &ReleaseDoubleArrayElements,
1430
1431         // void (JNICALL *GetBooleanArrayRegion) (JNIEnv *env, jbooleanArray array, jsize start, jsize l, jboolean *buf);
1432         // void (JNICALL *GetByteArrayRegion) (JNIEnv *env, jbyteArray array, jsize start, jsize len, jbyte *buf);
1433         // void (JNICALL *GetCharArrayRegion) (JNIEnv *env, jcharArray array, jsize start, jsize len, jchar *buf);
1434         // void (JNICALL *GetShortArrayRegion) (JNIEnv *env, jshortArray array, jsize start, jsize len, jshort *buf);
1435         // void (JNICALL *GetIntArrayRegion) (JNIEnv *env, jintArray array, jsize start, jsize len, jint *buf);
1436         // void (JNICALL *GetLongArrayRegion) (JNIEnv *env, jlongArray array, jsize start, jsize len, jlong *buf);
1437         // void (JNICALL *GetFloatArrayRegion) (JNIEnv *env, jfloatArray array, jsize start, jsize len, jfloat *buf);
1438         // void (JNICALL *GetDoubleArrayRegion) (JNIEnv *env, jdoubleArray array, jsize start, jsize len, jdouble *buf);
1439         &GetBooleanArrayRegion, &GetByteArrayRegion, &GetCharArrayRegion, &GetShortArrayRegion,
1440         &GetIntArrayRegion, &GetLongArrayRegion, &GetFloatArrayRegion, &GetDoubleArrayRegion,
1441
1442         // void (JNICALL *SetBooleanArrayRegion) (JNIEnv *env, jbooleanArray array, jsize start, jsize l, jboolean *buf);
1443         // void (JNICALL *SetByteArrayRegion) (JNIEnv *env, jbyteArray array, jsize start, jsize len, jbyte *buf);
1444         // void (JNICALL *SetCharArrayRegion) (JNIEnv *env, jcharArray array, jsize start, jsize len, jchar *buf);
1445         // void (JNICALL *SetShortArrayRegion) (JNIEnv *env, jshortArray array, jsize start, jsize len, jshort *buf);
1446         // void (JNICALL *SetIntArrayRegion) (JNIEnv *env, jintArray array, jsize start, jsize len, jint *buf);
1447         // void (JNICALL *SetLongArrayRegion) (JNIEnv *env, jlongArray array, jsize start, jsize len, jlong *buf);
1448         // void (JNICALL *SetFloatArrayRegion) (JNIEnv *env, jfloatArray array, jsize start, jsize len, jfloat *buf);
1449         // void (JNICALL *SetDoubleArrayRegion) (JNIEnv *env, jdoubleArray array, jsize start, jsize len, jdouble *buf);
1450         &SetBooleanArrayRegion, &SetByteArrayRegion, &SetCharArrayRegion, &SetShortArrayRegion,
1451         &SetIntArrayRegion, &SetLongArrayRegion, &SetFloatArrayRegion, &SetDoubleArrayRegion,
1452
1453         // jint (JNICALL *RegisterNatives) (JNIEnv *env, jclass clazz, const JNINativeMethod *methods, jint nMethods);
1454         // jint (JNICALL *UnregisterNatives) (JNIEnv *env, jclass clazz);
1455         &RegisterNatives, &UnregisterNatives,
1456
1457         // jint (JNICALL *MonitorEnter) (JNIEnv *env, jobject obj);
1458         // jint (JNICALL *MonitorExit) (JNIEnv *env, jobject obj);
1459         &MonitorEnter, &MonitorExit,
1460
1461         // jint (JNICALL *GetJavaVM) (JNIEnv *env, JavaVM **vm);
1462         &GetJavaVM
1463 };
1464
1465 nsHashtable* nsJNIEnv::theIDTable = NULL;
1466
1467 nsJNIEnv::nsJNIEnv(nsISecureJNI2* secureEnv)
1468         :       mSecureEnv(secureEnv), mContext(NULL), mJavaThread(NULL)
1469 {
1470         this->functions = &theFuncs;
1471         if (theIDTable == NULL)
1472                 theIDTable = new nsHashtable();
1473 }
1474
1475 nsJNIEnv::~nsJNIEnv()
1476 {
1477         this->functions = NULL;
1478 }