Remove dynamic calls to FindClass.

Initially, I was just fixing a threading bug in NativeDecimalFormat.cpp where
we were bypassing GCC's built-in static initializer thread safety. This led me
to the question of how expensive FindClass is, which led me to creating a new
canonical cache of jclasses.

Here's the motivating benchmark, showing the cost of calling an empty regular
(non-native) method, an empty native method, a native method that calls
FindClass, a native method that calls FindClass and GetFieldID, and a native
method that calls FindClass and GetMethodID:

             benchmark    ns logarithmic runtime
         NoArgsRegular    74 ||||||||||||||
          NoArgsNative   428 XX|||||||||||||||||||
             FindClass  3064 XXXXXXXXXXXXXXXX|||||||||||
     FindClassGetField  3654 XXXXXXXXXXXXXXXXXXX|||||||||
    FindClassGetMethod  5634 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Change-Id: I41ab2b347895f043a7e21d8fa19e4541e198c3fc

23 files changed, 306 insertions, 308 deletions

diff --git a/luni/src/main/native/BidiWrapper.cpp b/luni/src/main/native/BidiWrapper.cpp
index 59dcfaa..f703586 100644
--- a/luni/src/main/native/BidiWrapper.cpp
+++ b/luni/src/main/native/BidiWrapper.cpp
@@ -16,11 +16,13 @@
  */
 #define LOG_TAG "BidiWrapper"
 
-#include <JNIHelp.h>
 #include "ErrorCode.h"
+#include "JNIHelp.h"
+#include "JniConstants.h"
 #include "ScopedPrimitiveArray.h"
 #include "UniquePtr.h"
 #include "unicode/ubidi.h"
+
 #include <stdlib.h>
 #include <string.h>
 
