diff --git a/src/class_linker.cc b/src/class_linker.cc
index 2aed455..ac11578 100644
--- a/src/class_linker.cc
+++ b/src/class_linker.cc
@@ -484,7 +484,7 @@
   dst->name_ = ResolveString(klass, method_id.name_idx_, dex_file);
   {
     int32_t utf16_length;
-    scoped_ptr<char> utf8(dex_file.CreateMethodDescriptor(method_id.proto_idx_,
+    scoped_array<char> utf8(dex_file.CreateMethodDescriptor(method_id.proto_idx_,
                                                           &utf16_length));
     dst->descriptor_ = String::AllocFromModifiedUtf8(utf16_length, utf8.get());
   }
diff --git a/src/common_test.h b/src/common_test.h
index f1c952c..2ae4159 100644
--- a/src/common_test.h
+++ b/src/common_test.h
@@ -342,7 +342,7 @@
 
   DexFile* GetLibCoreDex() {
     std::string libcore_dex_file_name = GetLibCoreDexFileName();
-    return DexFile::OpenZip(libcore_dex_file_name.c_str());
+    return DexFile::OpenZip(libcore_dex_file_name);
   }
 
   void UseLibCoreDex() {
diff --git a/src/dex_file.cc b/src/dex_file.cc
index b3bb7d2..3cddd7f 100644
--- a/src/dex_file.cc
+++ b/src/dex_file.cc
@@ -151,6 +151,7 @@
                                 adjacent_dex_filename.end(),
                                 ".dex");
   // Example adjacent_dex_filename = dir/foo.dex
+  // TODO: stat first, so we don't report a bogus error.
   DexFile* adjacent_dex_file = DexFile::OpenFile(adjacent_dex_filename);
   if (adjacent_dex_file != NULL) {
       // We don't verify anything in this case, because we aren't in
@@ -204,11 +205,18 @@
     // lock. If somebody else is working on it, we'll block here until
     // they complete.  Because we're waiting on an external resource,
     // we go into native mode.
+    // Note that current_thread can be NULL if we're parsing the bootclasspath
+    // during JNI_CreateJavaVM.
     Thread* current_thread = Thread::Current();
-    Thread::State old = current_thread->GetState();
-    current_thread->SetState(Thread::kNative);
+    Thread::State old;
+    if (current_thread != NULL) {
+        old = current_thread->GetState();
+        current_thread->SetState(Thread::kNative);
+    }
     scoped_ptr<LockedFd> fd(LockedFd::CreateAndLock(cache_path_tmp, 0644));
-    current_thread->SetState(old);
+    if (current_thread != NULL) {
+        current_thread->SetState(old);
+    }
     if (fd == NULL) {
       return NULL;
     }
diff --git a/src/intern_table.cc b/src/intern_table.cc
index 31749fd..3a0dff8 100644
--- a/src/intern_table.cc
+++ b/src/intern_table.cc
@@ -19,7 +19,7 @@
 }
 
 String* InternTable::Intern(int32_t utf16_length, const char* utf8_data_in) {
-  scoped_ptr<uint16_t> utf16_data_out(new uint16_t[utf16_length]);
+  scoped_array<uint16_t> utf16_data_out(new uint16_t[utf16_length]);
   String::ConvertModifiedUtf8ToUtf16(utf16_data_out.get(), utf8_data_in);
   int32_t hash_code = String::ComputeUtf16Hash(utf16_data_out.get(), utf16_length);
   {
diff --git a/src/jni_compiler.cc b/src/jni_compiler.cc
index 436d4d8..b7d8f5d 100644
--- a/src/jni_compiler.cc
+++ b/src/jni_compiler.cc
@@ -134,9 +134,11 @@
       FrameOffset out_off = jni_conv.CurrentParamStackOffset();
       jni_asm->StoreRawPtr(out_off, jni_env_register);
     }
-    // Call JNIEnv*->MonitorEnter(JNIEnv*, object)
-    jni_asm->Call(jni_env_register, JniEnvironment::MonitorEnterOffset(),
+    // Call JNIEnvExt::MonitorEnterHelper(JNIEnv*, object)
+    static Offset monitor_enter(OFFSETOF_MEMBER(JNIEnvExt, MonitorEnterHelper));
+    jni_asm->Call(jni_env_register, monitor_enter,
                   jni_conv.InterproceduralScratchRegister());
+    jni_asm->ExceptionPoll(jni_conv.InterproceduralScratchRegister());
   }
 
   // 8. Iterate over arguments placing values from managed calling convention in
@@ -232,9 +234,11 @@
       FrameOffset out_off = jni_conv.CurrentParamStackOffset();
       jni_asm->StoreRawPtr(out_off, jni_env_register);
     }
-    // Call JNIEnv*->MonitorExit(JNIEnv*, object)
-    jni_asm->Call(jni_env_register, JniEnvironment::MonitorExitOffset(),
+    // Call JNIEnvExt::MonitorExitHelper(JNIEnv*, object)
+    static Offset monitor_exit(OFFSETOF_MEMBER(JNIEnvExt, MonitorExitHelper));
+    jni_asm->Call(jni_env_register, monitor_exit,
                   jni_conv.InterproceduralScratchRegister());
+    jni_asm->ExceptionPoll(jni_conv.InterproceduralScratchRegister());
     // Reload return value
     jni_asm->Load(jni_conv.ReturnRegister(), return_save_location,
                   jni_conv.SizeOfReturnValue());
diff --git a/src/jni_internal.cc b/src/jni_internal.cc
index a495d65..839ad0e 100644
--- a/src/jni_internal.cc
+++ b/src/jni_internal.cc
@@ -5,6 +5,7 @@
 #include <vector>
 #include <utility>
 
+#include "class_linker.h"
 #include "jni.h"
 #include "logging.h"
 #include "runtime.h"
@@ -14,1673 +15,1219 @@
 
 namespace art {
 
-static void JniMonitorEnter(JniEnvironment*, jobject) {
-  LOG(WARNING) << "Unimplemented: JNI Monitor Enter";
-}
-
-static void JniMonitorExit(JniEnvironment*, jobject) {
-  LOG(WARNING) << "Unimplemented: JNI Monitor Exit";
-}
-
-JniEnvironment::JniEnvironment() {
-  monitor_enter_ = &JniMonitorEnter;
-  monitor_exit_ = &JniMonitorExit;
-}
-
-// JNI Native interface.
-
-jint JniNativeInterface::GetVersion(JNIEnv* env) {
+jint GetVersion(JNIEnv* env) {
   return JNI_VERSION_1_6;
 }
 
-jclass JniNativeInterface::DefineClass(JNIEnv *env,
-                                       const char *name,
-                                       jobject loader,
-                                       const jbyte *buf,
-                                       jsize len) {
+jclass DefineClass(JNIEnv *env, const char *name,
+    jobject loader, const jbyte *buf, jsize len) {
   LOG(FATAL) << "Unimplemented";
   return NULL;
 }
 
-jclass JniNativeInterface::FindClass(JNIEnv *env, const char *name) {
+jclass FindClass(JNIEnv* env, const char* name) {
+  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
+  // TODO: need to get the appropriate ClassLoader.
+  Class* c = class_linker->FindClass(name, NULL);
+  // TODO: local reference.
+  return reinterpret_cast<jclass>(c);
+}
+
+jmethodID FromReflectedMethod(JNIEnv* env, jobject method) {
   LOG(FATAL) << "Unimplemented";
   return NULL;
 }
 
-jmethodID JniNativeInterface::FromReflectedMethod(JNIEnv* env, jobject method) {
+jfieldID FromReflectedField(JNIEnv* env, jobject field) {
   LOG(FATAL) << "Unimplemented";
   return NULL;
 }
 
-jfieldID JniNativeInterface::FromReflectedField(JNIEnv* env, jobject field) {
+jobject ToReflectedMethod(JNIEnv* env, jclass cls,
+    jmethodID methodID, jboolean isStatic) {
   LOG(FATAL) << "Unimplemented";
   return NULL;
 }
 
-jobject JniNativeInterface::ToReflectedMethod(JNIEnv* env,
-                                              jclass cls,
-                                              jmethodID methodID,
-                                              jboolean isStatic) {
+jclass GetSuperclass(JNIEnv* env, jclass sub) {
   LOG(FATAL) << "Unimplemented";
   return NULL;
 }
 
-jclass JniNativeInterface::GetSuperclass(JNIEnv* env, jclass sub) {
-  LOG(FATAL) << "Unimplemented";
-  return NULL;
-}
-
-jboolean JniNativeInterface::IsAssignableFrom(JNIEnv* env,
-                                              jclass sub,
-                                              jclass sup) {
+jboolean IsAssignableFrom(JNIEnv* env, jclass sub, jclass sup) {
   LOG(FATAL) << "Unimplemented";
   return JNI_FALSE;
 }
 
-jobject JniNativeInterface::ToReflectedField(JNIEnv* env,
-                                             jclass cls,
-                                             jfieldID fieldID,
-                                             jboolean isStatic) {
+jobject ToReflectedField(JNIEnv* env, jclass cls,
+    jfieldID fieldID, jboolean isStatic) {
   LOG(FATAL) << "Unimplemented";
   return NULL;
 }
 
-jint JniNativeInterface::Throw(JNIEnv* env, jthrowable obj) {
+jint Throw(JNIEnv* env, jthrowable obj) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jint JniNativeInterface::ThrowNew(JNIEnv* env, jclass clazz, const char* msg) {
+jint ThrowNew(JNIEnv* env, jclass clazz, const char* msg) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jthrowable JniNativeInterface::ExceptionOccurred(JNIEnv* env) {
+jthrowable ExceptionOccurred(JNIEnv* env) {
   LOG(FATAL) << "Unimplemented";
   return NULL;
 }
 
-void JniNativeInterface::ExceptionDescribe(JNIEnv* env) {
+void ExceptionDescribe(JNIEnv* env) {
   LOG(FATAL) << "Unimplemented";
 }
 
-void JniNativeInterface::ExceptionClear(JNIEnv* env) {
+void ExceptionClear(JNIEnv* env) {
   LOG(FATAL) << "Unimplemented";
 }
 
-void JniNativeInterface::FatalError(JNIEnv* env, const char* msg) {
+void FatalError(JNIEnv* env, const char* msg) {
   LOG(FATAL) << "Unimplemented";
 }
 
-jint JniNativeInterface::PushLocalFrame(JNIEnv* env, jint cap) {
+jint PushLocalFrame(JNIEnv* env, jint cap) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jobject JniNativeInterface::PopLocalFrame(JNIEnv* env, jobject res) {
+jobject PopLocalFrame(JNIEnv* env, jobject res) {
   LOG(FATAL) << "Unimplemented";
   return NULL;
 }
 
-jobject JniNativeInterface::NewGlobalRef(JNIEnv* env, jobject lobj) {
+jobject NewGlobalRef(JNIEnv* env, jobject lobj) {
   LOG(FATAL) << "Unimplemented";
   return NULL;
 }
 
-void JniNativeInterface::DeleteGlobalRef(JNIEnv* env, jobject gref) {
+void DeleteGlobalRef(JNIEnv* env, jobject gref) {
   LOG(FATAL) << "Unimplemented";
 }
 
-void JniNativeInterface::DeleteLocalRef(JNIEnv* env, jobject obj) {
+void DeleteLocalRef(JNIEnv* env, jobject obj) {
   LOG(FATAL) << "Unimplemented";
 }
 
-jboolean JniNativeInterface::IsSameObject(JNIEnv* env,
-                                          jobject obj1,
-                                          jobject obj2) {
+jboolean IsSameObject(JNIEnv* env, jobject obj1, jobject obj2) {
   LOG(FATAL) << "Unimplemented";
   return JNI_FALSE;
 }
 
-jobject JniNativeInterface::NewLocalRef(JNIEnv* env, jobject ref) {
+jobject NewLocalRef(JNIEnv* env, jobject ref) {
   LOG(FATAL) << "Unimplemented";
   return NULL;
 }
 
-jint JniNativeInterface::EnsureLocalCapacity(JNIEnv* env, jint) {
+jint EnsureLocalCapacity(JNIEnv* env, jint) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jobject JniNativeInterface::AllocObject(JNIEnv* env, jclass clazz) {
+jobject AllocObject(JNIEnv* env, jclass clazz) {
   LOG(FATAL) << "Unimplemented";
   return NULL;
 }
 
-jobject JniNativeInterface::NewObject(JNIEnv* env,
-                                      jclass clazz,
-                                      jmethodID methodID,
-                                      ...) {
+jobject NewObject(JNIEnv* env, jclass clazz, jmethodID methodID, ...) {
   LOG(FATAL) << "Unimplemented";
   return NULL;
 }
 
-jobject JniNativeInterface::NewObjectV(JNIEnv* env,
-                                       jclass clazz,
-                                       jmethodID methodID,
-                                       va_list args) {
+jobject NewObjectV(JNIEnv* env,
+    jclass clazz, jmethodID methodID, va_list args) {
   LOG(FATAL) << "Unimplemented";
   return NULL;
 }
 
-jobject JniNativeInterface::NewObjectA(JNIEnv* env,
-                                       jclass clazz,
-                                       jmethodID methodID,
-                                       jvalue* args) {
+jobject NewObjectA(JNIEnv* env,
+    jclass clazz, jmethodID methodID, jvalue* args) {
   LOG(FATAL) << "Unimplemented";
   return NULL;
 }
 
-jclass JniNativeInterface::GetObjectClass(JNIEnv* env, jobject obj) {
+jclass GetObjectClass(JNIEnv* env, jobject obj) {
   LOG(FATAL) << "Unimplemented";
   return NULL;
 }
 
-jboolean JniNativeInterface::IsInstanceOf(JNIEnv* env,
-                                          jobject obj,
-                                          jclass clazz) {
+jboolean IsInstanceOf(JNIEnv* env, jobject obj, jclass clazz) {
   LOG(FATAL) << "Unimplemented";
   return JNI_FALSE;
 }
 
-jmethodID JniNativeInterface::GetMethodID(JNIEnv* env,
-                                          jclass clazz,
-                                          const char* name,
-                                          const char* sig) {
+jmethodID GetMethodID(JNIEnv* env,
+    jclass clazz, const char* name, const char* sig) {
   LOG(FATAL) << "Unimplemented";
   return NULL;
 }
 
-jobject JniNativeInterface::CallObjectMethod(JNIEnv* env,
-                                             jobject obj,
-                                             jmethodID methodID,
-                                             ...) {
+jobject CallObjectMethod(JNIEnv* env, jobject obj, jmethodID methodID, ...) {
   LOG(FATAL) << "Unimplemented";
   return NULL;
 }
 
-jobject JniNativeInterface::CallObjectMethodV(JNIEnv* env,
-                                              jobject obj,
-                                              jmethodID methodID,
-                                              va_list args) {
+jobject CallObjectMethodV(JNIEnv* env,
+    jobject obj, jmethodID methodID, va_list args) {
   LOG(FATAL) << "Unimplemented";
   return NULL;
 }
 
-jobject JniNativeInterface::CallObjectMethodA(JNIEnv* env,
-                                              jobject obj,
-                                              jmethodID methodID,
-                                              jvalue*  args) {
+jobject CallObjectMethodA(JNIEnv* env,
+    jobject obj, jmethodID methodID, jvalue*  args) {
   LOG(FATAL) << "Unimplemented";
   return NULL;
 }
 
-jboolean JniNativeInterface::CallBooleanMethod(JNIEnv* env,
-                                               jobject obj,
-                                               jmethodID methodID,
-                                               ...) {
+jboolean CallBooleanMethod(JNIEnv* env, jobject obj, jmethodID methodID, ...) {
   LOG(FATAL) << "Unimplemented";
   return JNI_FALSE;
 }
 
-jboolean JniNativeInterface::CallBooleanMethodV(JNIEnv* env,
-                                                jobject obj,
-                                                jmethodID methodID,
-                                                va_list args) {
+jboolean CallBooleanMethodV(JNIEnv* env,
+    jobject obj, jmethodID methodID, va_list args) {
   LOG(FATAL) << "Unimplemented";
   return JNI_FALSE;
 }
 
-jboolean JniNativeInterface::CallBooleanMethodA(JNIEnv* env,
-                                                jobject obj,
-                                                jmethodID methodID,
-                                                jvalue*  args) {
+jboolean CallBooleanMethodA(JNIEnv* env,
+    jobject obj, jmethodID methodID, jvalue*  args) {
   LOG(FATAL) << "Unimplemented";
   return JNI_FALSE;
 }
 
-jbyte JniNativeInterface::CallByteMethod(JNIEnv* env,
-                                         jobject obj,
-                                         jmethodID methodID,
-                                         ...) {
+jbyte CallByteMethod(JNIEnv* env, jobject obj, jmethodID methodID, ...) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jbyte JniNativeInterface::CallByteMethodV(JNIEnv* env,
-                                          jobject obj,
-                                          jmethodID methodID,
-                                          va_list args) {
+jbyte CallByteMethodV(JNIEnv* env,
+    jobject obj, jmethodID methodID, va_list args) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jbyte JniNativeInterface::CallByteMethodA(JNIEnv* env,
-                                          jobject obj,
-                                          jmethodID methodID,
-                                          jvalue* args) {
+jbyte CallByteMethodA(JNIEnv* env,
+    jobject obj, jmethodID methodID, jvalue* args) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jchar JniNativeInterface::CallCharMethod(JNIEnv* env,
-                                         jobject obj,
-                                         jmethodID methodID, ...) {
+jchar CallCharMethod(JNIEnv* env, jobject obj, jmethodID methodID, ...) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jchar JniNativeInterface::CallCharMethodV(JNIEnv* env,
-                                          jobject obj,
-                                          jmethodID methodID,
-                                          va_list args) {
+jchar CallCharMethodV(JNIEnv* env,
+    jobject obj, jmethodID methodID, va_list args) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jchar JniNativeInterface::CallCharMethodA(JNIEnv* env,
-                                          jobject obj,
-                                          jmethodID methodID,
-                                          jvalue* args) {
+jchar CallCharMethodA(JNIEnv* env,
+    jobject obj, jmethodID methodID, jvalue* args) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jshort JniNativeInterface::CallShortMethod(JNIEnv* env,
-                                           jobject obj,
-                                           jmethodID methodID,
-                                           ...) {
+jshort CallShortMethod(JNIEnv* env, jobject obj, jmethodID methodID, ...) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jshort JniNativeInterface::CallShortMethodV(JNIEnv* env,
-                                            jobject obj,
-                                            jmethodID methodID,
-                                            va_list args) {
+jshort CallShortMethodV(JNIEnv* env,
+    jobject obj, jmethodID methodID, va_list args) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jshort JniNativeInterface::CallShortMethodA(JNIEnv* env,
-                                            jobject obj,
-                                            jmethodID methodID,
-                                            jvalue* args) {
+jshort CallShortMethodA(JNIEnv* env,
+    jobject obj, jmethodID methodID, jvalue* args) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jint JniNativeInterface::CallIntMethod(JNIEnv* env,
-                                       jobject obj,
-                                       jmethodID methodID,
-                                       ...) {
+jint CallIntMethod(JNIEnv* env, jobject obj, jmethodID methodID, ...) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jint JniNativeInterface::CallIntMethodV(JNIEnv* env,
-                                        jobject obj,
-                                        jmethodID methodID,
-                                        va_list args) {
+jint CallIntMethodV(JNIEnv* env,
+    jobject obj, jmethodID methodID, va_list args) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jint JniNativeInterface::CallIntMethodA(JNIEnv* env,
-                                        jobject obj,
-                                        jmethodID methodID,
-                                        jvalue* args) {
+jint CallIntMethodA(JNIEnv* env,
+    jobject obj, jmethodID methodID, jvalue* args) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jlong JniNativeInterface::CallLongMethod(JNIEnv* env,
-                                         jobject obj,
-                                         jmethodID methodID,
-                                         ...) {
+jlong CallLongMethod(JNIEnv* env, jobject obj, jmethodID methodID, ...) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jlong JniNativeInterface::CallLongMethodV(JNIEnv* env,
-                                          jobject obj,
-                                          jmethodID methodID,
-                                          va_list args) {
+jlong CallLongMethodV(JNIEnv* env,
+    jobject obj, jmethodID methodID, va_list args) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jlong JniNativeInterface::CallLongMethodA(JNIEnv* env,
-                                          jobject obj,
-                                          jmethodID methodID,
-                                          jvalue* args) {
+jlong CallLongMethodA(JNIEnv* env,
+    jobject obj, jmethodID methodID, jvalue* args) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jfloat JniNativeInterface::CallFloatMethod(JNIEnv* env,
-                                           jobject obj,
-                                           jmethodID methodID,
-                                           ...) {
+jfloat CallFloatMethod(JNIEnv* env, jobject obj, jmethodID methodID, ...) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jfloat JniNativeInterface::CallFloatMethodV(JNIEnv* env,
-                                            jobject obj,
-                                            jmethodID methodID,
-                                            va_list args) {
+jfloat CallFloatMethodV(JNIEnv* env,
+    jobject obj, jmethodID methodID, va_list args) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jfloat JniNativeInterface::CallFloatMethodA(JNIEnv* env,
-                                            jobject obj,
-                                            jmethodID methodID,
-                                            jvalue* args) {
+jfloat CallFloatMethodA(JNIEnv* env,
+    jobject obj, jmethodID methodID, jvalue* args) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jdouble JniNativeInterface::CallDoubleMethod(JNIEnv* env,
-                                             jobject obj,
-                                             jmethodID methodID,
-                                             ...) {
+jdouble CallDoubleMethod(JNIEnv* env, jobject obj, jmethodID methodID, ...) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jdouble JniNativeInterface::CallDoubleMethodV(JNIEnv* env,
-                                              jobject obj,
-                                              jmethodID methodID,
-                                              va_list args) {
+jdouble CallDoubleMethodV(JNIEnv* env,
+    jobject obj, jmethodID methodID, va_list args) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jdouble JniNativeInterface::CallDoubleMethodA(JNIEnv* env,
-                                              jobject obj,
-                                              jmethodID methodID,
-                                              jvalue* args) {
+jdouble CallDoubleMethodA(JNIEnv* env,
+    jobject obj, jmethodID methodID, jvalue* args) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-void JniNativeInterface::CallVoidMethod(JNIEnv* env,
-                                        jobject obj,
-                                        jmethodID methodID,
-                                        ...) {
+void CallVoidMethod(JNIEnv* env, jobject obj, jmethodID methodID, ...) {
   LOG(FATAL) << "Unimplemented";
 }
 
-void JniNativeInterface::CallVoidMethodV(JNIEnv* env,
-                                         jobject obj,
-                                         jmethodID methodID,
-                                         va_list args) {
+void CallVoidMethodV(JNIEnv* env, jobject obj,
+    jmethodID methodID, va_list args) {
   LOG(FATAL) << "Unimplemented";
 }
 
-void JniNativeInterface::CallVoidMethodA(JNIEnv* env,
-                                         jobject obj,
-                                         jmethodID methodID,
-                                         jvalue*  args) {
+void CallVoidMethodA(JNIEnv* env, jobject obj,
+    jmethodID methodID, jvalue*  args) {
   LOG(FATAL) << "Unimplemented";
 }
 
-jobject JniNativeInterface::CallNonvirtualObjectMethod(JNIEnv* env,
-                                                       jobject obj,
-                                                       jclass clazz,
-                                                       jmethodID methodID,
-                                                       ...) {
+jobject CallNonvirtualObjectMethod(JNIEnv* env,
+    jobject obj, jclass clazz, jmethodID methodID, ...) {
   LOG(FATAL) << "Unimplemented";
   return NULL;
 }
 
-jobject JniNativeInterface::CallNonvirtualObjectMethodV(JNIEnv* env,
-                                                        jobject obj,
-                                                        jclass clazz,
-                                                        jmethodID methodID,
-                                                        va_list args) {
+jobject CallNonvirtualObjectMethodV(JNIEnv* env,
+    jobject obj, jclass clazz, jmethodID methodID, va_list args) {
   LOG(FATAL) << "Unimplemented";
   return NULL;
 }
 
-jobject JniNativeInterface::CallNonvirtualObjectMethodA(JNIEnv* env,
-                                                        jobject obj,
-                                                        jclass clazz,
-                                                        jmethodID methodID,
-                                                        jvalue*  args) {
+jobject CallNonvirtualObjectMethodA(JNIEnv* env,
+    jobject obj, jclass clazz, jmethodID methodID, jvalue*  args) {
   LOG(FATAL) << "Unimplemented";
   return NULL;
 }
 
-jboolean JniNativeInterface::CallNonvirtualBooleanMethod(JNIEnv* env,
-                                                         jobject obj,
-                                                         jclass clazz,
-                                                         jmethodID methodID,
-                                                         ...) {
+jboolean CallNonvirtualBooleanMethod(JNIEnv* env,
+    jobject obj, jclass clazz, jmethodID methodID, ...) {
   LOG(FATAL) << "Unimplemented";
   return JNI_FALSE;
 }
 
-jboolean JniNativeInterface::CallNonvirtualBooleanMethodV(JNIEnv* env,
-                                                          jobject obj,
-                                                          jclass clazz,
-                                                          jmethodID methodID,
-                                                          va_list args) {
+jboolean CallNonvirtualBooleanMethodV(JNIEnv* env,
+    jobject obj, jclass clazz, jmethodID methodID, va_list args) {
   LOG(FATAL) << "Unimplemented";
   return JNI_FALSE;
 }
 
-jboolean JniNativeInterface::CallNonvirtualBooleanMethodA(JNIEnv* env,
-                                                          jobject obj,
-                                                          jclass clazz,
-                                                          jmethodID methodID,
-                                                          jvalue*  args) {
+jboolean CallNonvirtualBooleanMethodA(JNIEnv* env,
+    jobject obj, jclass clazz, jmethodID methodID, jvalue*  args) {
   LOG(FATAL) << "Unimplemented";
   return JNI_FALSE;
 }
 
-jbyte JniNativeInterface::CallNonvirtualByteMethod(JNIEnv* env,
-                                                   jobject obj,
-                                                   jclass clazz,
-                                                   jmethodID methodID,
-                                                   ...) {
+jbyte CallNonvirtualByteMethod(JNIEnv* env,
+    jobject obj, jclass clazz, jmethodID methodID, ...) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jbyte JniNativeInterface::CallNonvirtualByteMethodV(JNIEnv* env,
-                                                    jobject obj,
-                                                    jclass clazz,
-                                                    jmethodID methodID,
-                                                    va_list args) {
+jbyte CallNonvirtualByteMethodV(JNIEnv* env,
+    jobject obj, jclass clazz, jmethodID methodID, va_list args) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jbyte JniNativeInterface::CallNonvirtualByteMethodA(JNIEnv* env,
-                                                    jobject obj,
-                                                    jclass clazz,
-                                                    jmethodID methodID,
-                                                    jvalue* args) {
+jbyte CallNonvirtualByteMethodA(JNIEnv* env,
+    jobject obj, jclass clazz, jmethodID methodID, jvalue* args) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jchar JniNativeInterface::CallNonvirtualCharMethod(JNIEnv* env,
-                                                   jobject obj,
-                                                   jclass clazz,
-                                                   jmethodID methodID,
-                                                   ...) {
+jchar CallNonvirtualCharMethod(JNIEnv* env,
+    jobject obj, jclass clazz, jmethodID methodID, ...) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jchar JniNativeInterface::CallNonvirtualCharMethodV(JNIEnv* env,
-                                                    jobject obj,
-                                                    jclass clazz,
-                                                    jmethodID methodID,
-                                                    va_list args) {
+jchar CallNonvirtualCharMethodV(JNIEnv* env,
+    jobject obj, jclass clazz, jmethodID methodID, va_list args) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jchar JniNativeInterface::CallNonvirtualCharMethodA(JNIEnv* env,
-                                                    jobject obj,
-                                                    jclass clazz,
-                                                    jmethodID methodID,
-                                                    jvalue* args) {
+jchar CallNonvirtualCharMethodA(JNIEnv* env,
+    jobject obj, jclass clazz, jmethodID methodID, jvalue* args) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jshort JniNativeInterface::CallNonvirtualShortMethod(JNIEnv* env,
-                                                     jobject obj,
-                                                     jclass clazz,
-                                                     jmethodID methodID,
-                                                     ...) {
+jshort CallNonvirtualShortMethod(JNIEnv* env,
+    jobject obj, jclass clazz, jmethodID methodID, ...) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jshort JniNativeInterface::CallNonvirtualShortMethodV(JNIEnv* env,
-                                                      jobject obj,
-                                                      jclass clazz,
-                                                      jmethodID methodID,
-                                                      va_list args) {
+jshort CallNonvirtualShortMethodV(JNIEnv* env,
+    jobject obj, jclass clazz, jmethodID methodID, va_list args) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jshort JniNativeInterface::CallNonvirtualShortMethodA(JNIEnv* env,
-                                                      jobject obj,
-                                                      jclass clazz,
-                                                      jmethodID methodID,
-                                                      jvalue* args) {
+jshort CallNonvirtualShortMethodA(JNIEnv* env,
+    jobject obj, jclass clazz, jmethodID methodID, jvalue* args) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jint JniNativeInterface::CallNonvirtualIntMethod(JNIEnv* env,
-                                                 jobject obj,
-                                                 jclass clazz,
-                                                 jmethodID methodID,
-                                                 ...) {
+jint CallNonvirtualIntMethod(JNIEnv* env,
+    jobject obj, jclass clazz, jmethodID methodID, ...) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jint JniNativeInterface::CallNonvirtualIntMethodV(JNIEnv* env,
-                                                  jobject obj,
-                                                  jclass clazz,
-                                                  jmethodID methodID,
-                                                  va_list args) {
+jint CallNonvirtualIntMethodV(JNIEnv* env,
+    jobject obj, jclass clazz, jmethodID methodID, va_list args) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jint JniNativeInterface::CallNonvirtualIntMethodA(JNIEnv* env,
-                                                  jobject obj,
-                                                  jclass clazz,
-                                                  jmethodID methodID,
-                                                  jvalue* args) {
+jint CallNonvirtualIntMethodA(JNIEnv* env,
+    jobject obj, jclass clazz, jmethodID methodID, jvalue* args) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jlong JniNativeInterface::CallNonvirtualLongMethod(JNIEnv* env,
-                                                   jobject obj,
-                                                   jclass clazz,
-                                                   jmethodID methodID,
-                                                   ...) {
+jlong CallNonvirtualLongMethod(JNIEnv* env,
+    jobject obj, jclass clazz, jmethodID methodID, ...) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jlong JniNativeInterface::CallNonvirtualLongMethodV(JNIEnv* env,
-                                                    jobject obj,
-                                                    jclass clazz,
-                                                    jmethodID methodID,
-                                                    va_list args) {
+jlong CallNonvirtualLongMethodV(JNIEnv* env,
+    jobject obj, jclass clazz, jmethodID methodID, va_list args) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jlong JniNativeInterface::CallNonvirtualLongMethodA(JNIEnv* env,
-                                                    jobject obj,
-                                                    jclass clazz,
-                                                    jmethodID methodID,
-                                                    jvalue* args) {
+jlong CallNonvirtualLongMethodA(JNIEnv* env,
+    jobject obj, jclass clazz, jmethodID methodID, jvalue* args) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jfloat JniNativeInterface::CallNonvirtualFloatMethod(JNIEnv* env,
-                                                     jobject obj,
-                                                     jclass clazz,
-                                                     jmethodID methodID,
-                                                     ...) {
+jfloat CallNonvirtualFloatMethod(JNIEnv* env,
+    jobject obj, jclass clazz, jmethodID methodID, ...) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jfloat JniNativeInterface::CallNonvirtualFloatMethodV(JNIEnv* env,
-                                                      jobject obj,
-                                                      jclass clazz,
-                                                      jmethodID methodID,
-                                                      va_list args) {
+jfloat CallNonvirtualFloatMethodV(JNIEnv* env,
+    jobject obj, jclass clazz, jmethodID methodID, va_list args) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jfloat JniNativeInterface::CallNonvirtualFloatMethodA(JNIEnv* env,
-                                                      jobject obj,
-                                                      jclass clazz,
-                                                      jmethodID methodID,
-                                                      jvalue* args) {
+jfloat CallNonvirtualFloatMethodA(JNIEnv* env,
+    jobject obj, jclass clazz, jmethodID methodID, jvalue* args) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jdouble JniNativeInterface::CallNonvirtualDoubleMethod(JNIEnv* env,
-                                                       jobject obj,
-                                                       jclass clazz,
-                                                       jmethodID methodID,
-                                                       ...) {
+jdouble CallNonvirtualDoubleMethod(JNIEnv* env,
+    jobject obj, jclass clazz, jmethodID methodID, ...) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jdouble JniNativeInterface::CallNonvirtualDoubleMethodV(JNIEnv* env,
-                                                        jobject obj,
-                                                        jclass clazz,
-                                                        jmethodID methodID,
-                                                        va_list args) {
+jdouble CallNonvirtualDoubleMethodV(JNIEnv* env,
+    jobject obj, jclass clazz, jmethodID methodID, va_list args) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jdouble JniNativeInterface::CallNonvirtualDoubleMethodA(JNIEnv* env,
-                                                        jobject obj,
-                                                        jclass clazz,
-                                                        jmethodID methodID,
-                                                        jvalue* args) {
+jdouble CallNonvirtualDoubleMethodA(JNIEnv* env,
+    jobject obj, jclass clazz, jmethodID methodID, jvalue* args) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-void JniNativeInterface::CallNonvirtualVoidMethod(JNIEnv* env,
-                                                  jobject obj,
-                                                  jclass clazz,
-                                                  jmethodID methodID,
-                                                  ...) {
+void CallNonvirtualVoidMethod(JNIEnv* env,
+    jobject obj, jclass clazz, jmethodID methodID, ...) {
   LOG(FATAL) << "Unimplemented";
 }
 
-void JniNativeInterface::CallNonvirtualVoidMethodV(JNIEnv* env,
-                                                   jobject obj,
-                                                   jclass clazz,
-                                                   jmethodID methodID,
-                                                   va_list args) {
+void CallNonvirtualVoidMethodV(JNIEnv* env,
+    jobject obj, jclass clazz, jmethodID methodID, va_list args) {
   LOG(FATAL) << "Unimplemented";
 }
 
-void JniNativeInterface::CallNonvirtualVoidMethodA(JNIEnv* env,
-                                                   jobject obj,
-                                                   jclass clazz,
-                                                   jmethodID methodID,
-                                                   jvalue*  args) {
+void CallNonvirtualVoidMethodA(JNIEnv* env,
+    jobject obj, jclass clazz, jmethodID methodID, jvalue*  args) {
   LOG(FATAL) << "Unimplemented";
 }
 
-jfieldID JniNativeInterface::GetFieldID(JNIEnv* env,
-                                        jclass clazz,
-                                        const char* name,
-                                        const char* sig) {
+jfieldID GetFieldID(JNIEnv* env,
+    jclass clazz, const char* name, const char* sig) {
   LOG(FATAL) << "Unimplemented";
   return NULL;
 }
 
-jobject JniNativeInterface::GetObjectField(JNIEnv* env,
-                                           jobject obj,
-                                           jfieldID fieldID) {
+jobject GetObjectField(JNIEnv* env, jobject obj, jfieldID fieldID) {
   LOG(FATAL) << "Unimplemented";
   return NULL;
 }
 
-jboolean JniNativeInterface::GetBooleanField(JNIEnv* env,
-                                             jobject obj,
-                                             jfieldID fieldID) {
+jboolean GetBooleanField(JNIEnv* env, jobject obj, jfieldID fieldID) {
   LOG(FATAL) << "Unimplemented";
   return JNI_FALSE;
 }
 
-jbyte JniNativeInterface::GetByteField(JNIEnv* env,
-                                       jobject obj,
-                                       jfieldID fieldID) {
+jbyte GetByteField(JNIEnv* env, jobject obj, jfieldID fieldID) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jchar JniNativeInterface::GetCharField(JNIEnv* env,
-                                       jobject obj,
-                                       jfieldID fieldID) {
+jchar GetCharField(JNIEnv* env, jobject obj, jfieldID fieldID) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jshort JniNativeInterface::GetShortField(JNIEnv* env,
-                                         jobject obj,
-                                         jfieldID fieldID) {
+jshort GetShortField(JNIEnv* env, jobject obj, jfieldID fieldID) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jint JniNativeInterface::GetIntField(JNIEnv* env,
-                                     jobject obj,
-                                     jfieldID fieldID) {
+jint GetIntField(JNIEnv* env, jobject obj, jfieldID fieldID) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jlong JniNativeInterface::GetLongField(JNIEnv* env,
-                                       jobject obj,
-                                       jfieldID fieldID) {
+jlong GetLongField(JNIEnv* env, jobject obj, jfieldID fieldID) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jfloat JniNativeInterface::GetFloatField(JNIEnv* env,
-                                         jobject obj,
-                                         jfieldID fieldID) {
+jfloat GetFloatField(JNIEnv* env, jobject obj, jfieldID fieldID) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jdouble JniNativeInterface::GetDoubleField(JNIEnv* env,
-                                           jobject obj,
-                                           jfieldID fieldID) {
+jdouble GetDoubleField(JNIEnv* env, jobject obj, jfieldID fieldID) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-void JniNativeInterface::SetObjectField(JNIEnv* env,
-                                        jobject obj,
-                                        jfieldID fieldID,
-                                        jobject val) {
+void SetObjectField(JNIEnv* env, jobject obj, jfieldID fieldID, jobject val) {
   LOG(FATAL) << "Unimplemented";
 }
 
-void JniNativeInterface::SetBooleanField(JNIEnv* env,
-                                         jobject obj,
-                                         jfieldID fieldID,
-                                         jboolean val) {
+void SetBooleanField(JNIEnv* env, jobject obj, jfieldID fieldID, jboolean val) {
   LOG(FATAL) << "Unimplemented";
 }
 
-void JniNativeInterface::SetByteField(JNIEnv* env,
-                                      jobject obj,
-                                      jfieldID fieldID,
-                                      jbyte val) {
+void SetByteField(JNIEnv* env, jobject obj, jfieldID fieldID, jbyte val) {
   LOG(FATAL) << "Unimplemented";
 }
 
-void JniNativeInterface::SetCharField(JNIEnv* env,
-                                      jobject obj,
-                                      jfieldID fieldID,
-                                      jchar val) {
+void SetCharField(JNIEnv* env, jobject obj, jfieldID fieldID, jchar val) {
   LOG(FATAL) << "Unimplemented";
 }
 
-void JniNativeInterface::SetShortField(JNIEnv* env,
-                                       jobject obj,
-                                       jfieldID fieldID,
-                                       jshort val) {
+void SetShortField(JNIEnv* env, jobject obj, jfieldID fieldID, jshort val) {
   LOG(FATAL) << "Unimplemented";
 }
 
-void JniNativeInterface::SetIntField(JNIEnv* env,
-                                     jobject obj,
-                                     jfieldID fieldID,
-                                     jint val) {
+void SetIntField(JNIEnv* env, jobject obj, jfieldID fieldID, jint val) {
   LOG(FATAL) << "Unimplemented";
 }
 
-void JniNativeInterface::SetLongField(JNIEnv* env,
-                                      jobject obj,
-                                      jfieldID fieldID,
-                                      jlong val) {
+void SetLongField(JNIEnv* env, jobject obj, jfieldID fieldID, jlong val) {
   LOG(FATAL) << "Unimplemented";
 }
 
-void JniNativeInterface::SetFloatField(JNIEnv* env,
-                                       jobject obj,
-                                       jfieldID fieldID,
-                                       jfloat val) {
+void SetFloatField(JNIEnv* env, jobject obj, jfieldID fieldID, jfloat val) {
   LOG(FATAL) << "Unimplemented";
 }
 
-void JniNativeInterface::SetDoubleField(JNIEnv* env,
-                                        jobject obj,
-                                        jfieldID fieldID,
-                                        jdouble val) {
+void SetDoubleField(JNIEnv* env, jobject obj, jfieldID fieldID, jdouble val) {
   LOG(FATAL) << "Unimplemented";
 }
 
-jmethodID JniNativeInterface::GetStaticMethodID(JNIEnv* env,
-                                                jclass clazz,
-                                                const char* name,
-                                                const char* sig) {
+jmethodID GetStaticMethodID(JNIEnv* env,
+    jclass clazz, const char* name, const char* sig) {
   LOG(FATAL) << "Unimplemented";
   return NULL;
 }
 
-jobject JniNativeInterface::CallStaticObjectMethod(JNIEnv* env,
-                                                   jclass clazz,
-                                                   jmethodID methodID,
-                                                   ...) {
+jobject CallStaticObjectMethod(JNIEnv* env,
+    jclass clazz, jmethodID methodID, ...) {
   LOG(FATAL) << "Unimplemented";
   return NULL;
 }
 
-jobject JniNativeInterface::CallStaticObjectMethodV(JNIEnv* env,
-                                                    jclass clazz,
-                                                    jmethodID methodID,
-                                                    va_list args) {
+jobject CallStaticObjectMethodV(JNIEnv* env,
+    jclass clazz, jmethodID methodID, va_list args) {
   LOG(FATAL) << "Unimplemented";
   return NULL;
 }
 
-jobject JniNativeInterface::CallStaticObjectMethodA(JNIEnv* env,
-                                                    jclass clazz,
-                                                    jmethodID methodID,
-                                                    jvalue* args) {
+jobject CallStaticObjectMethodA(JNIEnv* env,
+    jclass clazz, jmethodID methodID, jvalue* args) {
   LOG(FATAL) << "Unimplemented";
   return NULL;
 }
 
-jboolean JniNativeInterface::CallStaticBooleanMethod(JNIEnv* env,
-                                                     jclass clazz,
-                                                     jmethodID methodID,
-                                                     ...) {
+jboolean CallStaticBooleanMethod(JNIEnv* env,
+    jclass clazz, jmethodID methodID, ...) {
   LOG(FATAL) << "Unimplemented";
   return JNI_FALSE;
 }
 
-jboolean JniNativeInterface::CallStaticBooleanMethodV(JNIEnv* env,
-                                                      jclass clazz,
-                                                      jmethodID methodID,
-                                                      va_list args) {
+jboolean CallStaticBooleanMethodV(JNIEnv* env,
+    jclass clazz, jmethodID methodID, va_list args) {
   LOG(FATAL) << "Unimplemented";
   return JNI_FALSE;
 }
 
-jboolean JniNativeInterface::CallStaticBooleanMethodA(JNIEnv* env,
-                                                      jclass clazz,
-                                                      jmethodID methodID,
-                                                      jvalue* args) {
+jboolean CallStaticBooleanMethodA(JNIEnv* env,
+    jclass clazz, jmethodID methodID, jvalue* args) {
   LOG(FATAL) << "Unimplemented";
   return JNI_FALSE;
 }
 
-jbyte JniNativeInterface::CallStaticByteMethod(JNIEnv* env,
-                                               jclass clazz,
-                                               jmethodID methodID,
-                                               ...) {
+jbyte CallStaticByteMethod(JNIEnv* env, jclass clazz, jmethodID methodID, ...) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jbyte JniNativeInterface::CallStaticByteMethodV(JNIEnv* env,
-                                                jclass clazz,
-                                                jmethodID methodID,
-                                                va_list args) {
+jbyte CallStaticByteMethodV(JNIEnv* env,
+    jclass clazz, jmethodID methodID, va_list args) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jbyte JniNativeInterface::CallStaticByteMethodA(JNIEnv* env,
-                                                jclass clazz,
-                                                jmethodID methodID,
-                                                jvalue* args) {
+jbyte CallStaticByteMethodA(JNIEnv* env,
+    jclass clazz, jmethodID methodID, jvalue* args) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jchar JniNativeInterface::CallStaticCharMethod(JNIEnv* env,
-                                               jclass clazz,
-                                               jmethodID methodID,
-                                               ...) {
+jchar CallStaticCharMethod(JNIEnv* env, jclass clazz, jmethodID methodID, ...) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jchar JniNativeInterface::CallStaticCharMethodV(JNIEnv* env,
-                                                jclass clazz,
-                                                jmethodID methodID,
-                                                va_list args) {
+jchar CallStaticCharMethodV(JNIEnv* env,
+    jclass clazz, jmethodID methodID, va_list args) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jchar JniNativeInterface::CallStaticCharMethodA(JNIEnv* env,
-                                                jclass clazz,
-                                                jmethodID methodID,
-                                                jvalue* args) {
+jchar CallStaticCharMethodA(JNIEnv* env,
+    jclass clazz, jmethodID methodID, jvalue* args) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jshort JniNativeInterface::CallStaticShortMethod(JNIEnv* env,
-                                                 jclass clazz,
-                                                 jmethodID methodID,
-                                                 ...) {
+jshort CallStaticShortMethod(JNIEnv* env,
+    jclass clazz, jmethodID methodID, ...) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jshort JniNativeInterface::CallStaticShortMethodV(JNIEnv* env,
-                                                  jclass clazz,
-                                                  jmethodID methodID,
-                                                  va_list args) {
+jshort CallStaticShortMethodV(JNIEnv* env,
+    jclass clazz, jmethodID methodID, va_list args) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jshort JniNativeInterface::CallStaticShortMethodA(JNIEnv* env,
-                                                  jclass clazz,
-                                                  jmethodID methodID,
-                                                  jvalue* args) {
+jshort CallStaticShortMethodA(JNIEnv* env,
+    jclass clazz, jmethodID methodID, jvalue* args) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jint JniNativeInterface::CallStaticIntMethod(JNIEnv* env,
-                                             jclass clazz,
-                                             jmethodID methodID,
-                                             ...) {
+jint CallStaticIntMethod(JNIEnv* env, jclass clazz, jmethodID methodID, ...) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jint JniNativeInterface::CallStaticIntMethodV(JNIEnv* env,
-                                              jclass clazz,
-                                              jmethodID methodID,
-                                              va_list args) {
+jint CallStaticIntMethodV(JNIEnv* env,
+    jclass clazz, jmethodID methodID, va_list args) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jint JniNativeInterface::CallStaticIntMethodA(JNIEnv* env,
-                                              jclass clazz,
-                                              jmethodID methodID,
-                                              jvalue* args) {
+jint CallStaticIntMethodA(JNIEnv* env,
+    jclass clazz, jmethodID methodID, jvalue* args) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jlong JniNativeInterface::CallStaticLongMethod(JNIEnv* env,
-                                               jclass clazz,
-                                               jmethodID methodID,
-                                               ...) {
+jlong CallStaticLongMethod(JNIEnv* env, jclass clazz, jmethodID methodID, ...) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jlong JniNativeInterface::CallStaticLongMethodV(JNIEnv* env,
-                                                jclass clazz,
-                                                jmethodID methodID,
-                                                va_list args) {
+jlong CallStaticLongMethodV(JNIEnv* env,
+    jclass clazz, jmethodID methodID, va_list args) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jlong JniNativeInterface::CallStaticLongMethodA(JNIEnv* env,
-                                                jclass clazz,
-                                                jmethodID methodID,
-                                                jvalue* args) {
+jlong CallStaticLongMethodA(JNIEnv* env,
+    jclass clazz, jmethodID methodID, jvalue* args) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jfloat JniNativeInterface::CallStaticFloatMethod(JNIEnv* env,
-                                                 jclass clazz,
-                                                 jmethodID methodID,
-                                                 ...) {
+jfloat CallStaticFloatMethod(JNIEnv* env,
+    jclass clazz, jmethodID methodID, ...) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jfloat JniNativeInterface::CallStaticFloatMethodV(JNIEnv* env,
-                                                  jclass clazz,
-                                                  jmethodID methodID,
-                                                  va_list args) {
+jfloat CallStaticFloatMethodV(JNIEnv* env,
+    jclass clazz, jmethodID methodID, va_list args) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jfloat JniNativeInterface::CallStaticFloatMethodA(JNIEnv* env,
-                                                  jclass clazz,
-                                                  jmethodID methodID,
-                                                  jvalue* args) {
+jfloat CallStaticFloatMethodA(JNIEnv* env,
+    jclass clazz, jmethodID methodID, jvalue* args) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jdouble JniNativeInterface::CallStaticDoubleMethod(JNIEnv* env,
-                                                   jclass clazz,
-                                                   jmethodID methodID,
-                                                   ...) {
+jdouble CallStaticDoubleMethod(JNIEnv* env,
+    jclass clazz, jmethodID methodID, ...) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jdouble JniNativeInterface::CallStaticDoubleMethodV(JNIEnv* env,
-                                                    jclass clazz,
-                                                    jmethodID methodID,
-                                                    va_list args) {
+jdouble CallStaticDoubleMethodV(JNIEnv* env,
+    jclass clazz, jmethodID methodID, va_list args) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jdouble JniNativeInterface::CallStaticDoubleMethodA(JNIEnv* env,
-                                                    jclass clazz,
-                                                    jmethodID methodID,
-                                                    jvalue* args) {
+jdouble CallStaticDoubleMethodA(JNIEnv* env,
+    jclass clazz, jmethodID methodID, jvalue* args) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-void JniNativeInterface::CallStaticVoidMethod(JNIEnv* env,
-                                              jclass cls,
-                                              jmethodID methodID,
-                                              ...) {
+void CallStaticVoidMethod(JNIEnv* env, jclass cls, jmethodID methodID, ...) {
   LOG(FATAL) << "Unimplemented";
 }
 
-void JniNativeInterface::CallStaticVoidMethodV(JNIEnv* env,
-                                               jclass cls,
-                                               jmethodID methodID,
-                                               va_list args) {
+void CallStaticVoidMethodV(JNIEnv* env,
+    jclass cls, jmethodID methodID, va_list args) {
   LOG(FATAL) << "Unimplemented";
 }
 
-void JniNativeInterface::CallStaticVoidMethodA(JNIEnv* env,
-                                               jclass cls,
-                                               jmethodID methodID,
-                                               jvalue*  args) {
+void CallStaticVoidMethodA(JNIEnv* env,
+    jclass cls, jmethodID methodID, jvalue*  args) {
   LOG(FATAL) << "Unimplemented";
 }
 
-jfieldID JniNativeInterface::GetStaticFieldID(JNIEnv* env,
-                                              jclass clazz,
-                                              const char* name,
-                                              const char* sig) {
+jfieldID GetStaticFieldID(JNIEnv* env,
+    jclass clazz, const char* name, const char* sig) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jobject JniNativeInterface::GetStaticObjectField(JNIEnv* env,
-                                                 jclass clazz,
-                                                 jfieldID fieldID) {
+jobject GetStaticObjectField(JNIEnv* env, jclass clazz, jfieldID fieldID) {
   LOG(FATAL) << "Unimplemented";
   return NULL;
 }
 
-jboolean JniNativeInterface::GetStaticBooleanField(JNIEnv* env,
-                                                   jclass clazz,
-                                                   jfieldID fieldID) {
+jboolean GetStaticBooleanField(JNIEnv* env, jclass clazz, jfieldID fieldID) {
   LOG(FATAL) << "Unimplemented";
   return JNI_FALSE;
 }
 
-jbyte JniNativeInterface::GetStaticByteField(JNIEnv* env,
-                                             jclass clazz,
-                                             jfieldID fieldID) {
+jbyte GetStaticByteField(JNIEnv* env, jclass clazz, jfieldID fieldID) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jchar JniNativeInterface::GetStaticCharField(JNIEnv* env,
-                                             jclass clazz,
-                                             jfieldID fieldID) {
+jchar GetStaticCharField(JNIEnv* env, jclass clazz, jfieldID fieldID) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jshort JniNativeInterface::GetStaticShortField(JNIEnv* env,
-                                               jclass clazz,
-                                               jfieldID fieldID) {
+jshort GetStaticShortField(JNIEnv* env, jclass clazz, jfieldID fieldID) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jint JniNativeInterface::GetStaticIntField(JNIEnv* env,
-                                           jclass clazz,
-                                           jfieldID fieldID) {
+jint GetStaticIntField(JNIEnv* env, jclass clazz, jfieldID fieldID) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jlong JniNativeInterface::GetStaticLongField(JNIEnv* env,
-                                             jclass clazz,
-                                             jfieldID fieldID) {
+jlong GetStaticLongField(JNIEnv* env, jclass clazz, jfieldID fieldID) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jfloat JniNativeInterface::GetStaticFloatField(JNIEnv* env,
-                                               jclass clazz,
-                                               jfieldID fieldID) {
+jfloat GetStaticFloatField(JNIEnv* env, jclass clazz, jfieldID fieldID) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jdouble JniNativeInterface::GetStaticDoubleField(JNIEnv* env,
-                                                 jclass clazz,
-                                                 jfieldID fieldID) {
+jdouble GetStaticDoubleField(JNIEnv* env, jclass clazz, jfieldID fieldID) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-void JniNativeInterface::SetStaticObjectField(JNIEnv* env,
-                                              jclass clazz,
-                                              jfieldID fieldID,
-                                              jobject value) {
+void SetStaticObjectField(JNIEnv* env,
+    jclass clazz, jfieldID fieldID, jobject value) {
   LOG(FATAL) << "Unimplemented";
 }
 
-void JniNativeInterface::SetStaticBooleanField(JNIEnv* env,
-                                               jclass clazz,
-                                               jfieldID fieldID,
-                                               jboolean value) {
+void SetStaticBooleanField(JNIEnv* env,
+    jclass clazz, jfieldID fieldID, jboolean value) {
   LOG(FATAL) << "Unimplemented";
 }
 
-void JniNativeInterface::SetStaticByteField(JNIEnv* env,
-                                            jclass clazz,
-                                            jfieldID fieldID,
-                                            jbyte value) {
+void SetStaticByteField(JNIEnv* env,
+    jclass clazz, jfieldID fieldID, jbyte value) {
   LOG(FATAL) << "Unimplemented";
 }
 
-void JniNativeInterface::SetStaticCharField(JNIEnv* env,
-                                            jclass clazz,
-                                            jfieldID fieldID,
-                                            jchar value) {
+void SetStaticCharField(JNIEnv* env,
+    jclass clazz, jfieldID fieldID, jchar value) {
   LOG(FATAL) << "Unimplemented";
 }
 
-void JniNativeInterface::SetStaticShortField(JNIEnv* env,
-                                             jclass clazz,
-                                             jfieldID fieldID,
-                                             jshort value) {
+void SetStaticShortField(JNIEnv* env,
+    jclass clazz, jfieldID fieldID, jshort value) {
   LOG(FATAL) << "Unimplemented";
 }
 
-void JniNativeInterface::SetStaticIntField(JNIEnv* env,
-                                           jclass clazz,
-                                           jfieldID fieldID,
-                                           jint value) {
+void SetStaticIntField(JNIEnv* env,
+    jclass clazz, jfieldID fieldID, jint value) {
   LOG(FATAL) << "Unimplemented";
 }
 
-void JniNativeInterface::SetStaticLongField(JNIEnv* env,
-                                            jclass clazz,
-                                            jfieldID fieldID,
-                                            jlong value) {
+void SetStaticLongField(JNIEnv* env,
+    jclass clazz, jfieldID fieldID, jlong value) {
   LOG(FATAL) << "Unimplemented";
 }
 
-void JniNativeInterface::SetStaticFloatField(JNIEnv* env,
-                                             jclass clazz,
-                                             jfieldID fieldID,
-                                             jfloat value) {
+void SetStaticFloatField(JNIEnv* env,
+    jclass clazz, jfieldID fieldID, jfloat value) {
   LOG(FATAL) << "Unimplemented";
 }
 
-void JniNativeInterface::SetStaticDoubleField(JNIEnv* env,
-                                              jclass clazz,
-                                              jfieldID fieldID,
-                                              jdouble value) {
+void SetStaticDoubleField(JNIEnv* env,
+    jclass clazz, jfieldID fieldID, jdouble value) {
   LOG(FATAL) << "Unimplemented";
 }
 
-jstring JniNativeInterface::NewString(JNIEnv* env,
-                                      const jchar* unicode,
-                                      jsize len) {
+jstring NewString(JNIEnv* env, const jchar* unicode, jsize len) {
   LOG(FATAL) << "Unimplemented";
   return NULL;
 }
 
-jsize JniNativeInterface::GetStringLength(JNIEnv* env, jstring str) {
+jsize GetStringLength(JNIEnv* env, jstring str) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-const jchar* JniNativeInterface::GetStringChars(JNIEnv* env,
-                                                jstring str,
-                                                jboolean* isCopy) {
+const jchar* GetStringChars(JNIEnv* env, jstring str, jboolean* isCopy) {
   LOG(FATAL) << "Unimplemented";
   return NULL;
 }
 
-void JniNativeInterface::ReleaseStringChars(JNIEnv* env,
-                                            jstring str,
-                                            const jchar* chars) {
+void ReleaseStringChars(JNIEnv* env, jstring str, const jchar* chars) {
   LOG(FATAL) << "Unimplemented";
 }
 
-jstring JniNativeInterface::NewStringUTF(JNIEnv* env, const char* utf) {
+jstring NewStringUTF(JNIEnv* env, const char* utf) {
   LOG(FATAL) << "Unimplemented";
   return NULL;
 }
 
-jsize JniNativeInterface::GetStringUTFLength(JNIEnv* env, jstring str) {
+jsize GetStringUTFLength(JNIEnv* env, jstring str) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-const char* JniNativeInterface::GetStringUTFChars(JNIEnv* env,
-                                                  jstring str,
-                                                  jboolean* isCopy) {
+const char* GetStringUTFChars(JNIEnv* env, jstring str, jboolean* isCopy) {
   LOG(FATAL) << "Unimplemented";
   return NULL;
 }
 
-void JniNativeInterface::ReleaseStringUTFChars(JNIEnv* env,
-                                               jstring str,
-                                               const char* chars) {
+void ReleaseStringUTFChars(JNIEnv* env, jstring str, const char* chars) {
   LOG(FATAL) << "Unimplemented";
 }
 
-jsize JniNativeInterface::GetArrayLength(JNIEnv* env, jarray array) {
+jsize GetArrayLength(JNIEnv* env, jarray array) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jobjectArray JniNativeInterface::NewObjectArray(JNIEnv* env,
-                                                jsize len,
-                                                jclass clazz,
-                                                jobject init) {
+jobjectArray NewObjectArray(JNIEnv* env,
+    jsize len, jclass clazz, jobject init) {
   LOG(FATAL) << "Unimplemented";
   return NULL;
 }
 
-jobject JniNativeInterface::GetObjectArrayElement(JNIEnv* env,
-                                                  jobjectArray array,
-                                                  jsize index) {
+jobject GetObjectArrayElement(JNIEnv* env, jobjectArray array, jsize index) {
   LOG(FATAL) << "Unimplemented";
   return NULL;
 }
 
-void JniNativeInterface::SetObjectArrayElement(JNIEnv* env,
-                                               jobjectArray array,
-                                               jsize index,
-                                               jobject val) {
+void SetObjectArrayElement(JNIEnv* env,
+    jobjectArray array, jsize index, jobject val) {
   LOG(FATAL) << "Unimplemented";
 }
 
-jbooleanArray JniNativeInterface::NewBooleanArray(JNIEnv* env, jsize len) {
+jbooleanArray NewBooleanArray(JNIEnv* env, jsize len) {
   LOG(FATAL) << "Unimplemented";
   return NULL;
 }
 
-jbyteArray JniNativeInterface::NewByteArray(JNIEnv* env, jsize len) {
+jbyteArray NewByteArray(JNIEnv* env, jsize len) {
   LOG(FATAL) << "Unimplemented";
   return NULL;
 }
 
-jcharArray JniNativeInterface::NewCharArray(JNIEnv* env, jsize len) {
+jcharArray NewCharArray(JNIEnv* env, jsize len) {
   LOG(FATAL) << "Unimplemented";
   return NULL;
 }
 
-jshortArray JniNativeInterface::NewShortArray(JNIEnv* env, jsize len) {
+jshortArray NewShortArray(JNIEnv* env, jsize len) {
   LOG(FATAL) << "Unimplemented";
   return NULL;
 }
 
-jintArray JniNativeInterface::NewIntArray(JNIEnv* env, jsize len) {
+jintArray NewIntArray(JNIEnv* env, jsize len) {
   LOG(FATAL) << "Unimplemented";
   return NULL;
 }
 
-jlongArray JniNativeInterface::NewLongArray(JNIEnv* env, jsize len) {
+jlongArray NewLongArray(JNIEnv* env, jsize len) {
   LOG(FATAL) << "Unimplemented";
   return NULL;
 }
 
-jfloatArray JniNativeInterface::NewFloatArray(JNIEnv* env, jsize len) {
+jfloatArray NewFloatArray(JNIEnv* env, jsize len) {
   LOG(FATAL) << "Unimplemented";
   return NULL;
 }
 
-jdoubleArray JniNativeInterface::NewDoubleArray(JNIEnv* env, jsize len) {
+jdoubleArray NewDoubleArray(JNIEnv* env, jsize len) {
   LOG(FATAL) << "Unimplemented";
   return NULL;
 }
 
-jboolean* JniNativeInterface::GetBooleanArrayElements(JNIEnv* env,
-                                                      jbooleanArray array,
-                                                      jboolean* isCopy) {
+jboolean* GetBooleanArrayElements(JNIEnv* env,
+    jbooleanArray array, jboolean* isCopy) {
   LOG(FATAL) << "Unimplemented";
   return NULL;
 }
 
-jbyte* JniNativeInterface::GetByteArrayElements(JNIEnv* env,
-                                                jbyteArray array,
-                                                jboolean* isCopy) {
+jbyte* GetByteArrayElements(JNIEnv* env, jbyteArray array, jboolean* isCopy) {
   LOG(FATAL) << "Unimplemented";
   return NULL;
 }
 
-jchar* JniNativeInterface::GetCharArrayElements(JNIEnv* env,
-                                               jcharArray array,
-                                               jboolean* isCopy) {
+jchar* GetCharArrayElements(JNIEnv* env, jcharArray array, jboolean* isCopy) {
   LOG(FATAL) << "Unimplemented";
   return NULL;
 }
 
-jshort* JniNativeInterface::GetShortArrayElements(JNIEnv* env,
-                                                  jshortArray array,
-                                                  jboolean* isCopy) {
+jshort* GetShortArrayElements(JNIEnv* env,
+    jshortArray array, jboolean* isCopy) {
   LOG(FATAL) << "Unimplemented";
   return NULL;
 }
 
-jint* JniNativeInterface::GetIntArrayElements(JNIEnv* env,
-                                              jintArray array,
-                                              jboolean* isCopy) {
+jint* GetIntArrayElements(JNIEnv* env, jintArray array, jboolean* isCopy) {
   LOG(FATAL) << "Unimplemented";
   return NULL;
 }
 
-jlong* JniNativeInterface::GetLongArrayElements(JNIEnv* env,
-                                                jlongArray array,
-                                                jboolean* isCopy) {
+jlong* GetLongArrayElements(JNIEnv* env, jlongArray array, jboolean* isCopy) {
   LOG(FATAL) << "Unimplemented";
   return NULL;
 }
 
-jfloat* JniNativeInterface::GetFloatArrayElements(JNIEnv* env,
-                                                  jfloatArray array,
-                                                  jboolean* isCopy) {
+jfloat* GetFloatArrayElements(JNIEnv* env,
+    jfloatArray array, jboolean* isCopy) {
   LOG(FATAL) << "Unimplemented";
   return NULL;
 }
 
-jdouble* JniNativeInterface::GetDoubleArrayElements(JNIEnv* env,
-                                                    jdoubleArray array,
-                                                    jboolean* isCopy) {
+jdouble* GetDoubleArrayElements(JNIEnv* env,
+    jdoubleArray array, jboolean* isCopy) {
   LOG(FATAL) << "Unimplemented";
   return NULL;
 }
 
-void JniNativeInterface::ReleaseBooleanArrayElements(JNIEnv* env,
-                                                     jbooleanArray array,
-                                                     jboolean* elems,
-                                                     jint mode) {
+void ReleaseBooleanArrayElements(JNIEnv* env,
+    jbooleanArray array, jboolean* elems, jint mode) {
   LOG(FATAL) << "Unimplemented";
 }
 
-void JniNativeInterface::ReleaseByteArrayElements(JNIEnv* env,
-                                                  jbyteArray array,
-                                                  jbyte* elems,
-                                                  jint mode) {
+void ReleaseByteArrayElements(JNIEnv* env,
+    jbyteArray array, jbyte* elems, jint mode) {
   LOG(FATAL) << "Unimplemented";
 }
 
-void JniNativeInterface::ReleaseCharArrayElements(JNIEnv* env,
-                                                  jcharArray array,
-                                                  jchar* elems,
-                                                  jint mode) {
+void ReleaseCharArrayElements(JNIEnv* env,
+    jcharArray array, jchar* elems, jint mode) {
   LOG(FATAL) << "Unimplemented";
 }
 
-void JniNativeInterface::ReleaseShortArrayElements(JNIEnv* env,
-                                                   jshortArray array,
-                                                   jshort* elems,
-                                                   jint mode) {
+void ReleaseShortArrayElements(JNIEnv* env,
+    jshortArray array, jshort* elems, jint mode) {
   LOG(FATAL) << "Unimplemented";
 }
 
-void JniNativeInterface::ReleaseIntArrayElements(JNIEnv* env,
-                                                 jintArray array,
-                                                 jint* elems,
-                                                 jint mode) {
+void ReleaseIntArrayElements(JNIEnv* env,
+    jintArray array, jint* elems, jint mode) {
   LOG(FATAL) << "Unimplemented";
 }
 
-void JniNativeInterface::ReleaseLongArrayElements(JNIEnv* env,
-                                                  jlongArray array,
-                                                  jlong* elems,
-                                                  jint mode) {
+void ReleaseLongArrayElements(JNIEnv* env,
+    jlongArray array, jlong* elems, jint mode) {
   LOG(FATAL) << "Unimplemented";
 }
 
-void JniNativeInterface::ReleaseFloatArrayElements(JNIEnv* env,
-                                                   jfloatArray array,
-                                                   jfloat* elems,
-                                                   jint mode) {
+void ReleaseFloatArrayElements(JNIEnv* env,
+    jfloatArray array, jfloat* elems, jint mode) {
   LOG(FATAL) << "Unimplemented";
 }
 
-void JniNativeInterface::ReleaseDoubleArrayElements(JNIEnv* env,
-                                                    jdoubleArray array,
-                                                    jdouble* elems,
-                                                    jint mode) {
+void ReleaseDoubleArrayElements(JNIEnv* env,
+    jdoubleArray array, jdouble* elems, jint mode) {
   LOG(FATAL) << "Unimplemented";
 }
 
-void JniNativeInterface::GetBooleanArrayRegion(JNIEnv* env,
-                                               jbooleanArray array,
-                                               jsize start,
-                                               jsize l,
-                                               jboolean* buf) {
+void GetBooleanArrayRegion(JNIEnv* env,
+    jbooleanArray array, jsize start, jsize l, jboolean* buf) {
   LOG(FATAL) << "Unimplemented";
 }
 
-void JniNativeInterface::GetByteArrayRegion(JNIEnv* env,
-                                            jbyteArray array,
-                                            jsize start,
-                                            jsize len,
-                                            jbyte* buf) {
+void GetByteArrayRegion(JNIEnv* env,
+    jbyteArray array, jsize start, jsize len, jbyte* buf) {
   LOG(FATAL) << "Unimplemented";
 }
 
-void JniNativeInterface::GetCharArrayRegion(JNIEnv* env,
-                                            jcharArray array,
-                                            jsize start,
-                                            jsize len,
-                                            jchar* buf) {
+void GetCharArrayRegion(JNIEnv* env,
+    jcharArray array, jsize start, jsize len, jchar* buf) {
   LOG(FATAL) << "Unimplemented";
 }
 
-void JniNativeInterface::GetShortArrayRegion(JNIEnv* env,
-                                             jshortArray array,
-                                             jsize start,
-                                             jsize len,
-                                             jshort* buf) {
+void GetShortArrayRegion(JNIEnv* env,
+    jshortArray array, jsize start, jsize len, jshort* buf) {
   LOG(FATAL) << "Unimplemented";
 }
 
-void JniNativeInterface::GetIntArrayRegion(JNIEnv* env,
-                                           jintArray array,
-                                           jsize start,
-                                           jsize len,
-                                           jint* buf) {
+void GetIntArrayRegion(JNIEnv* env,
+    jintArray array, jsize start, jsize len, jint* buf) {
   LOG(FATAL) << "Unimplemented";
 }
 
-void JniNativeInterface::GetLongArrayRegion(JNIEnv* env,
-                                            jlongArray array,
-                                            jsize start,
-                                            jsize len,
-                                            jlong* buf) {
+void GetLongArrayRegion(JNIEnv* env,
+    jlongArray array, jsize start, jsize len, jlong* buf) {
   LOG(FATAL) << "Unimplemented";
 }
 
-void JniNativeInterface::GetFloatArrayRegion(JNIEnv* env,
-                                             jfloatArray array,
-                                             jsize start,
-                                             jsize len,
-                                             jfloat* buf) {
+void GetFloatArrayRegion(JNIEnv* env,
+    jfloatArray array, jsize start, jsize len, jfloat* buf) {
   LOG(FATAL) << "Unimplemented";
 }
 
-void JniNativeInterface::GetDoubleArrayRegion(JNIEnv* env,
-                                              jdoubleArray array,
-                                              jsize start,
-                                              jsize len,
-                                              jdouble* buf) {
+void GetDoubleArrayRegion(JNIEnv* env,
+    jdoubleArray array, jsize start, jsize len, jdouble* buf) {
   LOG(FATAL) << "Unimplemented";
 }
 
-void JniNativeInterface::SetBooleanArrayRegion(JNIEnv* env,
-                                               jbooleanArray array,
-                                               jsize start,
-                                               jsize l,
-                                               const jboolean* buf) {
+void SetBooleanArrayRegion(JNIEnv* env,
+    jbooleanArray array, jsize start, jsize l, const jboolean* buf) {
   LOG(FATAL) << "Unimplemented";
 }
 
-void JniNativeInterface::SetByteArrayRegion(JNIEnv* env,
-                                            jbyteArray array,
-                                            jsize start,
-                                            jsize len,
-                                            const jbyte* buf) {
+void SetByteArrayRegion(JNIEnv* env,
+    jbyteArray array, jsize start, jsize len, const jbyte* buf) {
   LOG(FATAL) << "Unimplemented";
 }
 
-void JniNativeInterface::SetCharArrayRegion(JNIEnv* env,
-                                            jcharArray array,
-                                            jsize start,
-                                            jsize len,
-                                            const jchar* buf) {
+void SetCharArrayRegion(JNIEnv* env,
+    jcharArray array, jsize start, jsize len, const jchar* buf) {
   LOG(FATAL) << "Unimplemented";
 }
 
-void JniNativeInterface::SetShortArrayRegion(JNIEnv* env,
-                                             jshortArray array,
-                                             jsize start,
-                                             jsize len,
-                                             const jshort* buf) {
+void SetShortArrayRegion(JNIEnv* env,
+    jshortArray array, jsize start, jsize len, const jshort* buf) {
   LOG(FATAL) << "Unimplemented";
 }
 
-void JniNativeInterface::SetIntArrayRegion(JNIEnv* env,
-                                           jintArray array,
-                                           jsize start,
-                                           jsize len,
-                                           const jint* buf) {
+void SetIntArrayRegion(JNIEnv* env,
+    jintArray array, jsize start, jsize len, const jint* buf) {
   LOG(FATAL) << "Unimplemented";
 }
 
-void JniNativeInterface::SetLongArrayRegion(JNIEnv* env,
-                                            jlongArray array,
-                                            jsize start,
-                                            jsize len,
-                                            const jlong* buf) {
+void SetLongArrayRegion(JNIEnv* env,
+    jlongArray array, jsize start, jsize len, const jlong* buf) {
   LOG(FATAL) << "Unimplemented";
 }
 
-void JniNativeInterface::SetFloatArrayRegion(JNIEnv* env,
-                                             jfloatArray array,
-                                             jsize start,
-                                             jsize len,
-                                             const jfloat* buf) {
+void SetFloatArrayRegion(JNIEnv* env,
+    jfloatArray array, jsize start, jsize len, const jfloat* buf) {
   LOG(FATAL) << "Unimplemented";
 }
 
-void JniNativeInterface::SetDoubleArrayRegion(JNIEnv* env,
-                                              jdoubleArray array,
-                                              jsize start,
-                                              jsize len,
-                                              const jdouble* buf) {
+void SetDoubleArrayRegion(JNIEnv* env,
+    jdoubleArray array, jsize start, jsize len, const jdouble* buf) {
   LOG(FATAL) << "Unimplemented";
 }
 
-jint JniNativeInterface::RegisterNatives(JNIEnv* env,
-                                         jclass clazz,
-                                         const JNINativeMethod* methods,
-                                         jint nMethods) {
+jint RegisterNatives(JNIEnv* env,
+    jclass clazz, const JNINativeMethod* methods, jint nMethods) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jint JniNativeInterface::UnregisterNatives(JNIEnv* env, jclass clazz) {
+jint UnregisterNatives(JNIEnv* env, jclass clazz) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jint JniNativeInterface::MonitorEnter(JNIEnv* env, jobject obj) {
+jint MonitorEnter(JNIEnv* env, jobject obj) {
+  LOG(WARNING) << "MonitorEnter unimplemented";
+  return 0;
+}
+
+jint MonitorExit(JNIEnv* env, jobject obj) {
+  LOG(WARNING) << "MonitorExit unimplemented";
+  return 0;
+}
+
+jint GetJavaVM(JNIEnv* env, JavaVM* *vm) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jint JniNativeInterface::MonitorExit(JNIEnv* env, jobject obj) {
-  LOG(FATAL) << "Unimplemented";
-  return 0;
-}
-
-jint JniNativeInterface::GetJavaVM(JNIEnv* env, JavaVM* *vm) {
-  LOG(FATAL) << "Unimplemented";
-  return 0;
-}
-
-void JniNativeInterface::GetStringRegion(JNIEnv* env,
-                                         jstring str,
-                                         jsize start,
-                                         jsize len,
-                                         jchar* buf) {
+void GetStringRegion(JNIEnv* env,
+    jstring str, jsize start, jsize len, jchar* buf) {
   LOG(FATAL) << "Unimplemented";
 }
 
-void JniNativeInterface::GetStringUTFRegion(JNIEnv* env,
-                                            jstring str,
-                                            jsize start,
-                                            jsize len,
-                                            char* buf) {
+void GetStringUTFRegion(JNIEnv* env,
+    jstring str, jsize start, jsize len, char* buf) {
   LOG(FATAL) << "Unimplemented";
 }
 
-void* JniNativeInterface::GetPrimitiveArrayCritical(JNIEnv* env,
-                                                    jarray array,
-                                                    jboolean* isCopy) {
+void* GetPrimitiveArrayCritical(JNIEnv* env,
+    jarray array, jboolean* isCopy) {
   LOG(FATAL) << "Unimplemented";
   return NULL;
 }
 
-void JniNativeInterface::ReleasePrimitiveArrayCritical(JNIEnv* env,
-                                                       jarray array,
-                                                       void* carray,
-                                                       jint mode) {
+void ReleasePrimitiveArrayCritical(JNIEnv* env,
+    jarray array, void* carray, jint mode) {
   LOG(FATAL) << "Unimplemented";
 }
 
-const jchar* JniNativeInterface::GetStringCritical(JNIEnv* env,
-                                                   jstring s,
-                                                   jboolean* isCopy) {
+const jchar* GetStringCritical(JNIEnv* env, jstring s, jboolean* isCopy) {
   LOG(FATAL) << "Unimplemented";
   return NULL;
 }
 
-void JniNativeInterface::ReleaseStringCritical(JNIEnv* env,
-                                               jstring s,
-                                               const jchar* cstr) {
+void ReleaseStringCritical(JNIEnv* env, jstring s, const jchar* cstr) {
   LOG(FATAL) << "Unimplemented";
 }
 
-jweak JniNativeInterface::NewWeakGlobalRef(JNIEnv* env, jobject obj) {
+jweak NewWeakGlobalRef(JNIEnv* env, jobject obj) {
   LOG(FATAL) << "Unimplemented";
   return NULL;
 }
 
-void JniNativeInterface::DeleteWeakGlobalRef(JNIEnv* env, jweak obj) {
+void DeleteWeakGlobalRef(JNIEnv* env, jweak obj) {
   LOG(FATAL) << "Unimplemented";
 }
 
-jboolean JniNativeInterface::ExceptionCheck(JNIEnv* env) {
+jboolean ExceptionCheck(JNIEnv* env) {
   LOG(FATAL) << "Unimplemented";
   return JNI_FALSE;
 }
 
-jobject JniNativeInterface::NewDirectByteBuffer(JNIEnv* env,
-                                                void* address,
-                                                jlong capacity) {
+jobject NewDirectByteBuffer(JNIEnv* env, void* address, jlong capacity) {
   LOG(FATAL) << "Unimplemented";
   return NULL;
 }
 
 
-void* JniNativeInterface::GetDirectBufferAddress(JNIEnv* env, jobject buf) {
+void* GetDirectBufferAddress(JNIEnv* env, jobject buf) {
   LOG(FATAL) << "Unimplemented";
   return NULL;
 }
 
-jlong JniNativeInterface::GetDirectBufferCapacity(JNIEnv* env, jobject buf) {
+jlong GetDirectBufferCapacity(JNIEnv* env, jobject buf) {
   LOG(FATAL) << "Unimplemented";
   return 0;
 }
 
-jobjectRefType JniNativeInterface::GetObjectRefType(JNIEnv* env, jobject jobj) {
+jobjectRefType GetObjectRefType(JNIEnv* env, jobject jobj) {
   LOG(FATAL) << "Unimplemented";
   return JNIInvalidRefType;
 }
 
-struct JNINativeInterface JniNativeInterface::native_interface_ = {
+static const struct JNINativeInterface gNativeInterface = {
   NULL,  // reserved0.
   NULL,  // reserved1.
   NULL,  // reserved2.
@@ -1916,6 +1463,23 @@
   GetObjectRefType,
 };
 
+void MonitorEnterHelper(JNIEnv* env, jobject obj) {
+  MonitorEnter(env, obj);  // Ignore the result.
+}
+
+void MonitorExitHelper(JNIEnv* env, jobject obj) {
+  MonitorExit(env, obj);  // Ignore the result.
+}
+
+JNIEnv* CreateJNIEnv() {
+  JNIEnvExt* result = (JNIEnvExt*) calloc(1, sizeof(JNIEnvExt));
+  result->fns = &gNativeInterface;
+  result->self = Thread::Current();
+  result->MonitorEnterHelper = &MonitorEnterHelper;
+  result->MonitorExitHelper = &MonitorExitHelper;
+  return reinterpret_cast<JNIEnv*>(result);
+}
+
 // JNI Invocation interface.
 
 extern "C" jint JNI_CreateJavaVM(JavaVM** p_vm, void** p_env, void* vm_args) {
@@ -1974,14 +1538,13 @@
     return JNI_ERR;
   }
   Runtime* runtime = reinterpret_cast<Runtime*>(vm);
-  JniEnvironment** jni_env = reinterpret_cast<JniEnvironment**>(p_env);
   const char* name = NULL;
   if (thr_args != NULL) {
     // TODO: check version
     name = static_cast<JavaVMAttachArgs*>(thr_args)->name;
     // TODO: thread group
   }
-  bool success = runtime->AttachCurrentThread(name, jni_env);
+  bool success = runtime->AttachCurrentThread(name, p_env);
   if (!success) {
     return JNI_ERR;
   } else {
@@ -2022,14 +1585,13 @@
     return JNI_ERR;
   }
   Runtime* runtime = reinterpret_cast<Runtime*>(vm);
-  JniEnvironment** jni_env = reinterpret_cast<JniEnvironment**>(p_env);
   const char* name = NULL;
   if (thr_args != NULL) {
     // TODO: check version
     name = static_cast<JavaVMAttachArgs*>(thr_args)->name;
     // TODO: thread group
   }
-  bool success = runtime->AttachCurrentThreadAsDaemon(name, jni_env);
+  bool success = runtime->AttachCurrentThreadAsDaemon(name, p_env);
   if (!success) {
     return JNI_ERR;
   } else {
diff --git a/src/jni_internal.h b/src/jni_internal.h
index ceaeb96..39ce2cd 100644
--- a/src/jni_internal.h
+++ b/src/jni_internal.h
@@ -10,858 +10,22 @@
 
 namespace art {
 
-// TODO: This is a place holder for a true JNIEnv used to provide limited
-// functionality for the JNI compiler
-class JniEnvironment {
- public:
-  explicit JniEnvironment();
+class Thread;
 
-  static Offset MonitorEnterOffset() {
-    return Offset(OFFSETOF_MEMBER(JniEnvironment, monitor_enter_));
-  }
+JNIEnv* CreateJNIEnv();
 
-  static Offset MonitorExitOffset() {
-    return Offset(OFFSETOF_MEMBER(JniEnvironment, monitor_exit_));
-  }
+struct JNIEnvExt {
+  const struct JNINativeInterface* fns;  // Must be first.
 
- private:
-  struct JNINativeInterface_* functions_;
+  Thread* self;
 
-  void (*monitor_enter_)(JniEnvironment*, jobject);
-  void (*monitor_exit_)(JniEnvironment*, jobject);
+  // Are we in a "critical" JNI call?
+  bool critical;
 
-  DISALLOW_COPY_AND_ASSIGN(JniEnvironment);
-};
-
-class JniNativeInterface {
- public:
-  static struct JNINativeInterface* GetInterface() {
-    return &native_interface_;
-  }
- private:
-  static jint GetVersion(JNIEnv* env);
-
-  static jclass DefineClass(JNIEnv* env,
-                            const char* name,
-                            jobject loader,
-                            const jbyte* buf,
-                            jsize len);
-  static jclass FindClass(JNIEnv* env, const char* name);
-
-  static jmethodID FromReflectedMethod(JNIEnv* env, jobject method);
-  static jfieldID FromReflectedField(JNIEnv* env, jobject field);
-  static jobject ToReflectedMethod(JNIEnv* env,
-                                   jclass cls,
-                                   jmethodID methodID,
-                                   jboolean isStatic);
-
-  static jclass GetSuperclass(JNIEnv* env, jclass sub);
-  static jboolean IsAssignableFrom(JNIEnv* env, jclass sub, jclass sup);
-  static jobject ToReflectedField(JNIEnv* env,
-                                  jclass cls,
-                                  jfieldID fieldID,
-                                  jboolean isStatic);
-
-  static jint Throw(JNIEnv* env, jthrowable obj);
-  static jint ThrowNew(JNIEnv* env, jclass clazz, const char* msg);
-  static jthrowable ExceptionOccurred(JNIEnv* env);
-  static void ExceptionDescribe(JNIEnv* env);
-  static void ExceptionClear(JNIEnv* env);
-  static void FatalError(JNIEnv* env, const char* msg);
-
-  static jint PushLocalFrame(JNIEnv* env, jint cap);
-  static jobject PopLocalFrame(JNIEnv* env, jobject res);
-
-  static jobject NewGlobalRef(JNIEnv* env, jobject lobj);
-  static void DeleteGlobalRef(JNIEnv* env, jobject gref);
-  static void DeleteLocalRef(JNIEnv* env, jobject obj);
-  static jboolean IsSameObject(JNIEnv* env, jobject obj1, jobject obj2);
-
-  static jobject NewLocalRef(JNIEnv* env, jobject ref);
-  static jint EnsureLocalCapacity(JNIEnv* env, jint);
-
-  static jobject AllocObject(JNIEnv* env, jclass clazz);
-  static jobject NewObject(JNIEnv* env, jclass clazz, jmethodID methodID, ...);
-  static jobject NewObjectV(JNIEnv* env,
-                            jclass clazz,
-                            jmethodID methodID,
-                            va_list args);
-  static jobject NewObjectA(JNIEnv* env,
-                            jclass clazz,
-                            jmethodID methodID,
-                            jvalue* args);
-
-  static jclass GetObjectClass(JNIEnv* env, jobject obj);
-  static jboolean IsInstanceOf(JNIEnv* env, jobject obj, jclass clazz);
-
-  static jmethodID GetMethodID(JNIEnv* env,
-                               jclass clazz,
-                               const char* name,
-                               const char* sig);
-
-  static jobject CallObjectMethod(JNIEnv* env,
-                                  jobject obj,
-                                  jmethodID methodID,
-                                  ...);
-  static jobject CallObjectMethodV(JNIEnv* env,
-                                   jobject obj,
-                                   jmethodID methodID,
-                                   va_list args);
-  static jobject CallObjectMethodA(JNIEnv* env,
-                                   jobject obj,
-                                   jmethodID methodID,
-                                   jvalue*  args);
-
-  static jboolean CallBooleanMethod(JNIEnv* env,
-                                    jobject obj,
-                                    jmethodID methodID,
-                                    ...);
-  static jboolean CallBooleanMethodV(JNIEnv* env,
-                                     jobject obj,
-                                     jmethodID methodID,
-                                     va_list args);
-  static jboolean CallBooleanMethodA(JNIEnv* env,
-                                     jobject obj,
-                                     jmethodID methodID,
-                                     jvalue*  args);
-
-  static jbyte CallByteMethod(JNIEnv* env,
-                              jobject obj,
-                              jmethodID methodID,
-                              ...);
-  static jbyte CallByteMethodV(JNIEnv* env,
-                               jobject obj,
-                               jmethodID methodID,
-                               va_list args);
-  static jbyte CallByteMethodA(JNIEnv* env,
-                               jobject obj,
-                               jmethodID methodID,
-                               jvalue* args);
-
-  static jchar CallCharMethod(JNIEnv* env,
-                              jobject obj,
-                              jmethodID methodID,
-                              ...);
-  static jchar CallCharMethodV(JNIEnv* env,
-                               jobject obj,
-                               jmethodID methodID,
-                               va_list args);
-  static jchar CallCharMethodA(JNIEnv* env,
-                               jobject obj,
-                               jmethodID methodID,
-                               jvalue* args);
-
-  static jshort CallShortMethod(JNIEnv* env,
-                                jobject obj,
-                                jmethodID methodID,
-                                ...);
-  static jshort CallShortMethodV(JNIEnv* env,
-                                 jobject obj,
-                                 jmethodID methodID,
-                                 va_list args);
-  static jshort CallShortMethodA(JNIEnv* env,
-                                 jobject obj,
-                                 jmethodID methodID,
-                                 jvalue* args);
-
-  static jint CallIntMethod(JNIEnv* env,
-                            jobject obj,
-                            jmethodID methodID,
-                            ...);
-  static jint CallIntMethodV(JNIEnv* env,
-                             jobject obj,
-                             jmethodID methodID,
-                             va_list args);
-  static jint CallIntMethodA(JNIEnv* env,
-                             jobject obj,
-                             jmethodID methodID,
-                             jvalue* args);
-
-  static jlong CallLongMethod(JNIEnv* env,
-                              jobject obj,
-                              jmethodID methodID,
-                              ...);
-  static jlong CallLongMethodV(JNIEnv* env,
-                               jobject obj,
-                               jmethodID methodID,
-                               va_list args);
-  static jlong CallLongMethodA(JNIEnv* env,
-                               jobject obj,
-                               jmethodID methodID,
-                               jvalue* args);
-
-  static jfloat CallFloatMethod(JNIEnv* env,
-                                jobject obj,
-                                jmethodID methodID,
-                                ...);
-  static jfloat CallFloatMethodV(JNIEnv* env,
-                                 jobject obj,
-                                 jmethodID methodID,
-                                 va_list args);
-  static jfloat CallFloatMethodA(JNIEnv* env,
-                                 jobject obj,
-                                 jmethodID methodID,
-                                 jvalue* args);
-
-  static jdouble CallDoubleMethod(JNIEnv* env,
-                                  jobject obj,
-                                  jmethodID methodID,
-                                  ...);
-  static jdouble CallDoubleMethodV(JNIEnv* env,
-                                   jobject obj,
-                                   jmethodID methodID,
-                                   va_list args);
-  static jdouble CallDoubleMethodA(JNIEnv* env,
-                                   jobject obj,
-                                   jmethodID methodID,
-                                   jvalue* args);
-
-  static void CallVoidMethod(JNIEnv* env,
-                             jobject obj,
-                             jmethodID methodID,
-                             ...);
-  static void CallVoidMethodV(JNIEnv* env,
-                              jobject obj,
-                              jmethodID methodID,
-                              va_list args);
-  static void CallVoidMethodA(JNIEnv* env,
-                              jobject obj,
-                              jmethodID methodID,
-                              jvalue*  args);
-
-  static jobject CallNonvirtualObjectMethod(JNIEnv* env,
-                                            jobject obj,
-                                            jclass clazz,
-                                            jmethodID methodID,
-                                            ...);
-  static jobject CallNonvirtualObjectMethodV(JNIEnv* env,
-                                             jobject obj,
-                                             jclass clazz,
-                                             jmethodID methodID,
-                                             va_list args);
-  static jobject CallNonvirtualObjectMethodA(JNIEnv* env,
-                                             jobject obj,
-                                             jclass clazz,
-                                             jmethodID methodID,
-                                             jvalue*  args);
-
-  static jboolean CallNonvirtualBooleanMethod(JNIEnv* env,
-                                              jobject obj,
-                                              jclass clazz,
-                                              jmethodID methodID,
-                                              ...);
-  static jboolean CallNonvirtualBooleanMethodV(JNIEnv* env,
-                                               jobject obj,
-                                               jclass clazz,
-                                               jmethodID methodID,
-                                               va_list args);
-  static jboolean CallNonvirtualBooleanMethodA(JNIEnv* env,
-                                               jobject obj,
-                                               jclass clazz,
-                                               jmethodID methodID,
-                                               jvalue*  args);
-
-  static jbyte CallNonvirtualByteMethod(JNIEnv* env,
-                                        jobject obj,
-                                        jclass clazz,
-                                        jmethodID methodID,
-                                        ...);
-  static jbyte CallNonvirtualByteMethodV(JNIEnv* env,
-                                         jobject obj,
-                                         jclass clazz,
-                                         jmethodID methodID,
-                                         va_list args);
-  static jbyte CallNonvirtualByteMethodA(JNIEnv* env,
-                                         jobject obj,
-                                         jclass clazz,
-                                         jmethodID methodID,
-                                         jvalue* args);
-
-  static jchar CallNonvirtualCharMethod(JNIEnv* env,
-                                        jobject obj,
-                                        jclass clazz,
-                                        jmethodID methodID,
-                                        ...);
-  static jchar CallNonvirtualCharMethodV(JNIEnv* env,
-                                         jobject obj,
-                                         jclass clazz,
-                                         jmethodID methodID,
-                                         va_list args);
-  static jchar CallNonvirtualCharMethodA(JNIEnv* env,
-                                         jobject obj,
-                                         jclass clazz,
-                                         jmethodID methodID,
-                                         jvalue* args);
-
-  static jshort CallNonvirtualShortMethod(JNIEnv* env,
-                                          jobject obj,
-                                          jclass clazz,
-                                          jmethodID methodID,
-                                          ...);
-  static jshort CallNonvirtualShortMethodV(JNIEnv* env,
-                                           jobject obj,
-                                           jclass clazz,
-                                           jmethodID methodID,
-                                           va_list args);
-  static jshort CallNonvirtualShortMethodA(JNIEnv* env,
-                                           jobject obj,
-                                           jclass clazz,
-                                           jmethodID methodID,
-                                           jvalue* args);
-
-  static jint CallNonvirtualIntMethod(JNIEnv* env,
-                                      jobject obj,
-                                      jclass clazz,
-                                      jmethodID methodID,
-                                      ...);
-  static jint CallNonvirtualIntMethodV(JNIEnv* env,
-                                       jobject obj,
-                                       jclass clazz,
-                                       jmethodID methodID,
-                                       va_list args);
-  static jint CallNonvirtualIntMethodA(JNIEnv* env,
-                                       jobject obj,
-                                       jclass clazz,
-                                       jmethodID methodID,
-                                       jvalue* args);
-
-  static jlong CallNonvirtualLongMethod(JNIEnv* env,
-                                        jobject obj,
-                                        jclass clazz,
-                                        jmethodID methodID,
-                                        ...);
-  static jlong CallNonvirtualLongMethodV(JNIEnv* env,
-                                         jobject obj,
-                                         jclass clazz,
-                                         jmethodID methodID,
-                                         va_list args);
-  static jlong CallNonvirtualLongMethodA(JNIEnv* env,
-                                         jobject obj,
-                                         jclass clazz,
-                                         jmethodID methodID,
-                                         jvalue* args);
-
-  static jfloat CallNonvirtualFloatMethod(JNIEnv* env,
-                                          jobject obj,
-                                          jclass clazz,
-                                          jmethodID methodID,
-                                          ...);
-  static jfloat CallNonvirtualFloatMethodV(JNIEnv* env,
-                                           jobject obj,
-                                           jclass clazz,
-                                           jmethodID methodID,
-                                           va_list args);
-  static jfloat CallNonvirtualFloatMethodA(JNIEnv* env,
-                                           jobject obj,
-                                           jclass clazz,
-                                           jmethodID methodID,
-                                           jvalue* args);
-
-  static jdouble CallNonvirtualDoubleMethod(JNIEnv* env,
-                                            jobject obj,
-                                            jclass clazz,
-                                            jmethodID methodID,
-                                            ...);
-  static jdouble CallNonvirtualDoubleMethodV(JNIEnv* env,
-                                             jobject obj,
-                                             jclass clazz,
-                                             jmethodID methodID,
-                                             va_list args);
-  static jdouble CallNonvirtualDoubleMethodA(JNIEnv* env,
-                                             jobject obj,
-                                             jclass clazz,
-                                             jmethodID methodID,
-                                             jvalue* args);
-
-  static void CallNonvirtualVoidMethod(JNIEnv* env,
-                                       jobject obj,
-                                       jclass clazz,
-                                       jmethodID methodID,
-                                       ...);
-  static void CallNonvirtualVoidMethodV(JNIEnv* env,
-                                        jobject obj,
-                                        jclass clazz,
-                                        jmethodID methodID,
-                                        va_list args);
-  static void CallNonvirtualVoidMethodA(JNIEnv* env,
-                                        jobject obj,
-                                        jclass clazz,
-                                        jmethodID methodID,
-                                        jvalue*  args);
-
-  static jfieldID GetFieldID(JNIEnv* env,
-                             jclass clazz,
-                             const char* name,
-                             const char* sig);
-
-  static jobject GetObjectField(JNIEnv* env, jobject obj, jfieldID fieldID);
-  static jboolean GetBooleanField(JNIEnv* env, jobject obj, jfieldID fieldID);
-  static jbyte GetByteField(JNIEnv* env, jobject obj, jfieldID fieldID);
-  static jchar GetCharField(JNIEnv* env, jobject obj, jfieldID fieldID);
-  static jshort GetShortField(JNIEnv* env, jobject obj, jfieldID fieldID);
-  static jint GetIntField(JNIEnv* env, jobject obj, jfieldID fieldID);
-  static jlong GetLongField(JNIEnv* env, jobject obj, jfieldID fieldID);
-  static jfloat GetFloatField(JNIEnv* env, jobject obj, jfieldID fieldID);
-  static jdouble GetDoubleField(JNIEnv* env, jobject obj, jfieldID fieldID);
-
-  static void SetObjectField(JNIEnv* env,
-                             jobject obj,
-                             jfieldID fieldID,
-                             jobject val);
-  static void SetBooleanField(JNIEnv* env,
-                              jobject obj,
-                              jfieldID fieldID,
-                              jboolean val);
-  static void SetByteField(JNIEnv* env,
-                           jobject obj,
-                           jfieldID fieldID,
-                           jbyte val);
-  static void SetCharField(JNIEnv* env,
-                           jobject obj,
-                           jfieldID fieldID,
-                           jchar val);
-  static void SetShortField(JNIEnv* env,
-                            jobject obj,
-                            jfieldID fieldID,
-                            jshort val);
-  static void SetIntField(JNIEnv* env, jobject obj, jfieldID fieldID, jint val);
-  static void SetLongField(JNIEnv* env,
-                           jobject obj,
-                           jfieldID fieldID,
-                           jlong val);
-  static void SetFloatField(JNIEnv* env,
-                            jobject obj,
-                            jfieldID fieldID,
-                            jfloat val);
-  static void SetDoubleField(JNIEnv* env,
-                             jobject obj,
-                             jfieldID fieldID,
-                             jdouble val);
-
-  static jmethodID GetStaticMethodID(JNIEnv* env,
-                                     jclass clazz,
-                                     const char* name,
-                                     const char* sig);
-
-  static jobject CallStaticObjectMethod(JNIEnv* env,
-                                        jclass clazz,
-                                        jmethodID methodID,
-                                        ...);
-  static jobject CallStaticObjectMethodV(JNIEnv* env,
-                                         jclass clazz,
-                                         jmethodID methodID,
-                                         va_list args);
-  static jobject CallStaticObjectMethodA(JNIEnv* env,
-                                         jclass clazz,
-                                         jmethodID methodID,
-                                         jvalue* args);
-
-  static jboolean CallStaticBooleanMethod(JNIEnv* env,
-                                          jclass clazz,
-                                          jmethodID methodID,
-                                          ...);
-  static jboolean CallStaticBooleanMethodV(JNIEnv* env,
-                                           jclass clazz,
-                                           jmethodID methodID,
-                                           va_list args);
-  static jboolean CallStaticBooleanMethodA(JNIEnv* env,
-                                           jclass clazz,
-                                           jmethodID methodID,
-                                           jvalue* args);
-
-  static jbyte CallStaticByteMethod(JNIEnv* env,
-                                    jclass clazz,
-                                    jmethodID methodID,
-                                    ...);
-  static jbyte CallStaticByteMethodV(JNIEnv* env,
-                                     jclass clazz,
-                                     jmethodID methodID,
-                                     va_list args);
-  static jbyte CallStaticByteMethodA(JNIEnv* env,
-                                     jclass clazz,
-                                     jmethodID methodID,
-                                     jvalue* args);
-
-  static jchar CallStaticCharMethod(JNIEnv* env,
-                                    jclass clazz,
-                                    jmethodID methodID,
-                                    ...);
-  static jchar CallStaticCharMethodV(JNIEnv* env,
-                                     jclass clazz,
-                                     jmethodID methodID,
-                                     va_list args);
-  static jchar CallStaticCharMethodA(JNIEnv* env,
-                                     jclass clazz,
-                                     jmethodID methodID,
-                                     jvalue* args);
-
-  static jshort CallStaticShortMethod(JNIEnv* env,
-                                      jclass clazz,
-                                      jmethodID methodID,
-                                      ...);
-  static jshort CallStaticShortMethodV(JNIEnv* env,
-                                       jclass clazz,
-                                       jmethodID methodID,
-                                       va_list args);
-  static jshort CallStaticShortMethodA(JNIEnv* env,
-                                       jclass clazz,
-                                       jmethodID methodID,
-                                       jvalue* args);
-
-  static jint CallStaticIntMethod(JNIEnv* env,
-                                  jclass clazz,
-                                  jmethodID methodID,
-                                  ...);
-  static jint CallStaticIntMethodV(JNIEnv* env,
-                                   jclass clazz,
-                                   jmethodID methodID,
-                                   va_list args);
-  static jint CallStaticIntMethodA(JNIEnv* env,
-                                   jclass clazz,
-                                   jmethodID methodID,
-                                   jvalue* args);
-
-  static jlong CallStaticLongMethod(JNIEnv* env,
-                                    jclass clazz,
-                                    jmethodID methodID,
-                                    ...);
-  static jlong CallStaticLongMethodV(JNIEnv* env,
-                                     jclass clazz,
-                                     jmethodID methodID,
-                                     va_list args);
-  static jlong CallStaticLongMethodA(JNIEnv* env,
-                                     jclass clazz,
-                                     jmethodID methodID,
-                                     jvalue* args);
-
-  static jfloat CallStaticFloatMethod(JNIEnv* env,
-                                      jclass clazz,
-                                      jmethodID methodID,
-                                      ...);
-  static jfloat CallStaticFloatMethodV(JNIEnv* env,
-                                       jclass clazz,
-                                       jmethodID methodID,
-                                       va_list args);
-  static jfloat CallStaticFloatMethodA(JNIEnv* env,
-                                       jclass clazz,
-                                       jmethodID methodID,
-                                       jvalue* args);
-
-  static jdouble CallStaticDoubleMethod(JNIEnv* env,
-                                        jclass clazz,
-                                        jmethodID methodID,
-                                        ...);
-  static jdouble CallStaticDoubleMethodV(JNIEnv* env,
-                                         jclass clazz,
-                                         jmethodID methodID,
-                                         va_list args);
-  static jdouble CallStaticDoubleMethodA(JNIEnv* env,
-                                         jclass clazz,
-                                         jmethodID methodID,
-                                         jvalue* args);
-
-  static void CallStaticVoidMethod(JNIEnv* env,
-                                   jclass cls,
-                                   jmethodID methodID,
-                                   ...);
-  static void CallStaticVoidMethodV(JNIEnv* env,
-                                    jclass cls,
-                                    jmethodID methodID,
-                                    va_list args);
-  static void CallStaticVoidMethodA(JNIEnv* env,
-                                    jclass cls,
-                                    jmethodID methodID,
-                                    jvalue*  args);
-
-  static jfieldID GetStaticFieldID(JNIEnv* env,
-                                   jclass clazz,
-                                   const char* name,
-                                   const char* sig);
-  static jobject GetStaticObjectField(JNIEnv* env,
-                                      jclass clazz,
-                                      jfieldID fieldID);
-  static jboolean GetStaticBooleanField(JNIEnv* env,
-                                        jclass clazz,
-                                        jfieldID fieldID);
-  static jbyte GetStaticByteField(JNIEnv* env, jclass clazz, jfieldID fieldID);
-  static jchar GetStaticCharField(JNIEnv* env, jclass clazz, jfieldID fieldID);
-  static jshort GetStaticShortField(JNIEnv* env,
-                                    jclass clazz,
-                                    jfieldID fieldID);
-  static jint GetStaticIntField(JNIEnv* env, jclass clazz, jfieldID fieldID);
-  static jlong GetStaticLongField(JNIEnv* env, jclass clazz, jfieldID fieldID);
-  static jfloat GetStaticFloatField(JNIEnv* env,
-                                    jclass clazz,
-                                    jfieldID fieldID);
-  static jdouble GetStaticDoubleField(JNIEnv* env,
-                                      jclass clazz,
-                                      jfieldID fieldID);
-
-  static void SetStaticObjectField(JNIEnv* env,
-                                   jclass clazz,
-                                   jfieldID fieldID,
-                                   jobject value);
-  static void SetStaticBooleanField(JNIEnv* env,
-                                    jclass clazz,
-                                    jfieldID fieldID,
-                                    jboolean value);
-  static void SetStaticByteField(JNIEnv* env,
-                                 jclass clazz,
-                                 jfieldID fieldID,
-                                 jbyte value);
-  static void SetStaticCharField(JNIEnv* env,
-                                 jclass clazz,
-                                 jfieldID fieldID,
-                                 jchar value);
-  static void SetStaticShortField(JNIEnv* env,
-                                  jclass clazz,
-                                  jfieldID fieldID,
-                                  jshort value);
-  static void SetStaticIntField(JNIEnv* env,
-                                jclass clazz,
-                                jfieldID fieldID,
-                                jint value);
-  static void SetStaticLongField(JNIEnv* env,
-                                 jclass clazz,
-                                 jfieldID fieldID,
-                                 jlong value);
-  static void SetStaticFloatField(JNIEnv* env,
-                                  jclass clazz,
-                                  jfieldID fieldID,
-                                  jfloat value);
-  static void SetStaticDoubleField(JNIEnv* env,
-                                   jclass clazz,
-                                   jfieldID fieldID,
-                                   jdouble value);
-
-  static jstring NewString(JNIEnv* env, const jchar* unicode, jsize len);
-  static jsize GetStringLength(JNIEnv* env, jstring str);
-  static const jchar* GetStringChars(JNIEnv* env,
-                                     jstring str,
-                                     jboolean* isCopy);
-  static void ReleaseStringChars(JNIEnv* env, jstring str, const jchar* chars);
-  static jstring NewStringUTF(JNIEnv* env, const char* utf);
-  static jsize GetStringUTFLength(JNIEnv* env, jstring str);
-  static const char* GetStringUTFChars(JNIEnv* env,
-                                       jstring str,
-                                       jboolean* isCopy);
-  static void ReleaseStringUTFChars(JNIEnv* env,
-                                    jstring str,
-                                    const char* chars);
-
-  static jsize GetArrayLength(JNIEnv* env, jarray array);
-
-  static jobjectArray NewObjectArray(JNIEnv* env,
-                                     jsize len,
-                                     jclass clazz,
-                                     jobject init);
-  static jobject GetObjectArrayElement(JNIEnv* env,
-                                       jobjectArray array,
-                                       jsize index);
-  static void SetObjectArrayElement(JNIEnv* env,
-                                    jobjectArray array,
-                                    jsize index,
-                                    jobject val);
-
-  static jbooleanArray NewBooleanArray(JNIEnv* env, jsize len);
-  static jbyteArray NewByteArray(JNIEnv* env, jsize len);
-  static jcharArray NewCharArray(JNIEnv* env, jsize len);
-  static jshortArray NewShortArray(JNIEnv* env, jsize len);
-  static jintArray NewIntArray(JNIEnv* env, jsize len);
-  static jlongArray NewLongArray(JNIEnv* env, jsize len);
-  static jfloatArray NewFloatArray(JNIEnv* env, jsize len);
-  static jdoubleArray NewDoubleArray(JNIEnv* env, jsize len);
-
-  static jboolean*  GetBooleanArrayElements(JNIEnv* env,
-                                            jbooleanArray array,
-                                            jboolean* isCopy);
-  static jbyte*  GetByteArrayElements(JNIEnv* env,
-                                      jbyteArray array,
-                                      jboolean* isCopy);
-  static jchar*  GetCharArrayElements(JNIEnv* env,
-                                      jcharArray array,
-                                      jboolean* isCopy);
-  static jshort*  GetShortArrayElements(JNIEnv* env,
-                                        jshortArray array,
-                                        jboolean* isCopy);
-  static jint*  GetIntArrayElements(JNIEnv* env,
-                                    jintArray array,
-                                    jboolean* isCopy);
-  static jlong*  GetLongArrayElements(JNIEnv* env,
-                                      jlongArray array,
-                                      jboolean* isCopy);
-  static jfloat*  GetFloatArrayElements(JNIEnv* env,
-                                        jfloatArray array,
-                                        jboolean* isCopy);
-  static jdouble*  GetDoubleArrayElements(JNIEnv* env,
-                                          jdoubleArray array,
-                                          jboolean* isCopy);
-
-  static void ReleaseBooleanArrayElements(JNIEnv* env,
-                                          jbooleanArray array,
-                                          jboolean* elems,
-                                          jint mode);
-  static void ReleaseByteArrayElements(JNIEnv* env,
-                                       jbyteArray array,
-                                       jbyte* elems,
-                                       jint mode);
-  static void ReleaseCharArrayElements(JNIEnv* env,
-                                       jcharArray array,
-                                       jchar* elems,
-                                       jint mode);
-  static void ReleaseShortArrayElements(JNIEnv* env,
-                                        jshortArray array,
-                                        jshort* elems,
-                                        jint mode);
-  static void ReleaseIntArrayElements(JNIEnv* env,
-                                      jintArray array,
-                                      jint* elems,
-                                      jint mode);
-  static void ReleaseLongArrayElements(JNIEnv* env,
-                                       jlongArray array,
-                                       jlong* elems,
-                                       jint mode);
-  static void ReleaseFloatArrayElements(JNIEnv* env,
-                                        jfloatArray array,
-                                        jfloat* elems,
-                                        jint mode);
-  static void ReleaseDoubleArrayElements(JNIEnv* env,
-                                         jdoubleArray array,
-                                         jdouble* elems,
-                                         jint mode);
-
-  static void GetBooleanArrayRegion(JNIEnv* env,
-                                    jbooleanArray array,
-                                    jsize start,
-                                    jsize l,
-                                    jboolean* buf);
-  static void GetByteArrayRegion(JNIEnv* env,
-                                 jbyteArray array,
-                                 jsize start,
-                                 jsize len,
-                                 jbyte* buf);
-  static void GetCharArrayRegion(JNIEnv* env,
-                                 jcharArray array,
-                                 jsize start,
-                                 jsize len,
-                                 jchar* buf);
-  static void GetShortArrayRegion(JNIEnv* env,
-                                  jshortArray array,
-                                  jsize start,
-                                  jsize len,
-                                  jshort* buf);
-  static void GetIntArrayRegion(JNIEnv* env,
-                                jintArray array,
-                                jsize start,
-                                jsize len,
-                                jint* buf);
-  static void GetLongArrayRegion(JNIEnv* env,
-                                 jlongArray array,
-                                 jsize start,
-                                 jsize len,
-                                 jlong* buf);
-  static void GetFloatArrayRegion(JNIEnv* env,
-                                  jfloatArray array,
-                                  jsize start,
-                                  jsize len,
-                                  jfloat* buf);
-  static void GetDoubleArrayRegion(JNIEnv* env,
-                                   jdoubleArray array,
-                                   jsize start,
-                                   jsize len,
-                                   jdouble* buf);
-
-  static void SetBooleanArrayRegion(JNIEnv* env,
-                                    jbooleanArray array,
-                                    jsize start,
-                                    jsize l,
-                                    const jboolean* buf);
-  static void SetByteArrayRegion(JNIEnv* env,
-                                 jbyteArray array,
-                                 jsize start,
-                                 jsize len,
-                                 const jbyte* buf);
-  static void SetCharArrayRegion(JNIEnv* env,
-                                 jcharArray array,
-                                 jsize start,
-                                 jsize len,
-                                 const jchar* buf);
-  static void SetShortArrayRegion(JNIEnv* env,
-                                  jshortArray array,
-                                  jsize start,
-                                  jsize len,
-                                  const jshort* buf);
-  static void SetIntArrayRegion(JNIEnv* env,
-                                jintArray array,
-                                jsize start,
-                                jsize len,
-                                const jint* buf);
-  static void SetLongArrayRegion(JNIEnv* env,
-                                 jlongArray array,
-                                 jsize start,
-                                 jsize len,
-                                 const jlong* buf);
-  static void SetFloatArrayRegion(JNIEnv* env,
-                                  jfloatArray array,
-                                  jsize start,
-                                  jsize len,
-                                  const jfloat* buf);
-  static void SetDoubleArrayRegion(JNIEnv* env,
-                                   jdoubleArray array,
-                                   jsize start,
-                                   jsize len,
-                                   const jdouble* buf);
-
-  static jint RegisterNatives(JNIEnv* env,
-                              jclass clazz,
-                              const JNINativeMethod* methods,
-                              jint nMethods);
-  static jint UnregisterNatives(JNIEnv* env, jclass clazz);
-
-  static jint MonitorEnter(JNIEnv* env, jobject obj);
-  static jint MonitorExit(JNIEnv* env, jobject obj);
-
-  static jint GetJavaVM(JNIEnv* env, JavaVM* *vm);
-
-  static void GetStringRegion(JNIEnv* env,
-                              jstring str,
-                              jsize start,
-                              jsize len,
-                              jchar* buf);
-  static void GetStringUTFRegion(JNIEnv* env,
-                                 jstring str,
-                                 jsize start,
-                                 jsize len,
-                                 char* buf);
-
-  static void* GetPrimitiveArrayCritical(JNIEnv* env,
-                                         jarray array,
-                                         jboolean* isCopy);
-  static void ReleasePrimitiveArrayCritical(JNIEnv* env,
-                                            jarray array,
-                                            void* carray,
-                                            jint mode);
-
-  static const jchar* GetStringCritical(JNIEnv* env,
-                                        jstring s,
-                                        jboolean* isCopy);
-  static void ReleaseStringCritical(JNIEnv* env, jstring s, const jchar* cstr);
-
-  static jweak NewWeakGlobalRef(JNIEnv* env, jobject obj);
-  static void DeleteWeakGlobalRef(JNIEnv* env, jweak obj);
-
-  static jboolean ExceptionCheck(JNIEnv* env);
-
-  static jobject NewDirectByteBuffer(JNIEnv* env,
-                                     void* address,
-                                     jlong capacity);
-  static void* GetDirectBufferAddress(JNIEnv* env, jobject buf);
-  static jlong GetDirectBufferCapacity(JNIEnv* env, jobject buf);
-
-  static jobjectRefType GetObjectRefType(JNIEnv* env, jobject obj);
-
-  static struct JNINativeInterface native_interface_;
-  DISALLOW_IMPLICIT_CONSTRUCTORS(JniNativeInterface);
+  // Used to help call synchronized native methods.
+  // TODO: make jni_compiler.cc do the indirection itself.
+  void (*MonitorEnterHelper)(JNIEnv*, jobject);
+  void (*MonitorExitHelper)(JNIEnv*, jobject);
 };
 
 class JniInvokeInterface {
diff --git a/src/runtime.cc b/src/runtime.cc
index 6d0dfd2..a02b09c 100644
--- a/src/runtime.cc
+++ b/src/runtime.cc
@@ -89,6 +89,19 @@
   }
 }
 
+DexFile* Open(const std::string& filename) {
+  if (filename.size() < 4) {
+    LOG(WARNING) << "Ignoring short classpath entry '" << filename << "'";
+    return NULL;
+  }
+  std::string suffix(filename.substr(filename.size() - 4));
+  if (suffix == ".zip" || suffix == ".jar" || suffix == ".apk") {
+    return DexFile::OpenZip(filename);
+  } else {
+    return DexFile::OpenFile(filename);
+  }
+}
+
 void CreateBootClassPath(const Runtime::Options& options,
                          std::vector<DexFile*>* boot_class_path) {
   CHECK(boot_class_path != NULL);
@@ -96,7 +109,7 @@
   std::vector<std::string> parsed;
   ParseClassPath(str, &parsed);
   for (size_t i = 0; i < parsed.size(); ++i) {
-    DexFile* dex_file = DexFile::OpenFile(parsed[i].c_str());
+    DexFile* dex_file = Open(parsed[i]);
     if (dex_file != NULL) {
       boot_class_path->push_back(dex_file);
     }
@@ -136,12 +149,11 @@
   return true;
 }
 
-bool Runtime::AttachCurrentThread(const char* name, JniEnvironment** penv) {
+bool Runtime::AttachCurrentThread(const char* name, JNIEnv** penv) {
   return Thread::Attach() != NULL;
 }
 
-bool Runtime::AttachCurrentThreadAsDaemon(const char* name,
-                                          JniEnvironment** penv) {
+bool Runtime::AttachCurrentThreadAsDaemon(const char* name, JNIEnv** penv) {
   // TODO: do something different for daemon threads.
   return Thread::Attach() != NULL;
 }
diff --git a/src/runtime.h b/src/runtime.h
index 1a9661f..f04aefe 100644
--- a/src/runtime.h
+++ b/src/runtime.h
@@ -6,6 +6,7 @@
 #include <vector>
 #include <utility>
 
+#include "jni.h"
 #include "globals.h"
 #include "macros.h"
 #include "stringpiece.h"
@@ -15,7 +16,6 @@
 class ClassLinker;
 class DexFile;
 class Heap;
-class JniEnvironment;
 class ThreadList;
 
 class Runtime {
@@ -41,8 +41,8 @@
   static void Abort(const char* file, int line);
 
   // Attaches the current native thread to the runtime.
-  bool AttachCurrentThread(const char* name, JniEnvironment** jni_env);
-  bool AttachCurrentThreadAsDaemon(const char* name, JniEnvironment** jni_env);
+  bool AttachCurrentThread(const char* name, JNIEnv** jni_env);
+  bool AttachCurrentThreadAsDaemon(const char* name, JNIEnv** jni_env);
 
   // Detaches the current native thread from the runtime.
   bool DetachCurrentThread();
diff --git a/src/thread.h b/src/thread.h
index d0f6623..02b2f65 100644
--- a/src/thread.h
+++ b/src/thread.h
@@ -189,7 +189,7 @@
   }
 
   // JNI methods
-  JniEnvironment* GetJniEnv() const {
+  JNIEnv* GetJniEnv() const {
     return jni_env_;
   }
 
@@ -240,9 +240,9 @@
   void DecrementSuspendCount() { suspend_count_--; }
 
  private:
-  Thread() :
-    id_(1234), top_shb_(NULL), exception_(NULL), suspend_count_(0) {
-    jni_env_ = new JniEnvironment();
+  Thread()
+      : id_(1234), top_shb_(NULL), exception_(NULL), suspend_count_(0) {
+    jni_env_ = CreateJNIEnv();
   }
 
   ~Thread() {
@@ -263,7 +263,7 @@
   StackHandleBlock* top_shb_;
 
   // Every thread may have an associated JNI environment
-  JniEnvironment* jni_env_;
+  JNIEnv* jni_env_;
 
   State state_;
 
diff --git a/src/zip_archive.cc b/src/zip_archive.cc
index 0303e6f..e44b855 100644
--- a/src/zip_archive.cc
+++ b/src/zip_archive.cc
@@ -342,7 +342,7 @@
       read_amount = file_length;
   }
 
-  scoped_ptr<uint8_t> scan_buf(new uint8_t[read_amount]);
+  scoped_array<uint8_t> scan_buf(new uint8_t[read_amount]);
   if (scan_buf == NULL) {
     return false;
   }
diff --git a/tools/art b/tools/art
new file mode 100755
index 0000000..ab252eb
--- /dev/null
+++ b/tools/art
@@ -0,0 +1,26 @@
+#!/bin/sh
+#
+# 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.
+
+mkdir -p /tmp/android-data/art-cache
+ANDROID_DATA=/tmp/android-data \
+ANDROID_ROOT=$ANDROID_BUILD_TOP/out/host/linux-x86 \
+LD_LIBRARY_PATH=$ANDROID_BUILD_TOP/out/host/linux-x86/lib \
+$ANDROID_BUILD_TOP/out/host/linux-x86/bin/aexecd \
+-Xbootclasspath\
+:$ANDROID_BUILD_TOP/out/host/linux-x86/framework/core-hostdex.jar\
+:$ANDROID_BUILD_TOP/out/host/linux-x86/framework/bouncycastle-hostdex.jar\
+:$ANDROID_BUILD_TOP/out/host/linux-x86/framework/apache-xml-hostdex.jar \
+$*