Some of our helpers have moved into libnativehelpers.

(cherry picked from commit 4b5012a6cd5f7f32f33a776c9e2c94ca3f3eb1d5)

Change-Id: I8a154f8b6e39b8ed0a633fab9ba31d557b545bb5

10 files changed, 4 insertions, 418 deletions

diff --git a/dalvik/src/main/java/dalvik/system/DexFile.java b/dalvik/src/main/java/dalvik/system/DexFile.java
index 8db3985..18b730b 100644
--- a/dalvik/src/main/java/dalvik/system/DexFile.java
+++ b/dalvik/src/main/java/dalvik/system/DexFile.java
@@ -273,12 +273,6 @@ public final class DexFile {
         int flags) throws IOException;
 
     /*
-     * Open a DEX file based on a {@code byte[]}. The value returned
-     * is a magic VM cookie. On failure, a RuntimeException is thrown.
-     */
-    native private static int openDexFile(byte[] fileContents);
-
-    /*
      * Close DEX file.
      */
     native private static void closeDexFile(int cookie);
diff --git a/dalvik/src/main/native/org_apache_harmony_dalvik_NativeTestTarget.cpp b/dalvik/src/main/native/org_apache_harmony_dalvik_NativeTestTarget.cpp
index 11735eb..52f22a8 100644
--- a/dalvik/src/main/native/org_apache_harmony_dalvik_NativeTestTarget.cpp
+++ b/dalvik/src/main/native/org_apache_harmony_dalvik_NativeTestTarget.cpp
@@ -17,7 +17,7 @@
 #define LOG_TAG "NativeTestTarget"
 
 #include "JNIHelp.h"
-#include "../../../../luni/src/main/native/JniConstants.h"
+#include "JniConstants.h"
 
 static void NativeTestTarget_emptyJniMethod0(JNIEnv*, jobject) { }
 static void NativeTestTarget_emptyJniMethod6(JNIEnv*, jclass, int, int, int, int, int, int) { }