@@ -135,15 +137,14 @@ static jobjectArray BidiWrapper_ubidi_getRuns(JNIEnv* env, jclass, jlong ptr) {
     if (icu4jni_error(env, err)) {
         return NULL;
     }
-    jclass bidiRunClass = env->FindClass("org/apache/harmony/text/BidiRun");
-    jmethodID bidiRunConstructor = env->GetMethodID(bidiRunClass, "<init>", "(III)V");
-    jobjectArray runs = env->NewObjectArray(runCount, bidiRunClass, NULL);
+    jmethodID bidiRunConstructor = env->GetMethodID(JniConstants::bidiRunClass, "<init>", "(III)V");
+    jobjectArray runs = env->NewObjectArray(runCount, JniConstants::bidiRunClass, NULL);
     UBiDiLevel level = 0;
     int start = 0;
     int limit = 0;
     for (int i = 0; i < runCount; ++i) {
         ubidi_getLogicalRun(ubidi, start, &limit, &level);
-        jobject run = env->NewObject(bidiRunClass, bidiRunConstructor, start, limit, level);
+        jobject run = env->NewObject(JniConstants::bidiRunClass, bidiRunConstructor, start, limit, level);
         env->SetObjectArrayElement(runs, i, run);
         start = limit;
     }
diff --git a/luni/src/main/native/ICU.cpp b/luni/src/main/native/ICU.cpp
index 329b494..8df7c7e 100644
--- a/luni/src/main/native/ICU.cpp
+++ b/luni/src/main/native/ICU.cpp
@@ -18,6 +18,7 @@
 
 #include "ErrorCode.h"
 #include "JNIHelp.h"
+#include "JniConstants.h"
 #include "ScopedLocalRef.h"
 #include "ScopedUtfChars.h"
 #include "UniquePtr.h"
@@ -47,8 +48,6 @@
 #include <time.h>
 #include <sys/time.h>
 
-static jclass string_class;
-
 class ScopedResourceBundle {
 public:
     ScopedResourceBundle(UResourceBundle* bundle) : mBundle(bundle) {
@@ -213,7 +212,7 @@ static jobjectArray toStringArray(JNIEnv* env, const char* const* strings) {
     while (strings[count] != NULL) {
         ++count;
     }
-    jobjectArray result = env->NewObjectArray(count, string_class, NULL);
+    jobjectArray result = env->NewObjectArray(count, JniConstants::stringClass, NULL);
     for (size_t i = 0; i < count; ++i) {
         ScopedLocalRef<jstring> s(env, env->NewStringUTF(strings[i]));
         env->SetObjectArrayElement(result, i, s.get());
@@ -232,7 +231,7 @@ static jobjectArray getISOLanguagesNative(JNIEnv* env, jclass) {
 template <typename Counter, typename Getter>
 static jobjectArray getAvailableLocales(JNIEnv* env, Counter* counter, Getter* getter) {
     size_t count = (*counter)();
-    jobjectArray result = env->NewObjectArray(count, string_class, NULL);
+    jobjectArray result = env->NewObjectArray(count, JniConstants::stringClass, NULL);
     for (size_t i = 0; i < count; ++i) {
         ScopedLocalRef<jstring> s(env, env->NewStringUTF((*getter)(i)));
         env->SetObjectArrayElement(result, i, s.get());
@@ -386,7 +385,7 @@ static jobjectArray getAmPmMarkers(JNIEnv* env, UResourceBundle* gregorian) {
         return NULL;
     }
 
-    jobjectArray amPmMarkers = env->NewObjectArray(2, string_class, NULL);
+    jobjectArray amPmMarkers = env->NewObjectArray(2, JniConstants::stringClass, NULL);
     ScopedLocalRef<jstring> amU(env, env->NewString(am, lengthAm));
     env->SetObjectArrayElement(amPmMarkers, 0, amU.get());
     ScopedLocalRef<jstring> pmU(env, env->NewString(pm, lengthPm));
@@ -408,7 +407,7 @@ static jobjectArray getEras(JNIEnv* env, UResourceBundle* gregorian) {
     }
 
     int eraCount = ures_getSize(eraElems.get());
-    jobjectArray eras = env->NewObjectArray(eraCount, string_class, NULL);
+    jobjectArray eras = env->NewObjectArray(eraCount, JniConstants::stringClass, NULL);
     for (int i = 0; i < eraCount; ++i) {
         int eraLength;
         const jchar* era = ures_getStringByIndex(eraElems.get(), i, &eraLength, &status);
@@ -435,7 +434,7 @@ static jobjectArray getNames(JNIEnv* env, UResourceBundle* namesBundle, bool mon
 
     // The months array has a trailing empty string. The days array has a leading empty string.
     int count = ures_getSize(valuesBundle.get());
-    jobjectArray result = env->NewObjectArray(count + 1, string_class, NULL);
+    jobjectArray result = env->NewObjectArray(count + 1, JniConstants::stringClass, NULL);
     env->SetObjectArrayElement(result, months ? count : 0, env->NewStringUTF(""));
     int arrayOffset = months ? 0 : 1;
     for (int i = 0; i < count; ++i) {
@@ -467,20 +466,17 @@ static jstring getIntCurrencyCode(JNIEnv* env, jstring locale) {
 
 static void setIntegerField(JNIEnv* env, jobject obj, const char* fieldName, int value) {
     ScopedLocalRef<jobject> integerValue(env, integerValueOf(env, value));
-    jclass localeDataClass = env->FindClass("com/ibm/icu4jni/util/LocaleData");
-    jfieldID fid = env->GetFieldID(localeDataClass, fieldName, "Ljava/lang/Integer;");
+    jfieldID fid = env->GetFieldID(JniConstants::localeDataClass, fieldName, "Ljava/lang/Integer;");
     env->SetObjectField(obj, fid, integerValue.get());
 }
 
 static void setStringField(JNIEnv* env, jobject obj, const char* fieldName, jstring value) {
-    jclass localeDataClass = env->FindClass("com/ibm/icu4jni/util/LocaleData");
-    jfieldID fid = env->GetFieldID(localeDataClass, fieldName, "Ljava/lang/String;");
+    jfieldID fid = env->GetFieldID(JniConstants::localeDataClass, fieldName, "Ljava/lang/String;");
     env->SetObjectField(obj, fid, value);
 }
 
 static void setStringArrayField(JNIEnv* env, jobject obj, const char* fieldName, jobjectArray value) {
-    jclass localeDataClass = env->FindClass("com/ibm/icu4jni/util/LocaleData");
-    jfieldID fid = env->GetFieldID(localeDataClass, fieldName, "[Ljava/lang/String;");
+    jfieldID fid = env->GetFieldID(JniConstants::localeDataClass, fieldName, "[Ljava/lang/String;");
     env->SetObjectField(obj, fid, value);
 }
 
@@ -500,8 +496,7 @@ static void setCharField(JNIEnv* env, jobject obj, const char* fieldName, UResou
     int charCount;
     const UChar* chars = ures_getStringByIndex(bundle, index, &charCount, &status);
     if (U_SUCCESS(status)) {
-        jclass localeDataClass = env->FindClass("com/ibm/icu4jni/util/LocaleData");
-        jfieldID fid = env->GetFieldID(localeDataClass, fieldName, "C");
+        jfieldID fid = env->GetFieldID(JniConstants::localeDataClass, fieldName, "C");
         env->SetCharField(obj, fid, chars[0]);
     } else {
         LOGE("Error setting char field %s from ICU resource: %s", fieldName, u_errorName(status));
@@ -653,11 +648,5 @@ static JNINativeMethod gMethods[] = {
     {"initLocaleDataImpl", "(Ljava/lang/String;Lcom/ibm/icu4jni/util/LocaleData;)Z", (void*) initLocaleDataImpl},
 };
 int register_com_ibm_icu4jni_util_Resources(JNIEnv* env) {
-    jclass stringclass = env->FindClass("java/lang/String");
-    if (stringclass == NULL) {
-        return -1;
-    }
-    string_class = (jclass) env->NewGlobalRef(stringclass);
-
     return jniRegisterNativeMethods(env, "com/ibm/icu4jni/util/ICU", gMethods, NELEM(gMethods));
 }
diff --git a/luni/src/main/native/JniConstants.cpp b/luni/src/main/native/JniConstants.cpp
new file mode 100644
index 0000000..0292357
--- /dev/null
+++ b/luni/src/main/native/JniConstants.cpp
@@ -0,0 +1,86 @@
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "JniConstants.h"
+
+#include <stdlib.h>
+
+jclass JniConstants::bidiRunClass;
+jclass JniConstants::bigDecimalClass;
+jclass JniConstants::booleanClass;
+jclass JniConstants::byteClass;
+jclass JniConstants::byteArrayClass;
+jclass JniConstants::charsetICUClass;
+jclass JniConstants::constructorClass;
+jclass JniConstants::datagramPacketClass;
+jclass JniConstants::deflaterClass;
+jclass JniConstants::doubleClass;
+jclass JniConstants::fieldClass;
+jclass JniConstants::fieldPositionIteratorClass;
+jclass JniConstants::fileDescriptorClass;
+jclass JniConstants::genericIPMreqClass;
+jclass JniConstants::inetAddressClass;
+jclass JniConstants::inflaterClass;
+jclass JniConstants::integerClass;
+jclass JniConstants::interfaceAddressClass;
+jclass JniConstants::localeDataClass;
+jclass JniConstants::longClass;
+jclass JniConstants::methodClass;
+jclass JniConstants::parsePositionClass;
+jclass JniConstants::patternSyntaxExceptionClass;
+jclass JniConstants::socketClass;
+jclass JniConstants::socketImplClass;
+jclass JniConstants::stringClass;
+jclass JniConstants::vmRuntimeClass;
+
+static jclass findClass(JNIEnv* env, const char* name) {
+    jclass result = reinterpret_cast<jclass>(env->NewGlobalRef(env->FindClass(name)));
+    if (result == NULL) {
+        LOGE("failed to find class '%s'", name);
+        abort();
+    }
+    return result;
+}
+
+void JniConstants::init(JNIEnv* env) {
+    bidiRunClass = findClass(env, "org/apache/harmony/text/BidiRun");
+    bigDecimalClass = findClass(env, "java/math/BigDecimal");
+    booleanClass = findClass(env, "java/lang/Boolean");
+    byteClass = findClass(env, "java/lang/Byte");
+    byteArrayClass = findClass(env, "[B");
+    charsetICUClass = findClass(env, "com/ibm/icu4jni/charset/CharsetICU");
+    constructorClass = findClass(env, "java/lang/reflect/Constructor");
+    datagramPacketClass = findClass(env, "java/net/DatagramPacket");
+    deflaterClass = findClass(env, "java/util/zip/Deflater");
+    doubleClass = findClass(env, "java/lang/Double");
+    fieldClass = findClass(env, "java/lang/reflect/Field");
+    fieldPositionIteratorClass = findClass(env, "com/ibm/icu4jni/text/NativeDecimalFormat$FieldPositionIterator");
+    fileDescriptorClass = findClass(env, "java/io/FileDescriptor");
+    genericIPMreqClass = findClass(env, "org/apache/harmony/luni/net/GenericIPMreq");
+    inetAddressClass = findClass(env, "java/net/InetAddress");
+    inflaterClass = findClass(env, "java/util/zip/Inflater");
+    integerClass = findClass(env, "java/lang/Integer");
+    interfaceAddressClass = findClass(env, "java/net/InterfaceAddress");
+    localeDataClass = findClass(env, "com/ibm/icu4jni/util/LocaleData");
+    longClass = findClass(env, "java/lang/Long");
+    methodClass = findClass(env, "java/lang/reflect/Method");
+    parsePositionClass = findClass(env, "java/text/ParsePosition");
+    patternSyntaxExceptionClass = findClass(env, "java/util/regex/PatternSyntaxException");
+    socketClass = findClass(env, "java/net/Socket");
+    socketImplClass = findClass(env, "java/net/SocketImpl");
+    stringClass = findClass(env, "java/lang/String");
+    vmRuntimeClass = findClass(env, "dalvik/system/VMRuntime");
+}
diff --git a/luni/src/main/native/JniConstants.h b/luni/src/main/native/JniConstants.h
new file mode 100644
index 0000000..e5898f2
--- /dev/null
+++ b/luni/src/main/native/JniConstants.h
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef JNI_CONSTANTS_H_included
+#define JNI_CONSTANTS_H_included
+
+#include "JNIHelp.h"
+
+struct JniConstants {
+    static void init(JNIEnv* env);
+
+    static jclass bidiRunClass;
+    static jclass bigDecimalClass;
+    static jclass booleanClass;
+    static jclass byteClass;
+    static jclass byteArrayClass;
+    static jclass charsetICUClass;
+    static jclass constructorClass;
+    static jclass datagramPacketClass;
+    static jclass deflaterClass;
+    static jclass doubleClass;
+    static jclass fieldClass;
+    static jclass fieldPositionIteratorClass;
+    static jclass fileDescriptorClass;
+    static jclass genericIPMreqClass;
+    static jclass inetAddressClass;
+    static jclass inflaterClass;
+    static jclass integerClass;
+    static jclass interfaceAddressClass;
+    static jclass localeDataClass;
+    static jclass longClass;
+    static jclass methodClass;
+    static jclass parsePositionClass;
+    static jclass patternSyntaxExceptionClass;
+    static jclass socketClass;
+    static jclass socketImplClass;
+    static jclass stringClass;
+    static jclass vmRuntimeClass;
+};
+
+#endif  // JNI_CONSTANTS_H_included
diff --git a/luni/src/main/native/NativeConverter.cpp b/luni/src/main/native/NativeConverter.cpp
index 35fcf6f..2d99383 100644
--- a/luni/src/main/native/NativeConverter.cpp
+++ b/luni/src/main/native/NativeConverter.cpp
@@ -19,6 +19,7 @@
 
 #include "ErrorCode.h"
 #include "JNIHelp.h"
+#include "JniConstants.h"
 #include "ScopedLocalRef.h"
 #include "ScopedPrimitiveArray.h"
 #include "ScopedUtfChars.h"
@@ -300,7 +301,7 @@ static jstring getJavaCanonicalName(JNIEnv* env, const char* icuCanonicalName) {
 
 static jobjectArray NativeConverter_getAvailableCharsetNames(JNIEnv* env, jclass) {
     int32_t num = ucnv_countAvailable();
-    jobjectArray result = env->NewObjectArray(num, env->FindClass("java/lang/String"), NULL);
+    jobjectArray result = env->NewObjectArray(num, JniConstants::stringClass, NULL);
     for (int i = 0; i < num; ++i) {
         const char* name = ucnv_getAvailableName(i);
         ScopedLocalRef<jstring> javaCanonicalName(env, getJavaCanonicalName(env, name));
@@ -337,7 +338,7 @@ static jobjectArray getAliases(JNIEnv* env, const char* icuCanonicalName) {
     }
 
     // Convert our C++ char*[] into a Java String[]...
-    jobjectArray result = env->NewObjectArray(actualAliasCount, env->FindClass("java/lang/String"), NULL);
+    jobjectArray result = env->NewObjectArray(actualAliasCount, JniConstants::stringClass, NULL);
     for (int i = 0; i < actualAliasCount; ++i) {
         ScopedLocalRef<jstring> alias(env, env->NewStringUTF(aliasArray[i]));
         env->SetObjectArrayElement(result, i, alias.get());
@@ -622,16 +623,12 @@ static jobject NativeConverter_charsetForName(JNIEnv* env, jclass, jstring chars
     }
 
     // Construct the CharsetICU object.
-    jclass charsetClass = env->FindClass("com/ibm/icu4jni/charset/CharsetICU");
-    if (env->ExceptionOccurred()) {
-        return NULL;
-    }
-    jmethodID charsetConstructor = env->GetMethodID(charsetClass, "<init>",
+    jmethodID charsetConstructor = env->GetMethodID(JniConstants::charsetICUClass, "<init>",
             "(Ljava/lang/String;Ljava/lang/String;[Ljava/lang/String;)V");
     if (env->ExceptionOccurred()) {
         return NULL;
     }
-    return env->NewObject(charsetClass, charsetConstructor,
+    return env->NewObject(JniConstants::charsetICUClass, charsetConstructor,
             javaCanonicalName, env->NewStringUTF(icuCanonicalName), aliases);
 }
 
diff --git a/luni/src/main/native/NativeDecimalFormat.cpp b/luni/src/main/native/NativeDecimalFormat.cpp
index 759a271..6fda6b1 100644
--- a/luni/src/main/native/NativeDecimalFormat.cpp
+++ b/luni/src/main/native/NativeDecimalFormat.cpp
@@ -18,6 +18,7 @@
 
 #include "ErrorCode.h"
 #include "JNIHelp.h"
+#include "JniConstants.h"
 #include "ScopedJavaUnicodeString.h"
 #include "ScopedPrimitiveArray.h"
 #include "ScopedUtfChars.h"
@@ -229,8 +230,7 @@ static jstring toPatternImpl(JNIEnv* env, jclass, jint addr, jboolean localized)
 }
 
 static jstring formatResult(JNIEnv* env, const UnicodeString &str, FieldPositionIterator *fpi, jobject fpIter) {
-    static jclass gFPIClass = env->FindClass("com/ibm/icu4jni/text/NativeDecimalFormat$FieldPositionIterator");
-    static jmethodID gFPI_setData = env->GetMethodID(gFPIClass, "setData", "([I)V");
+    static jmethodID gFPI_setData = env->GetMethodID(JniConstants::fieldPositionIteratorClass, "setData", "([I)V");
 
     if (fpi != NULL) {
         int len = fpi->getData(NULL, 0);
@@ -279,8 +279,7 @@ static jstring formatDigitList(JNIEnv* env, jclass, jint addr, jstring value, jo
 }
 
 static jobject newBigDecimal(JNIEnv* env, const char* value, jsize len) {
-    static jclass gBigDecimalClass = (jclass) env->NewGlobalRef(env->FindClass("java/math/BigDecimal"));
-    static jmethodID gBigDecimal_init = env->GetMethodID(gBigDecimalClass, "<init>", "(Ljava/lang/String;)V");
+    static jmethodID gBigDecimal_init = env->GetMethodID(JniConstants::bigDecimalClass, "<init>", "(Ljava/lang/String;)V");
 
     // this is painful...
     // value is a UTF-8 string of invariant characters, but isn't guaranteed to be
@@ -288,29 +287,21 @@ static jobject newBigDecimal(JNIEnv* env, const char* value, jsize len) {
     // data to jchars using UnicodeString, and call NewString instead.
     UnicodeString tmp(value, len, UnicodeString::kInvariant);
     jobject str = env->NewString(tmp.getBuffer(), tmp.length());
-    return env->NewObject(gBigDecimalClass, gBigDecimal_init, str);
+    return env->NewObject(JniConstants::bigDecimalClass, gBigDecimal_init, str);
 }
 
-static jmethodID gPP_getIndex = NULL;
-static jmethodID gPP_setIndex = NULL;
-static jmethodID gPP_setErrorIndex = NULL;
-
 static jobject parse(JNIEnv* env, jclass, jint addr, jstring text,
                      jobject position, jboolean parseBigDecimal) {
 
-    if (gPP_getIndex == NULL) {
-        jclass ppClass = env->FindClass("java/text/ParsePosition");
-        gPP_getIndex = env->GetMethodID(ppClass, "getIndex", "()I");
-        gPP_setIndex = env->GetMethodID(ppClass, "setIndex", "(I)V");
-        gPP_setErrorIndex = env->GetMethodID(ppClass, "setErrorIndex", "(I)V");
-    }
+    static jmethodID gPP_getIndex = env->GetMethodID(JniConstants::parsePositionClass, "getIndex", "()I");
+    static jmethodID gPP_setIndex = env->GetMethodID(JniConstants::parsePositionClass, "setIndex", "(I)V");
+    static jmethodID gPP_setErrorIndex = env->GetMethodID(JniConstants::parsePositionClass, "setErrorIndex", "(I)V");
 
     // make sure the ParsePosition is valid. Actually icu4c would parse a number
     // correctly even if the parsePosition is set to -1, but since the RI fails
     // for that case we have to fail too
     int parsePos = env->CallIntMethod(position, gPP_getIndex, NULL);
-    const int strlength = env->GetStringLength(text);
-    if (parsePos < 0 || parsePos > strlength) {
+    if (parsePos < 0 || parsePos > env->GetStringLength(text)) {
         return NULL;
     }
 
diff --git a/luni/src/main/native/NativeRegEx.cpp b/luni/src/main/native/NativeRegEx.cpp
index d85270d..0f31204 100644
--- a/luni/src/main/native/NativeRegEx.cpp
+++ b/luni/src/main/native/NativeRegEx.cpp
@@ -20,13 +20,13 @@
 #include <stdio.h>
 #include <string.h>
 
+#include "JNIHelp.h"
+#include "JniConstants.h"
 #include "ScopedPrimitiveArray.h"
+#include "jni.h"
+#include "unicode/parseerr.h"
 #include "unicode/uregex.h"
 #include "unicode/utypes.h"
-#include "unicode/parseerr.h"
-
-#include <jni.h>
-#include <JNIHelp.h>
 
 static jchar EMPTY_STRING = 0;
 
@@ -45,14 +45,12 @@ struct RegExData {
 static void throwPatternSyntaxException(JNIEnv* env, UErrorCode status,
                                         jstring pattern, UParseError error)
 {
-    jclass clazz = env->FindClass("java/util/regex/PatternSyntaxException");
-    jmethodID method = env->GetMethodID(clazz, "<init>",
-                                    "(Ljava/lang/String;Ljava/lang/String;I)V");
-
+    jmethodID method = env->GetMethodID(JniConstants::patternSyntaxExceptionClass,
+            "<init>", "(Ljava/lang/String;Ljava/lang/String;I)V");
     jstring message = env->NewStringUTF(u_errorName(status));
-    jthrowable except = (jthrowable)(env->NewObject(clazz, method, message,
-                                                    pattern, error.offset));
-    env->Throw(except);
+    jobject exception = env->NewObject(JniConstants::patternSyntaxExceptionClass, method,
+            message, pattern, error.offset);
+    env->Throw(reinterpret_cast<jthrowable>(exception));
 }
 
 static void throwRuntimeException(JNIEnv* env, UErrorCode status) {
diff --git a/luni/src/main/native/NetworkUtilities.cpp b/luni/src/main/native/NetworkUtilities.cpp
index ca0e122..3af30be 100644
--- a/luni/src/main/native/NetworkUtilities.cpp
+++ b/luni/src/main/native/NetworkUtilities.cpp
@@ -18,6 +18,7 @@
 
 #include "NetworkUtilities.h"
 #include "JNIHelp.h"
+#include "JniConstants.h"
 
 #include <arpa/inet.h>
 #include <stdio.h>
@@ -89,16 +90,12 @@ jobject byteArrayToInetAddress(JNIEnv* env, jbyteArray byteArray) {
     if (byteArray == NULL) {
         return NULL;
     }
-    jclass inetAddressClass = env->FindClass("java/net/InetAddress");
-    if (inetAddressClass == NULL) {
-        return NULL;
-    }
-    jmethodID getByAddressMethod = env->GetStaticMethodID(inetAddressClass,
+    jmethodID getByAddressMethod = env->GetStaticMethodID(JniConstants::inetAddressClass,
             "getByAddress", "([B)Ljava/net/InetAddress;");
     if (getByAddressMethod == NULL) {
         return NULL;
     }
-    return env->CallStaticObjectMethod(inetAddressClass, getByAddressMethod, byteArray);
+    return env->CallStaticObjectMethod(JniConstants::inetAddressClass, getByAddressMethod, byteArray);
 }
 
 jobject socketAddressToInetAddress(JNIEnv* env, sockaddr_storage* ss) {
diff --git a/luni/src/main/native/Register.cpp b/luni/src/main/native/Register.cpp
index ee996c3..c2ca8ea 100644
--- a/luni/src/main/native/Register.cpp
+++ b/luni/src/main/native/Register.cpp
@@ -1,12 +1,12 @@
 /*
  * Copyright (C) 2010 The Android Open Source Project
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+#include "JniConstants.h"
 #include "ScopedLocalFrame.h"
 
 namespace android {
@@ -62,6 +63,8 @@ extern int register_org_openssl_NativeBN(JNIEnv* env);
 extern "C" int registerCoreLibrariesJni(JNIEnv* env) {
     ScopedLocalFrame localFrame(env);
 
+    JniConstants::init(env);
+
     bool result =
             register_com_ibm_icu4jni_converters_NativeConverter(env) != -1 &&
             register_com_ibm_icu4jni_lang_UCharacter(env) != -1 &&
diff --git a/luni/src/main/native/java_io_File.cpp b/luni/src/main/native/java_io_File.cpp
index fa41ad2..8b5434e 100644
--- a/luni/src/main/native/java_io_File.cpp
+++ b/luni/src/main/native/java_io_File.cpp
@@ -18,6 +18,7 @@
 #define LOG_TAG "File"
 
 #include "JNIHelp.h"
+#include "JniConstants.h"
 #include "LocalArray.h"
 #include "ScopedFd.h"
 #include "ScopedLocalRef.h"
@@ -353,11 +354,7 @@ static jobjectArray java_io_File_listImpl(JNIEnv* env, jobject, jbyteArray pathB
         return NULL;
     }
     // Translate the intermediate form into a Java String[].
-    jclass stringClass = env->FindClass("java/lang/String");
-    if (stringClass == NULL) {
-        return NULL;
-    }
-    jobjectArray result = env->NewObjectArray(files.size(), stringClass, NULL);
+    jobjectArray result = env->NewObjectArray(files.size(), JniConstants::stringClass, NULL);
     for (int i = 0; files.size() != 0; files.pop_front(), ++i) {
         ScopedLocalRef<jstring> javaFilename(env, env->NewStringUTF(files.front()));
         if (env->ExceptionCheck()) {
diff --git a/luni/src/main/native/java_io_FileDescriptor.c b/luni/src/main/native/java_io_FileDescriptor.c
index 075e19b..878e836 100644
--- a/luni/src/main/native/java_io_FileDescriptor.c
+++ b/luni/src/main/native/java_io_FileDescriptor.c
@@ -14,7 +14,7 @@
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  */
- 
+
 #include "JNIHelp.h"
 
 #include <stdlib.h>
@@ -117,16 +117,16 @@ static int checkClassInit (JNIEnv *env) {
         jclass clazz;
         clazz = (*env)->FindClass(env, "java/io/FileDescriptor");
         if(clazz == NULL) {
-            jniThrowException(env, "java/lang/ClassNotFoundException", 
+            jniThrowException(env, "java/lang/ClassNotFoundException",
                                     "java.io.FileDescriptor");
             return -1;
         }
 
         jfieldID readWriteId;
-        readWriteId = (*env)->GetStaticFieldID(env, clazz, "in", 
+        readWriteId = (*env)->GetStaticFieldID(env, clazz, "in",
                 "Ljava/io/FileDescriptor;");
         if(readWriteId == NULL) {
-            jniThrowException(env, "java/lang/NoSuchFieldException", 
+            jniThrowException(env, "java/lang/NoSuchFieldException",
                                     "FileDescriptor.readOnly(Z)");
             return -1;
         }
@@ -153,13 +153,13 @@ jobject jniCreateFileDescriptor (JNIEnv *env, int fd) {
 
     ret = (*env)->NewObject(env, gCachedFields.clazz,
             gCachedFields.constructorInt);
-    
+
     (*env)->SetIntField(env, ret, gCachedFields.descriptor, fd);
 
     return ret;
 }
 
-/* 
+/*
  * For JNIHelp.c
  * Get an int file descriptor from a java.io.FileDescriptor
  */
diff --git a/luni/src/main/native/java_io_ObjectStreamClass.cpp b/luni/src/main/native/java_io_ObjectStreamClass.cpp
index 395e39f..3799f3a 100644
--- a/luni/src/main/native/java_io_ObjectStreamClass.cpp
+++ b/luni/src/main/native/java_io_ObjectStreamClass.cpp
@@ -18,87 +18,40 @@
 #define LOG_TAG "ObjectStreamClass"
 
 #include "JNIHelp.h"
+#include "JniConstants.h"
 
-static jobject java_io_osc_getFieldSignature(JNIEnv* env, jclass,
-                                                  jobject reflectField) {
-    jclass lookupClass;
-    jmethodID mid;
-
-    lookupClass = env->FindClass("java/lang/reflect/Field");
-    if(!lookupClass) {
+static jobject getSignature(JNIEnv* env, jclass c, jobject object) {
+    jmethodID mid = env->GetMethodID(c, "getSignature", "()Ljava/lang/String;");
+    if (!mid) {
         return NULL;
     }
-
-    mid = env->GetMethodID(lookupClass, "getSignature",
-            "()Ljava/lang/String;");
-    if(!mid)
-    {
-        return NULL;
-    }
-
-    jclass fieldClass = env->GetObjectClass(reflectField);
-
-    return env->CallNonvirtualObjectMethod(reflectField,
-            fieldClass, mid);
+    jclass objectClass = env->GetObjectClass(object);
+    return env->CallNonvirtualObjectMethod(object, objectClass, mid);
 }
 
-static jobject java_io_osc_getMethodSignature(JNIEnv* env, jclass,
-                                                   jobject reflectMethod)
-{
-    jclass lookupClass;
-    jmethodID mid;
-
-    lookupClass = env->FindClass("java/lang/reflect/Method");
-    if(!lookupClass) {
-        return NULL;
-    }
-
-    mid = env->GetMethodID(lookupClass, "getSignature",
-            "()Ljava/lang/String;");
-    if(!mid) {
-        return NULL;
-    }
-
-    jclass methodClass = env->GetObjectClass(reflectMethod);
-    return env->CallNonvirtualObjectMethod(reflectMethod,
-            methodClass, mid);
+static jobject ObjectStreamClass_getFieldSignature(JNIEnv* env, jclass, jobject field) {
+    return getSignature(env, JniConstants::fieldClass, field);
 }
 
-static jobject java_io_osc_getConstructorSignature(JNIEnv* env,
-                                                        jclass,
-                                                        jobject
-                                                        reflectConstructor)
-{
-    jclass lookupClass;
-    jmethodID mid;
-
-    lookupClass = env->FindClass("java/lang/reflect/Constructor");
-    if(!lookupClass) {
-        return NULL;
-    }
-
-    mid = env->GetMethodID(lookupClass, "getSignature",
-            "()Ljava/lang/String;");
-    if(!mid) {
-        return NULL;
-    }
+static jobject ObjectStreamClass_getMethodSignature(JNIEnv* env, jclass, jobject method) {
+    return getSignature(env, JniConstants::methodClass, method);
+}
 
-    jclass constructorClass = env->GetObjectClass(reflectConstructor);
-    return env->CallNonvirtualObjectMethod(reflectConstructor,
-                                             constructorClass, mid);
+static jobject ObjectStreamClass_getConstructorSignature(JNIEnv* env, jclass, jobject constructor) {
+    return getSignature(env, JniConstants::constructorClass, constructor);
 }
 
-static jboolean java_io_osc_hasClinit(JNIEnv * env, jclass, jclass targetClass) {
+static jboolean ObjectStreamClass_hasClinit(JNIEnv * env, jclass, jclass targetClass) {
     jmethodID mid = env->GetStaticMethodID(targetClass, "<clinit>", "()V");
     env->ExceptionClear();
     return (mid != 0);
 }
 
 static JNINativeMethod gMethods[] = {
-    { "getConstructorSignature", "(Ljava/lang/reflect/Constructor;)Ljava/lang/String;", (void*) java_io_osc_getConstructorSignature },
-    { "getFieldSignature", "(Ljava/lang/reflect/Field;)Ljava/lang/String;", (void*) java_io_osc_getFieldSignature },
-    { "getMethodSignature", "(Ljava/lang/reflect/Method;)Ljava/lang/String;", (void*) java_io_osc_getMethodSignature },
-    { "hasClinit", "(Ljava/lang/Class;)Z", (void*) java_io_osc_hasClinit },
+    { "getConstructorSignature", "(Ljava/lang/reflect/Constructor;)Ljava/lang/String;", (void*) ObjectStreamClass_getConstructorSignature },
+    { "getFieldSignature", "(Ljava/lang/reflect/Field;)Ljava/lang/String;", (void*) ObjectStreamClass_getFieldSignature },
+    { "getMethodSignature", "(Ljava/lang/reflect/Method;)Ljava/lang/String;", (void*) ObjectStreamClass_getMethodSignature },
+    { "hasClinit", "(Ljava/lang/Class;)Z", (void*) ObjectStreamClass_hasClinit },
 };
 int register_java_io_ObjectStreamClass(JNIEnv* env) {
     return jniRegisterNativeMethods(env, "java/io/ObjectStreamClass", gMethods, NELEM(gMethods));
diff --git a/luni/src/main/native/java_lang_ProcessManager.cpp b/luni/src/main/native/java_lang_ProcessManager.cpp
index c113c0f..e828342 100644
--- a/luni/src/main/native/java_lang_ProcessManager.cpp
+++ b/luni/src/main/native/java_lang_ProcessManager.cpp
@@ -28,6 +28,7 @@
 
 #include "jni.h"
 #include "JNIHelp.h"
+#include "JniConstants.h"
 #include "utils/Log.h"
 
 /** Environment variables. */
@@ -353,7 +354,7 @@ static pid_t java_lang_ProcessManager_exec(
     char** environment = convertStrings(env, javaEnvironment);
 
     pid_t result = executeProcess(
-            env, commands, environment, workingDirectory, 
+            env, commands, environment, workingDirectory,
             inDescriptor, outDescriptor, errDescriptor, redirectErrorStream);
 
     // Temporarily clear exception so we can clean up.
@@ -396,11 +397,7 @@ static void java_lang_ProcessManager_staticInitialize(JNIEnv* env,
         return;
     }
 
-    jclass fileDescriptorClass = env->FindClass("java/io/FileDescriptor");
-    if (fileDescriptorClass == NULL) {
-        return;
-    }
-    descriptorField = env->GetFieldID(fileDescriptorClass, "descriptor", "I");
+    descriptorField = env->GetFieldID(JniConstants::fileDescriptorClass, "descriptor", "I");
     if (descriptorField == NULL) {
         return;
     }
diff --git a/luni/src/main/native/java_net_InetAddress.cpp b/luni/src/main/native/java_net_InetAddress.cpp
index 304c8d4..64c6764 100644
--- a/luni/src/main/native/java_net_InetAddress.cpp
+++ b/luni/src/main/native/java_net_InetAddress.cpp
@@ -19,12 +19,13 @@
 #define LOG_DNS 0
 
 #include "JNIHelp.h"
+#include "JniConstants.h"
 #include "LocalArray.h"
 #include "NetworkUtilities.h"
 #include "ScopedLocalRef.h"
 #include "ScopedUtfChars.h"
-#include "utils/Log.h"
 #include "jni.h"
+#include "utils/Log.h"
 
 #include <stdio.h>
 #include <string.h>
@@ -35,9 +36,6 @@
 #include <arpa/inet.h>
 #include <sys/socket.h>
 
-
-static jclass byteArrayClass = NULL;
-
 static jstring InetAddress_gethostname(JNIEnv* env, jclass)
 {
     char name[256];
@@ -98,7 +96,7 @@ static jobjectArray InetAddress_getaddrinfo(JNIEnv* env, jclass, jstring javaNam
         }
 
         // Prepare output array.
-        addressArray = env->NewObjectArray(addressCount, byteArrayClass, NULL);
+        addressArray = env->NewObjectArray(addressCount, JniConstants::byteArrayClass, NULL);
         if (addressArray == NULL) {
             // Appropriate exception will be thrown.
             LOGE("getaddrinfo: could not allocate array of size %i", addressCount);
@@ -335,14 +333,5 @@ static JNINativeMethod gMethods[] = {
     { "ipStringToByteArray", "(Ljava/lang/String;)[B", (void*) InetAddress_ipStringToByteArray },
 };
 int register_java_net_InetAddress(JNIEnv* env) {
-    jclass tempClass = env->FindClass("[B");
-    if (tempClass) {
-        byteArrayClass = (jclass) env->NewGlobalRef(tempClass);
-    }
-    if (!byteArrayClass) {
-        LOGE("register_java_net_InetAddress: cannot allocate byte array class");
-        return -1;
-    }
-    return jniRegisterNativeMethods(env, "java/net/InetAddress",
-                gMethods, NELEM(gMethods));
+    return jniRegisterNativeMethods(env, "java/net/InetAddress", gMethods, NELEM(gMethods));
 }
diff --git a/luni/src/main/native/java_net_NetworkInterface.cpp b/luni/src/main/native/java_net_NetworkInterface.cpp
index 6a0d342..71e59e7 100644
--- a/luni/src/main/native/java_net_NetworkInterface.cpp
+++ b/luni/src/main/native/java_net_NetworkInterface.cpp
@@ -18,6 +18,7 @@
 #define LOG_TAG "NetworkInterface"
 
 #include "JNIHelp.h"
+#include "JniConstants.h"
 #include "jni.h"
 #include "NetworkUtilities.h"
 #include "ScopedFd.h"
@@ -69,11 +70,7 @@ static void jniThrowSocketException(JNIEnv* env) {
 }
 
 static jobject makeInterfaceAddress(JNIEnv* env, jint interfaceIndex, ifaddrs* ifa) {
-    jclass clazz = env->FindClass("java/net/InterfaceAddress");
-    if (clazz == NULL) {
-        return NULL;
-    }
-    jmethodID constructor = env->GetMethodID(clazz, "<init>",
+    jmethodID constructor = env->GetMethodID(JniConstants::interfaceAddressClass, "<init>",
             "(ILjava/lang/String;Ljava/net/InetAddress;Ljava/net/InetAddress;)V");
     if (constructor == NULL) {
         return NULL;
@@ -92,7 +89,8 @@ static jobject makeInterfaceAddress(JNIEnv* env, jint interfaceIndex, ifaddrs* i
     if (javaMask == NULL) {
         return NULL;
     }
-    return env->NewObject(clazz, constructor, interfaceIndex, javaName, javaAddress, javaMask);
+    return env->NewObject(JniConstants::interfaceAddressClass, constructor,
+            interfaceIndex, javaName, javaAddress, javaMask);
 }
 
 static jobjectArray getAllInterfaceAddressesImpl(JNIEnv* env, jclass) {
@@ -110,11 +108,8 @@ static jobjectArray getAllInterfaceAddressesImpl(JNIEnv* env, jclass) {
     }
 
     // Build the InterfaceAddress[]...
-    jclass interfaceAddressClass = env->FindClass("java/net/InterfaceAddress");
-    if (interfaceAddressClass == NULL) {
-        return NULL;
-    }
-    jobjectArray result = env->NewObjectArray(interfaceAddressCount, interfaceAddressClass, NULL);
+    jobjectArray result =
+            env->NewObjectArray(interfaceAddressCount, JniConstants::interfaceAddressClass, NULL);
     if (result == NULL) {
         return NULL;
     }
diff --git a/luni/src/main/native/java_util_zip_Deflater.cpp b/luni/src/main/native/java_util_zip_Deflater.cpp
index 924cd61..7255bcd 100644
--- a/luni/src/main/native/java_util_zip_Deflater.cpp
+++ b/luni/src/main/native/java_util_zip_Deflater.cpp
@@ -17,6 +17,7 @@
 
 #define LOG_TAG "Deflater"
 
+#include "JniConstants.h"
 #include "ScopedPrimitiveArray.h"
 #include "zip.h"
 
@@ -143,8 +144,7 @@ static JNINativeMethod gMethods[] = {
     { "setLevelsImpl", "(IIJ)V", (void*) Deflater_setLevelsImpl },
 };
 int register_java_util_zip_Deflater(JNIEnv* env) {
-    jclass deflaterClass = env->FindClass("java/util/zip/Deflater");
-    gCachedFields.finished = env->GetFieldID(deflaterClass, "finished", "Z");
-    gCachedFields.inRead = env->GetFieldID(deflaterClass, "inRead", "I");
+    gCachedFields.finished = env->GetFieldID(JniConstants::deflaterClass, "finished", "Z");
+    gCachedFields.inRead = env->GetFieldID(JniConstants::deflaterClass, "inRead", "I");
     return jniRegisterNativeMethods(env, "java/util/zip/Deflater", gMethods, NELEM(gMethods));
 }
diff --git a/luni/src/main/native/java_util_zip_Inflater.cpp b/luni/src/main/native/java_util_zip_Inflater.cpp
index 4fb884e..63a0140 100644
--- a/luni/src/main/native/java_util_zip_Inflater.cpp
+++ b/luni/src/main/native/java_util_zip_Inflater.cpp
@@ -17,6 +17,7 @@
 
 #define LOG_TAG "Inflater"
 
+#include "JniConstants.h"
 #include "ScopedPrimitiveArray.h"
 #include "zip.h"
 #include <errno.h>
@@ -179,9 +180,8 @@ static JNINativeMethod gMethods[] = {
     { "setInputImpl", "([BIIJ)V", (void*) Inflater_setInputImpl },
 };
 int register_java_util_zip_Inflater(JNIEnv* env) {
-    jclass inflaterClass = env->FindClass("java/util/zip/Inflater");
-    gCachedFields.finished = env->GetFieldID(inflaterClass, "finished", "Z");
-    gCachedFields.inRead = env->GetFieldID(inflaterClass, "inRead", "I");
-    gCachedFields.needsDictionary = env->GetFieldID(inflaterClass, "needsDictionary", "Z");
+    gCachedFields.finished = env->GetFieldID(JniConstants::inflaterClass, "finished", "Z");
+    gCachedFields.inRead = env->GetFieldID(JniConstants::inflaterClass, "inRead", "I");
+    gCachedFields.needsDictionary = env->GetFieldID(JniConstants::inflaterClass, "needsDictionary", "Z");
     return jniRegisterNativeMethods(env, "java/util/zip/Inflater", gMethods, NELEM(gMethods));
 }
diff --git a/luni/src/main/native/org_apache_harmony_luni_platform_OSMemory.cpp b/luni/src/main/native/org_apache_harmony_luni_platform_OSMemory.cpp
index 8c8a864..edfaba0 100644
--- a/luni/src/main/native/org_apache_harmony_luni_platform_OSMemory.cpp
+++ b/luni/src/main/native/org_apache_harmony_luni_platform_OSMemory.cpp
@@ -17,6 +17,7 @@
 #define LOG_TAG "OSMemory"
 
 #include "JNIHelp.h"
+#include "JniConstants.h"
 #include "utils/misc.h"
 #include "utils/Log.h"
 #include <sys/mman.h>
@@ -107,7 +108,7 @@ static void harmony_nio_freeImpl(JNIEnv* _env, jobject, jint pointer) {
  * Method:    memset
  * Signature: (IBJ)V
  */
-static void harmony_nio_memset(JNIEnv*, jobject, jint address, 
+static void harmony_nio_memset(JNIEnv*, jobject, jint address,
         jbyte value, jlong length) {
     memset ((void *) ((jint) address), (jbyte) value, (jlong) length);
 }
@@ -117,9 +118,9 @@ static void harmony_nio_memset(JNIEnv*, jobject, jint address,
  * Method:    memmove
  * Signature: (IIJ)V
  */
-static void harmony_nio_memmove(JNIEnv*, jobject, jint destAddress, 
+static void harmony_nio_memmove(JNIEnv*, jobject, jint destAddress,
         jint srcAddress, jlong length) {
-    memmove ((void *) ((jint) destAddress), (const void *) ((jint) srcAddress), 
+    memmove ((void *) ((jint) destAddress), (const void *) ((jint) srcAddress),
         (jlong) length);
 }
 
@@ -128,7 +129,7 @@ static void harmony_nio_memmove(JNIEnv*, jobject, jint destAddress,
  * Method:    getByteImpl
  * Signature: (I)B
  */
-static jbyte harmony_nio_getByteImpl(JNIEnv*, jobject, 
+static jbyte harmony_nio_getByteImpl(JNIEnv*, jobject,
         jint pointer) {
     jbyte returnValue = *((jbyte *)pointer);
     return returnValue;
@@ -139,7 +140,7 @@ static jbyte harmony_nio_getByteImpl(JNIEnv*, jobject,
  * Method:    getBytesImpl
  * Signature: (I[BII)V
  */
-static void harmony_nio_getBytesImpl(JNIEnv* _env, jobject, jint pointer, 
+static void harmony_nio_getBytesImpl(JNIEnv* _env, jobject, jint pointer,
         jbyteArray dst, jint offset, jint length) {
     jbyte* src = reinterpret_cast<jbyte*>(static_cast<uintptr_t>(pointer));
     _env->SetByteArrayRegion(dst, offset, length, src);
@@ -227,7 +228,7 @@ static void harmony_nio_setIntArrayImpl(JNIEnv* _env, jobject,
  * Method:    getShortImpl
  * Signature: (I)S
  */
-static jshort harmony_nio_getShortImpl(JNIEnv*, jobject, 
+static jshort harmony_nio_getShortImpl(JNIEnv*, jobject,
         jint pointer) {
     if ((pointer & 0x1) == 0) {
         jshort returnValue = *((jshort *)pointer);
@@ -248,7 +249,7 @@ static jshort harmony_nio_getShortImpl(JNIEnv*, jobject,
  * Method:    petShortImpl
  * Signature: (IS)V
  */
-static void harmony_nio_putShortImpl(JNIEnv*, jobject, jint pointer, 
+static void harmony_nio_putShortImpl(JNIEnv*, jobject, jint pointer,
         jshort value) {
     if ((pointer & 0x1) == 0) {
         *((jshort *)pointer) = value;
@@ -288,7 +289,7 @@ static jint harmony_nio_getIntImpl(JNIEnv*, jobject, jint pointer) {
  * Method:    putIntImpl
  * Signature: (II)V
  */
-static void harmony_nio_putIntImpl(JNIEnv*, jobject, jint pointer, 
+static void harmony_nio_putIntImpl(JNIEnv*, jobject, jint pointer,
         jint value) {
     if ((pointer & 0x3) == 0) {
         *((jint *)pointer) = value;
@@ -308,7 +309,7 @@ static void harmony_nio_putIntImpl(JNIEnv*, jobject, jint pointer,
  * Method:    getLongImpl
  * Signature: (I)Ljava/lang/Long;
  */
-static jlong harmony_nio_getLongImpl(JNIEnv*, jobject, 
+static jlong harmony_nio_getLongImpl(JNIEnv*, jobject,
         jint pointer) {
     if ((pointer & 0x7) == 0) {
         jlong returnValue = *((jlong *)pointer);
@@ -326,7 +327,7 @@ static jlong harmony_nio_getLongImpl(JNIEnv*, jobject,
  * Method:    putLongImpl
  * Signature: (IJ)V
  */
-static void harmony_nio_putLongImpl(JNIEnv*, jobject, jint pointer, 
+static void harmony_nio_putLongImpl(JNIEnv*, jobject, jint pointer,
         jlong value) {
     if ((pointer & 0x7) == 0) {
         *((jlong *)pointer) = value;
@@ -341,7 +342,7 @@ static void harmony_nio_putLongImpl(JNIEnv*, jobject, jint pointer,
  * Method:    getFloatImpl
  * Signature: (I)F
  */
-static jfloat harmony_nio_getFloatImpl(JNIEnv*, jobject, 
+static jfloat harmony_nio_getFloatImpl(JNIEnv*, jobject,
         jint pointer) {
     if ((pointer & 0x3) == 0) {
         jfloat returnValue = *((jfloat *)pointer);
@@ -359,7 +360,7 @@ static jfloat harmony_nio_getFloatImpl(JNIEnv*, jobject,
  * Method:    setFloatImpl
  * Signature: (IF)V
  */
-static void harmony_nio_putFloatImpl(JNIEnv*, jobject, jint pointer, 
+static void harmony_nio_putFloatImpl(JNIEnv*, jobject, jint pointer,
         jfloat value) {
     if ((pointer & 0x3) == 0) {
         *((jfloat *)pointer) = value;
@@ -374,7 +375,7 @@ static void harmony_nio_putFloatImpl(JNIEnv*, jobject, jint pointer,
  * Method:    getDoubleImpl
  * Signature: (I)D
  */
-static jdouble harmony_nio_getDoubleImpl(JNIEnv*, jobject, 
+static jdouble harmony_nio_getDoubleImpl(JNIEnv*, jobject,
         jint pointer) {
     if ((pointer & 0x7) == 0) {
         jdouble returnValue = *((jdouble *)pointer);
@@ -392,7 +393,7 @@ static jdouble harmony_nio_getDoubleImpl(JNIEnv*, jobject,
  * Method:    putDoubleImpl
  * Signature: (ID)V
  */
-static void harmony_nio_putDoubleImpl(JNIEnv*, jobject, jint pointer, 
+static void harmony_nio_putDoubleImpl(JNIEnv*, jobject, jint pointer,
         jdouble value) {
     if ((pointer & 0x7) == 0) {
         *((jdouble *)pointer) = value;
@@ -416,7 +417,7 @@ static jint harmony_nio_getAddress(JNIEnv*, jobject, jint pointer) {
  * Method:    setAddress
  * Signature: (II)V
  */
-static void harmony_nio_setAddress(JNIEnv*, jobject, jint pointer, 
+static void harmony_nio_setAddress(JNIEnv*, jobject, jint pointer,
         jint value) {
     *(int *) pointer = (int) value;
 }
@@ -426,7 +427,7 @@ static void harmony_nio_setAddress(JNIEnv*, jobject, jint pointer,
  * Method:    mmapImpl
  * Signature: (IJJI)I
  */
-static jint harmony_nio_mmapImpl(JNIEnv* env, jobject, jint fd, 
+static jint harmony_nio_mmapImpl(JNIEnv* env, jobject, jint fd,
         jlong offset, jlong size, jint mapMode) {
     int prot, flags;
     switch (mapMode) {
@@ -460,7 +461,7 @@ static jint harmony_nio_mmapImpl(JNIEnv* env, jobject, jint fd,
  * Method:    unmapImpl
  * Signature: (IJ)V
  */
-static void harmony_nio_unmapImpl(JNIEnv*, jobject, jint address, 
+static void harmony_nio_unmapImpl(JNIEnv*, jobject, jint address,
         jlong size) {
     munmap((void *)address, (size_t)size);
 }
@@ -470,7 +471,7 @@ static void harmony_nio_unmapImpl(JNIEnv*, jobject, jint address,
  * Method:    loadImpl
  * Signature: (IJ)I
  */
-static jint harmony_nio_loadImpl(JNIEnv*, jobject, jint address, 
+static jint harmony_nio_loadImpl(JNIEnv*, jobject, jint address,
         jlong size) {
 
     if(mlock((void *)address, (size_t)size)!=-1) {
@@ -484,7 +485,7 @@ static jint harmony_nio_loadImpl(JNIEnv*, jobject, jint address,
              return 0;
          }
     }
-    
+
     return -1;
 }
 
@@ -493,20 +494,20 @@ static jint harmony_nio_loadImpl(JNIEnv*, jobject, jint address,
  * Method:    isLoadedImpl
  * Signature: (IJ)Z
  */
-static jboolean harmony_nio_isLoadedImpl(JNIEnv*, jobject, 
+static jboolean harmony_nio_isLoadedImpl(JNIEnv*, jobject,
         jint address, jlong size) {
 
     static int page_size = getpagesize();
     jboolean result = 0;
     jint m_addr = (jint)address;
-    
+
     int align_offset = m_addr%page_size;// addr should align with the boundary of a page.
     m_addr -= align_offset;
     size   += align_offset;
     int page_count = (size+page_size-1)/page_size;
-    
+
     unsigned char* vec = (unsigned char *) malloc(page_count*sizeof(char));
-    
+
     if (mincore((void *)m_addr, size, (MINCORE_POINTER_TYPE) vec)==0) {
         // or else there is error about the mincore and return false;
         int i;
@@ -519,9 +520,9 @@ static jboolean harmony_nio_isLoadedImpl(JNIEnv*, jobject,
             result = 1;
         }
     }
-    
+
     free(vec);
-    
+
     return result;
 }
 
@@ -570,20 +571,12 @@ int register_org_apache_harmony_luni_platform_OSMemory(JNIEnv* env) {
      * We need to call VMRuntime.trackExternal{Allocation,Free}.  Cache
      * method IDs and a reference to the singleton.
      */
-    static const char* kVMRuntimeName = "dalvik/system/VMRuntime";
-    jmethodID method_getRuntime;
-    jclass clazz;
-
-    clazz = env->FindClass(kVMRuntimeName);
-    if (clazz == NULL) {
-        LOGE("Unable to find class %s\n", kVMRuntimeName);
-        return -1;
-    }
-    gIDCache.method_trackExternalAllocation = env->GetMethodID(clazz,
+    gIDCache.method_trackExternalAllocation = env->GetMethodID(JniConstants::vmRuntimeClass,
         "trackExternalAllocation", "(J)Z");
-    gIDCache.method_trackExternalFree = env->GetMethodID(clazz,
+    gIDCache.method_trackExternalFree = env->GetMethodID(JniConstants::vmRuntimeClass,
         "trackExternalFree", "(J)V");
-    method_getRuntime = env->GetStaticMethodID(clazz,
+
+    jmethodID method_getRuntime = env->GetStaticMethodID(JniConstants::vmRuntimeClass,
         "getRuntime", "()Ldalvik/system/VMRuntime;");
 
     if (gIDCache.method_trackExternalAllocation == NULL ||
@@ -594,7 +587,7 @@ int register_org_apache_harmony_luni_platform_OSMemory(JNIEnv* env) {
         return -1;
     }
 
-    jobject instance = env->CallStaticObjectMethod(clazz, method_getRuntime);
+    jobject instance = env->CallStaticObjectMethod(JniConstants::vmRuntimeClass, method_getRuntime);
     if (instance == NULL) {
         LOGE("Unable to obtain VMRuntime instance\n");
         return -1;
diff --git a/luni/src/main/native/org_apache_harmony_luni_platform_OSNetworkSystem.cpp b/luni/src/main/native/org_apache_harmony_luni_platform_OSNetworkSystem.cpp
index b03f374..3d6037a 100644
--- a/luni/src/main/native/org_apache_harmony_luni_platform_OSNetworkSystem.cpp
+++ b/luni/src/main/native/org_apache_harmony_luni_platform_OSNetworkSystem.cpp
@@ -24,6 +24,7 @@
 #define LOG_TAG "OSNetworkSystem"
 
 #include "JNIHelp.h"
+#include "JniConstants.h"
 #include "LocalArray.h"
 #include "NetworkUtilities.h"
 #include "ScopedPrimitiveArray.h"
@@ -95,22 +96,13 @@
 #define SOCKET_NOFLAGS 0
 
 static struct CachedFields {
-    jfieldID fd_descriptor;
-    jclass iaddr_class;
-    jclass i4addr_class;
     jfieldID iaddr_ipaddress;
-    jclass genericipmreq_class;
-    jclass integer_class;
     jfieldID integer_class_value;
-    jclass boolean_class;
     jfieldID boolean_class_value;
-    jclass byte_class;
     jfieldID byte_class_value;
-    jclass socketimpl_class;
     jfieldID socketimpl_address;
     jfieldID socketimpl_port;
     jfieldID socketimpl_localport;
-    jclass dpack_class;
     jfieldID dpack_address;
     jfieldID dpack_port;
     jfieldID dpack_length;
@@ -600,7 +592,7 @@ static void mcastAddDropMembership(JNIEnv *env, int handle, jobject optVal, int
      * is passed in, only support IPv4 as obtaining an interface from an
      * InetAddress is complex and should be done by the Java caller.
      */
-    if (env->IsInstanceOf(optVal, gCachedFields.iaddr_class)) {
+    if (env->IsInstanceOf(optVal, JniConstants::inetAddressClass)) {
         /*
          * optVal is an InetAddress. Construct a multicast request structure
          * from this address. Support IPv4 only.
@@ -641,12 +633,11 @@ static void mcastAddDropMembership(JNIEnv *env, int handle, jobject optVal, int
          */
 
         // Get the multicast address to join or leave.
-        jclass cls = env->GetObjectClass(optVal);
-        jfieldID multiaddrID = env->GetFieldID(cls, "multiaddr", "Ljava/net/InetAddress;");
+        jfieldID multiaddrID = env->GetFieldID(JniConstants::genericIPMreqClass, "multiaddr", "Ljava/net/InetAddress;");
         jobject multiaddr = env->GetObjectField(optVal, multiaddrID);
 
         // Get the interface index to use.
-        jfieldID interfaceIdxID = env->GetFieldID(cls, "interfaceIdx", "I");
+        jfieldID interfaceIdxID = env->GetFieldID(JniConstants::genericIPMreqClass, "interfaceIdx", "I");
         interfaceIndex = env->GetIntField(optVal, interfaceIdxID);
         LOGI("mcastAddDropMembership interfaceIndex=%i", interfaceIndex);
 
@@ -712,42 +703,22 @@ static bool initCachedFields(JNIEnv* env) {
     memset(&gCachedFields, 0, sizeof(gCachedFields));
     struct CachedFields *c = &gCachedFields;
 
-    struct classInfo {
-        jclass *clazz;
-        const char *name;
-    } classes[] = {
-        {&c->iaddr_class, "java/net/InetAddress"},
-        {&c->i4addr_class, "java/net/Inet4Address"},
-        {&c->genericipmreq_class, "org/apache/harmony/luni/net/GenericIPMreq"},
-        {&c->integer_class, "java/lang/Integer"},
-        {&c->boolean_class, "java/lang/Boolean"},
-        {&c->byte_class, "java/lang/Byte"},
-        {&c->socketimpl_class, "java/net/SocketImpl"},
-        {&c->dpack_class, "java/net/DatagramPacket"}
-    };
-    for (unsigned i = 0; i < sizeof(classes) / sizeof(classes[0]); i++) {
-        classInfo c = classes[i];
-        jclass tempClass = env->FindClass(c.name);
-        if (tempClass == NULL) return false;
-        *c.clazz = (jclass) env->NewGlobalRef(tempClass);
-    }
-
     struct fieldInfo {
         jfieldID *field;
         jclass clazz;
         const char *name;
         const char *type;
     } fields[] = {
-        {&c->iaddr_ipaddress, c->iaddr_class, "ipaddress", "[B"},
-        {&c->integer_class_value, c->integer_class, "value", "I"},
-        {&c->boolean_class_value, c->boolean_class, "value", "Z"},
-        {&c->byte_class_value, c->byte_class, "value", "B"},
-        {&c->socketimpl_port, c->socketimpl_class, "port", "I"},
-        {&c->socketimpl_localport, c->socketimpl_class, "localport", "I"},
-        {&c->socketimpl_address, c->socketimpl_class, "address", "Ljava/net/InetAddress;"},
-        {&c->dpack_address, c->dpack_class, "address", "Ljava/net/InetAddress;"},
-        {&c->dpack_port, c->dpack_class, "port", "I"},
-        {&c->dpack_length, c->dpack_class, "length", "I"}
+        {&c->iaddr_ipaddress, JniConstants::inetAddressClass, "ipaddress", "[B"},
+        {&c->integer_class_value, JniConstants::integerClass, "value", "I"},
+        {&c->boolean_class_value, JniConstants::booleanClass, "value", "Z"},
+        {&c->byte_class_value, JniConstants::byteClass, "value", "B"},
+        {&c->socketimpl_port, JniConstants::socketImplClass, "port", "I"},
+        {&c->socketimpl_localport, JniConstants::socketImplClass, "localport", "I"},
+        {&c->socketimpl_address, JniConstants::socketImplClass, "address", "Ljava/net/InetAddress;"},
+        {&c->dpack_address, JniConstants::datagramPacketClass, "address", "Ljava/net/InetAddress;"},
+        {&c->dpack_port, JniConstants::datagramPacketClass, "port", "I"},
+        {&c->dpack_length, JniConstants::datagramPacketClass, "length", "I"}
     };
     for (unsigned i = 0; i < sizeof(fields) / sizeof(fields[0]); i++) {
         fieldInfo f = fields[i];
@@ -1746,13 +1717,13 @@ static void osNetworkSystem_setSocketOption(JNIEnv* env, jobject, jobject fileDe
     }
 
     int intVal;
-    if (env->IsInstanceOf(optVal, gCachedFields.integer_class)) {
+    if (env->IsInstanceOf(optVal, JniConstants::integerClass)) {
         intVal = (int) env->GetIntField(optVal, gCachedFields.integer_class_value);
-    } else if (env->IsInstanceOf(optVal, gCachedFields.boolean_class)) {
+    } else if (env->IsInstanceOf(optVal, JniConstants::booleanClass)) {
         intVal = (int) env->GetBooleanField(optVal, gCachedFields.boolean_class_value);
-    } else if (env->IsInstanceOf(optVal, gCachedFields.byte_class)) {
+    } else if (env->IsInstanceOf(optVal, JniConstants::byteClass)) {
         intVal = (int) env->GetByteField(optVal, gCachedFields.byte_class_value);
-    } else if (env->IsInstanceOf(optVal, gCachedFields.genericipmreq_class) || env->IsInstanceOf(optVal, gCachedFields.iaddr_class)) {
+    } else if (env->IsInstanceOf(optVal, JniConstants::genericIPMreqClass) || env->IsInstanceOf(optVal, JniConstants::inetAddressClass)) {
         // we'll use optVal directly
     } else {
         jniThrowSocketException(env, EINVAL);
@@ -1822,7 +1793,7 @@ static void osNetworkSystem_setSocketOption(JNIEnv* env, jobject, jobject fileDe
     case JAVASOCKOPT_IP_MULTICAST_IF:
         {
             struct sockaddr_storage sockVal;
-            if (!env->IsInstanceOf(optVal, gCachedFields.iaddr_class) ||
+            if (!env->IsInstanceOf(optVal, JniConstants::inetAddressClass) ||
                     !inetAddressToSocketAddress(env, optVal, 0, &sockVal)) {
                 return;
             }
diff --git a/luni/src/main/native/org_apache_harmony_xml_ExpatParser.cpp b/luni/src/main/native/org_apache_harmony_xml_ExpatParser.cpp
index fbc99d3..087f2da 100644
--- a/luni/src/main/native/org_apache_harmony_xml_ExpatParser.cpp
+++ b/luni/src/main/native/org_apache_harmony_xml_ExpatParser.cpp
@@ -17,6 +17,7 @@
 #define LOG_TAG "ExpatParser"
 
 #include "JNIHelp.h"
+#include "JniConstants.h"
 #include "LocalArray.h"
 #include "ScopedLocalRef.h"
 #include "ScopedPrimitiveArray.h"
@@ -108,7 +109,6 @@ static jmethodID startElementMethod;
 static jmethodID startNamespaceMethod;
 static jmethodID textMethod;
 static jmethodID unparsedEntityDeclMethod;
-static jclass stringClass;
 static jstring emptyString;
 
 /**
@@ -1379,11 +1379,7 @@ static void staticInitialize(JNIEnv* env, jobject classObject, jstring empty) {
             "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V");
     if (unparsedEntityDeclMethod == NULL) return;
 
-    // Look up String class.
-    stringClass = env->FindClass("java/lang/String");
-
-    internMethod = env->GetMethodID(stringClass, "intern",
-        "()Ljava/lang/String;");
+    internMethod = env->GetMethodID(JniConstants::stringClass, "intern", "()Ljava/lang/String;");
     if (internMethod == NULL) return;
 
     // Reference to "".
diff --git a/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp b/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
index 9b0f56b..96ef89c 100644
--- a/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
+++ b/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
@@ -26,9 +26,6 @@
 
 #include <jni.h>
 
-#include <JNIHelp.h>
-#include <LocalArray.h>
-
 #include <openssl/dsa.h>
 #include <openssl/err.h>
 #include <openssl/evp.h>
@@ -36,6 +33,9 @@
 #include <openssl/rsa.h>
 #include <openssl/ssl.h>
 
+#include "JNIHelp.h"
+#include "JniConstants.h"
+#include "LocalArray.h"
 #include "ScopedLocalRef.h"
 #include "ScopedPrimitiveArray.h"
 #include "ScopedUtfChars.h"
@@ -991,8 +991,7 @@ static void info_callback_LOG(const SSL* s __attribute__ ((unused)), int where,
 /**
  * Returns an array containing all the X509 certificate's bytes.
  */
-static jobjectArray getCertificateBytes(JNIEnv* env,
-        const STACK_OF(X509)* chain)
+static jobjectArray getCertificateBytes(JNIEnv* env, const STACK_OF(X509)* chain)
 {
     if (chain == NULL) {
         // Chain can be NULL if the associated cipher doesn't do certs.
@@ -1004,7 +1003,7 @@ static jobjectArray getCertificateBytes(JNIEnv* env,
         return NULL;
     }
 
-    jobjectArray joa = env->NewObjectArray(count, env->FindClass("[B"), NULL);
+    jobjectArray joa = env->NewObjectArray(count, JniConstants::byteArrayClass, NULL);
     if (joa == NULL) {
         return NULL;
     }
@@ -2922,24 +2921,16 @@ int register_org_apache_harmony_xnet_provider_jsse_NativeCrypto(JNIEnv* env) {
     }
 
     // java.net.Socket
-    jclass socket = env->FindClass("java/net/Socket");
-    if (socket == NULL) {
-        LOGE("Can't find class java.net.Socket");
-        return -1;
-    }
-    field_Socket_mImpl = env->GetFieldID(socket, "impl", "Ljava/net/SocketImpl;");
+    field_Socket_mImpl =
+            env->GetFieldID(JniConstants::socketClass, "impl", "Ljava/net/SocketImpl;");
     if (field_Socket_mImpl == NULL) {
         LOGE("Can't find field impl in class java.net.Socket");
         return -1;
     }
 
     // java.net.SocketImpl
-    jclass socketImplClass = env->FindClass("java/net/SocketImpl");
-    if (socketImplClass == NULL) {
-        LOGE("Can't find class java.net.SocketImpl");
-        return -1;
-    }
-    field_Socket_mFD = env->GetFieldID(socketImplClass, "fd", "Ljava/io/FileDescriptor;");
+    field_Socket_mFD =
+            env->GetFieldID(JniConstants::socketImplClass, "fd", "Ljava/io/FileDescriptor;");
     if (field_Socket_mFD == NULL) {
         LOGE("Can't find field fd in java.net.SocketImpl");
         return -1;
diff --git a/luni/src/main/native/sub.mk b/luni/src/main/native/sub.mk
index 1c73e74..755788f 100644
--- a/luni/src/main/native/sub.mk
+++ b/luni/src/main/native/sub.mk
@@ -6,6 +6,7 @@ LOCAL_SRC_FILES := \
 	BidiWrapper.cpp \
 	ErrorCode.cpp \
 	ICU.cpp \
+	JniConstants.cpp \
 	NativeBreakIterator.cpp \
 	NativeCollation.cpp \
 	NativeConverter.cpp \
diff --git a/luni/src/main/native/valueOf.cpp b/luni/src/main/native/valueOf.cpp
index 64cfb1f..a3475e3 100644
--- a/luni/src/main/native/valueOf.cpp
+++ b/luni/src/main/native/valueOf.cpp
@@ -18,27 +18,26 @@
 
 #include "valueOf.h"
 #include "JNIHelp.h"
+#include "JniConstants.h"
 
-jobject booleanValueOf(JNIEnv * env, jboolean value) {
-    static jclass c = (jclass) env->NewGlobalRef(env->FindClass("java/lang/Boolean"));
-    static jmethodID valueOfMethod = env->GetStaticMethodID(c, "valueOf", "(Z)Ljava/lang/Boolean;");
+template <typename T>
+static jobject valueOf(JNIEnv* env, jclass c, const char* signature, const T& value) {
+    static jmethodID valueOfMethod = env->GetStaticMethodID(c, "valueOf", signature);
     return env->CallStaticObjectMethod(c, valueOfMethod, value);
 }
 
+jobject booleanValueOf(JNIEnv* env, jboolean value) {
+    return valueOf(env, JniConstants::booleanClass, "(Z)Ljava/lang/Boolean;", value);
+}
+
 jobject doubleValueOf(JNIEnv* env, jdouble value) {
-    static jclass c = (jclass) env->NewGlobalRef(env->FindClass("java/lang/Double"));
-    static jmethodID valueOfMethod = env->GetStaticMethodID(c, "valueOf", "(D)Ljava/lang/Double;");
-    return env->CallStaticObjectMethod(c, valueOfMethod, value);
+    return valueOf(env, JniConstants::doubleClass, "(D)Ljava/lang/Double;", value);
 }
 
 jobject integerValueOf(JNIEnv* env, jint value) {
-    static jclass c = (jclass) env->NewGlobalRef(env->FindClass("java/lang/Integer"));
-    static jmethodID valueOfMethod = env->GetStaticMethodID(c, "valueOf", "(I)Ljava/lang/Integer;");
-    return env->CallStaticObjectMethod(c, valueOfMethod, value);
+    return valueOf(env, JniConstants::integerClass, "(I)Ljava/lang/Integer;", value);
 }
 
 jobject longValueOf(JNIEnv* env, jlong value) {
-    static jclass c = (jclass) env->NewGlobalRef(env->FindClass("java/lang/Long"));
-    static jmethodID valueOfMethod = env->GetStaticMethodID(c, "valueOf", "(J)Ljava/lang/Long;");
-    return env->CallStaticObjectMethod(c, valueOfMethod, value);
+    return valueOf(env, JniConstants::longClass, "(J)Ljava/lang/Long;", value);
 }