diff --git a/luni/src/main/java/java/lang/ClassLoader.java b/luni/src/main/java/java/lang/ClassLoader.java
index c99d57c..dbad137 100644
--- a/luni/src/main/java/java/lang/ClassLoader.java
+++ b/luni/src/main/java/java/lang/ClassLoader.java
@@ -223,8 +223,7 @@ public abstract class ClassLoader {
     @Deprecated
     protected final Class<?> defineClass(byte[] classRep, int offset, int length)
             throws ClassFormatError {
-
-        return VMClassLoader.defineClass(this, classRep, offset, length);
+        throw new UnsupportedOperationException("can't load this type of class file");
     }
 
     /**
@@ -251,9 +250,7 @@ public abstract class ClassLoader {
      */
     protected final Class<?> defineClass(String className, byte[] classRep, int offset, int length)
             throws ClassFormatError {
-
-        // TODO Define a default ProtectionDomain on first use
-        return defineClass(className, classRep, offset, length, null);
+        throw new UnsupportedOperationException("can't load this type of class file");
     }
 
     /**
@@ -288,8 +285,7 @@ public abstract class ClassLoader {
      */
     protected final Class<?> defineClass(String className, byte[] classRep, int offset, int length,
             ProtectionDomain protectionDomain) throws java.lang.ClassFormatError {
-
-        return VMClassLoader.defineClass(this, className, classRep, offset, length);
+        throw new UnsupportedOperationException("can't load this type of class file");
     }
 
     /**
diff --git a/luni/src/main/java/java/lang/VMClassLoader.java b/luni/src/main/java/java/lang/VMClassLoader.java
index 8604360..d7162c6 100644
--- a/luni/src/main/java/java/lang/VMClassLoader.java
+++ b/luni/src/main/java/java/lang/VMClassLoader.java
@@ -75,12 +75,6 @@ class VMClassLoader {
 
     native static Class getPrimitiveClass(char type);
 
-    native static Class defineClass(ClassLoader cl, String name, byte[] data, int offset, int len)
-            throws ClassFormatError;
-
-    native static Class defineClass(ClassLoader cl, byte[] data, int offset, int len)
-            throws ClassFormatError;
-
     native static Class findLoadedClass(ClassLoader cl, String name);
 
     /**
diff --git a/luni/src/main/native/JniConstants.cpp b/luni/src/main/native/JniConstants.cpp
deleted file mode 100644
index 8693cf5..0000000
--- a/luni/src/main/native/JniConstants.cpp
+++ /dev/null
@@ -1,128 +0,0 @@
-/*
- * 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 "ScopedLocalRef.h"
-
-#include <stdlib.h>
-
-jclass JniConstants::bidiRunClass;
-jclass JniConstants::bigDecimalClass;
-jclass JniConstants::booleanClass;
-jclass JniConstants::byteArrayClass;
-jclass JniConstants::byteClass;
-jclass JniConstants::calendarClass;
-jclass JniConstants::charsetICUClass;
-jclass JniConstants::constructorClass;
-jclass JniConstants::deflaterClass;
-jclass JniConstants::doubleClass;
-jclass JniConstants::errnoExceptionClass;
-jclass JniConstants::fieldClass;
-jclass JniConstants::fieldPositionIteratorClass;
-jclass JniConstants::fileDescriptorClass;
-jclass JniConstants::gaiExceptionClass;
-jclass JniConstants::inet6AddressClass;
-jclass JniConstants::inetAddressClass;
-jclass JniConstants::inetSocketAddressClass;
-jclass JniConstants::inetUnixAddressClass;
-jclass JniConstants::inflaterClass;
-jclass JniConstants::inputStreamClass;
-jclass JniConstants::integerClass;
-jclass JniConstants::localeDataClass;
-jclass JniConstants::longClass;
-jclass JniConstants::methodClass;
-jclass JniConstants::mutableIntClass;
-jclass JniConstants::mutableLongClass;
-jclass JniConstants::objectClass;
-jclass JniConstants::objectArrayClass;
-jclass JniConstants::outputStreamClass;
-jclass JniConstants::parsePositionClass;
-jclass JniConstants::patternSyntaxExceptionClass;
-jclass JniConstants::realToStringClass;
-jclass JniConstants::socketClass;
-jclass JniConstants::socketImplClass;
-jclass JniConstants::stringClass;
-jclass JniConstants::structAddrinfoClass;
-jclass JniConstants::structFlockClass;
-jclass JniConstants::structGroupReqClass;
-jclass JniConstants::structLingerClass;
-jclass JniConstants::structPasswdClass;
-jclass JniConstants::structPollfdClass;
-jclass JniConstants::structStatClass;
-jclass JniConstants::structStatFsClass;
-jclass JniConstants::structTimevalClass;
-jclass JniConstants::structUcredClass;
-jclass JniConstants::structUtsnameClass;
-
-static jclass findClass(JNIEnv* env, const char* name) {
-    ScopedLocalRef<jclass> localClass(env, env->FindClass(name));
-    jclass result = reinterpret_cast<jclass>(env->NewGlobalRef(localClass.get()));
-    if (result == NULL) {
-        ALOGE("failed to find class '%s'", name);
-        abort();
-    }
-    return result;
-}
-
-void JniConstants::init(JNIEnv* env) {
-    bidiRunClass = findClass(env, "java/text/Bidi$Run");
-    bigDecimalClass = findClass(env, "java/math/BigDecimal");
-    booleanClass = findClass(env, "java/lang/Boolean");
-    byteClass = findClass(env, "java/lang/Byte");
-    byteArrayClass = findClass(env, "[B");
-    calendarClass = findClass(env, "java/util/Calendar");
-    charsetICUClass = findClass(env, "java/nio/charset/CharsetICU");
-    constructorClass = findClass(env, "java/lang/reflect/Constructor");
-    deflaterClass = findClass(env, "java/util/zip/Deflater");
-    doubleClass = findClass(env, "java/lang/Double");
-    errnoExceptionClass = findClass(env, "libcore/io/ErrnoException");
-    fieldClass = findClass(env, "java/lang/reflect/Field");
-    fieldPositionIteratorClass = findClass(env, "libcore/icu/NativeDecimalFormat$FieldPositionIterator");
-    fileDescriptorClass = findClass(env, "java/io/FileDescriptor");
-    gaiExceptionClass = findClass(env, "libcore/io/GaiException");
-    inet6AddressClass = findClass(env, "java/net/Inet6Address");
-    inetAddressClass = findClass(env, "java/net/InetAddress");
-    inetSocketAddressClass = findClass(env, "java/net/InetSocketAddress");
-    inetUnixAddressClass = findClass(env, "java/net/InetUnixAddress");
-    inflaterClass = findClass(env, "java/util/zip/Inflater");
-    inputStreamClass = findClass(env, "java/io/InputStream");
-    integerClass = findClass(env, "java/lang/Integer");
-    localeDataClass = findClass(env, "libcore/icu/LocaleData");
-    longClass = findClass(env, "java/lang/Long");
-    methodClass = findClass(env, "java/lang/reflect/Method");
-    mutableIntClass = findClass(env, "libcore/util/MutableInt");
-    mutableLongClass = findClass(env, "libcore/util/MutableLong");
-    objectClass = findClass(env, "java/lang/Object");
-    objectArrayClass = findClass(env, "[Ljava/lang/Object;");
-    outputStreamClass = findClass(env, "java/io/OutputStream");
-    parsePositionClass = findClass(env, "java/text/ParsePosition");
-    patternSyntaxExceptionClass = findClass(env, "java/util/regex/PatternSyntaxException");
-    realToStringClass = findClass(env, "java/lang/RealToString");
-    socketClass = findClass(env, "java/net/Socket");
-    socketImplClass = findClass(env, "java/net/SocketImpl");
-    stringClass = findClass(env, "java/lang/String");
-    structAddrinfoClass = findClass(env, "libcore/io/StructAddrinfo");
-    structFlockClass = findClass(env, "libcore/io/StructFlock");
-    structGroupReqClass = findClass(env, "libcore/io/StructGroupReq");
-    structLingerClass = findClass(env, "libcore/io/StructLinger");
-    structPasswdClass = findClass(env, "libcore/io/StructPasswd");
-    structPollfdClass = findClass(env, "libcore/io/StructPollfd");
-    structStatClass = findClass(env, "libcore/io/StructStat");
-    structStatFsClass = findClass(env, "libcore/io/StructStatFs");
-    structTimevalClass = findClass(env, "libcore/io/StructTimeval");
-    structUcredClass = findClass(env, "libcore/io/StructUcred");
-    structUtsnameClass = findClass(env, "libcore/io/StructUtsname");
-}
diff --git a/luni/src/main/native/JniConstants.h b/luni/src/main/native/JniConstants.h
deleted file mode 100644
index 8fd7bc8..0000000
--- a/luni/src/main/native/JniConstants.h
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
- * 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"
-
-/**
- * A cache to avoid calling FindClass at runtime.
- *
- * Class lookup is relatively expensive (2.5us on passion-eng at the time of writing), so we do
- * all such lookups eagerly at VM startup. This means that code that never uses, say,
- * java.util.zip.Deflater still has to pay for the lookup, but it means that on a device the cost
- * is definitely paid during boot and amortized. A central cache also removes the temptation to
- * dynamically call FindClass rather than add a small cache to each file that needs one. Another
- * cost is that each class cached here requires a global reference, though in practice we save
- * enough by not having a global reference for each file that uses a class such as java.lang.String
- * which is used in several files.
- *
- * FindClass is still called in a couple of situations: when throwing exceptions, and in some of
- * the serialization code. The former is clearly not a performance case, and we're currently
- * assuming that neither is the latter.
- *
- * TODO: similar arguments hold for field and method IDs; we should cache them centrally too.
- */
-struct JniConstants {
-    static void init(JNIEnv* env);
-
-    static jclass bidiRunClass;
-    static jclass bigDecimalClass;
-    static jclass booleanClass;
-    static jclass byteArrayClass;
-    static jclass byteClass;
-    static jclass calendarClass;
-    static jclass charsetICUClass;
-    static jclass constructorClass;
-    static jclass deflaterClass;
-    static jclass doubleClass;
-    static jclass errnoExceptionClass;
-    static jclass fieldClass;
-    static jclass fieldPositionIteratorClass;
-    static jclass fileDescriptorClass;
-    static jclass gaiExceptionClass;
-    static jclass inet6AddressClass;
-    static jclass inetAddressClass;
-    static jclass inetSocketAddressClass;
-    static jclass inetUnixAddressClass;
-    static jclass inflaterClass;
-    static jclass inputStreamClass;
-    static jclass integerClass;
-    static jclass localeDataClass;
-    static jclass longClass;
-    static jclass methodClass;
-    static jclass mutableIntClass;
-    static jclass mutableLongClass;
-    static jclass objectClass;
-    static jclass objectArrayClass;
-    static jclass outputStreamClass;
-    static jclass parsePositionClass;
-    static jclass patternSyntaxExceptionClass;
-    static jclass realToStringClass;
-    static jclass socketClass;
-    static jclass socketImplClass;
-    static jclass stringClass;
-    static jclass structAddrinfoClass;
-    static jclass structFlockClass;
-    static jclass structGroupReqClass;
-    static jclass structLingerClass;
-    static jclass structPasswdClass;
-    static jclass structPollfdClass;
-    static jclass structStatClass;
-    static jclass structStatFsClass;
-    static jclass structTimevalClass;
-    static jclass structUcredClass;
-    static jclass structUtsnameClass;
-};
-
-#define NATIVE_METHOD(className, functionName, signature) \
-    { #functionName, signature, reinterpret_cast<void*>(className ## _ ## functionName) }
-
-#endif  // JNI_CONSTANTS_H_included
diff --git a/luni/src/main/native/Register.cpp b/luni/src/main/native/Register.cpp
index 348378f..8418ef3 100644
--- a/luni/src/main/native/Register.cpp
+++ b/luni/src/main/native/Register.cpp
@@ -31,8 +31,6 @@ int JNI_OnLoad(JavaVM* vm, void*) {
 
     ScopedLocalFrame localFrame(env);
 
-    JniConstants::init(env);
-
 #define REGISTER(FN) extern void FN(JNIEnv*); FN(env)
     REGISTER(register_java_io_Console);
     REGISTER(register_java_io_File);
diff --git a/luni/src/main/native/sub.mk b/luni/src/main/native/sub.mk
index 9c8b97f..5627167 100644
--- a/luni/src/main/native/sub.mk
+++ b/luni/src/main/native/sub.mk
@@ -6,7 +6,6 @@
 LOCAL_SRC_FILES := \
 	AsynchronousSocketCloseMonitor.cpp \
 	IcuUtilities.cpp \
-	JniConstants.cpp \
 	JniException.cpp \
 	NetworkUtilities.cpp \
 	Register.cpp \
@@ -51,7 +50,6 @@ LOCAL_SRC_FILES := \
 	readlink.cpp \
 	realpath.cpp \
 	sun_misc_Unsafe.cpp \
-	toStringArray.cpp \
 	valueOf.cpp
 
 LOCAL_C_INCLUDES += \
diff --git a/luni/src/main/native/toStringArray.cpp b/luni/src/main/native/toStringArray.cpp
deleted file mode 100644
index 9640d22..0000000
--- a/luni/src/main/native/toStringArray.cpp
+++ /dev/null
@@ -1,102 +0,0 @@
-/*
- * Copyright (C) 2011 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 "toStringArray.h"
-
-#include <string>
-#include <vector>
-
-struct VectorCounter {
-    const std::vector<std::string>& strings;
-    VectorCounter(const std::vector<std::string>& strings) : strings(strings) {}
-    size_t operator()() {
-        return strings.size();
-    }
-};
-struct VectorGetter {
-    const std::vector<std::string>& strings;
-    VectorGetter(const std::vector<std::string>& strings) : strings(strings) {}
-    const char* operator()(size_t i) {
-        return strings[i].c_str();
-    }
-};
-
-jobjectArray toStringArray(JNIEnv* env, const std::vector<std::string>& strings) {
-    VectorCounter counter(strings);
-    VectorGetter getter(strings);
-    return toStringArray<VectorCounter, VectorGetter>(env, &counter, &getter);
-}
-
-struct ArrayCounter {
-    const char* const* strings;
-    ArrayCounter(const char* const* strings) : strings(strings) {}
-    size_t operator()() {
-        size_t count = 0;
-        while (strings[count] != NULL) {
-            ++count;
-        }
-        return count;
-    }
-};
-
-struct ArrayGetter {
-    const char* const* strings;
-    ArrayGetter(const char* const* strings) : strings(strings) {}
-    const char* operator()(size_t i) {
-        return strings[i];
-    }
-};
-
-jobjectArray toStringArray(JNIEnv* env, const char* const* strings) {
-    ArrayCounter counter(strings);
-    ArrayGetter getter(strings);
-    return toStringArray(env, &counter, &getter);
-}
-
-/** Converts a Java String[] to a 0-terminated char**. */
-char** convertStrings(JNIEnv* env, jobjectArray javaArray) {
-    if (javaArray == NULL) {
-        return NULL;
-    }
-
-    jsize length = env->GetArrayLength(javaArray);
-    char** array = new char*[length + 1];
-    array[length] = 0;
-    for (jsize i = 0; i < length; ++i) {
-        ScopedLocalRef<jstring> javaEntry(env, reinterpret_cast<jstring>(env->GetObjectArrayElement(javaArray, i)));
-        // We need to pass these strings to const-unfriendly code.
-        char* entry = const_cast<char*>(env->GetStringUTFChars(javaEntry.get(), NULL));
-        array[i] = entry;
-    }
-
-    return array;
-}
-
-/** Frees a char** which was converted from a Java String[]. */
-void freeStrings(JNIEnv* env, jobjectArray javaArray, char** array) {
-    if (javaArray == NULL) {
-        return;
-    }
-
-    jsize length = env->GetArrayLength(javaArray);
-    for (jsize i = 0; i < length; ++i) {
-        ScopedLocalRef<jstring> javaEntry(env, reinterpret_cast<jstring>(env->GetObjectArrayElement(javaArray, i)));
-        env->ReleaseStringUTFChars(javaEntry.get(), array[i]);
-    }
-
-    delete[] array;
-}
diff --git a/luni/src/main/native/toStringArray.h b/luni/src/main/native/toStringArray.h
deleted file mode 100644
index c65b8ad..0000000
--- a/luni/src/main/native/toStringArray.h
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
- * Copyright (C) 2011 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 "jni.h"
-#include "ScopedLocalRef.h"
-
-#include <string>
-#include <vector>
-
-template <typename Counter, typename Getter>
-jobjectArray toStringArray(JNIEnv* env, Counter* counter, Getter* getter) {
-    size_t count = (*counter)();
-    jobjectArray result = env->NewObjectArray(count, JniConstants::stringClass, NULL);
-    if (result == NULL) {
-        return NULL;
-    }
-    for (size_t i = 0; i < count; ++i) {
-        ScopedLocalRef<jstring> s(env, env->NewStringUTF((*getter)(i)));
-        if (env->ExceptionCheck()) {
-            return NULL;
-        }
-        env->SetObjectArrayElement(result, i, s.get());
-        if (env->ExceptionCheck()) {
-            return NULL;
-        }
-    }
-    return result;
-}
-
-template <typename Counter, typename Getter>
-jobjectArray toStringArray16(JNIEnv* env, Counter* counter, Getter* getter) {
-    size_t count = (*counter)();
-    jobjectArray result = env->NewObjectArray(count, JniConstants::stringClass, NULL);
-    if (result == NULL) {
-        return NULL;
-    }
-    for (size_t i = 0; i < count; ++i) {
-        int32_t charCount;
-        const jchar* chars = (*getter)(&charCount);
-        ScopedLocalRef<jstring> s(env, env->NewString(chars, charCount));
-        if (env->ExceptionCheck()) {
-            return NULL;
-        }
-        env->SetObjectArrayElement(result, i, s.get());
-        if (env->ExceptionCheck()) {
-            return NULL;
-        }
-    }
-    return result;
-}
-
-jobjectArray toStringArray(JNIEnv* env, const std::vector<std::string>& strings);
-jobjectArray toStringArray(JNIEnv* env, const char* const* strings);
-
-char** convertStrings(JNIEnv* env, jobjectArray javaArray);
-void freeStrings(JNIEnv* env, jobjectArray javaArray, char** array);