Bug 1086693 - Part 6: Use generated bindings for AndroidMediaCodec and AndroidSurfaceTexture r=blassey,gcp
☠☠ backed out by 12c9b418a8fc ☠ ☠
authorJames Willcox <snorp@snorp.net>
Tue, 11 Nov 2014 14:46:09 -0600
changeset 215062 b67a2e48f281b5d88d931cb14e04fdfd73e9f624
parent 215061 2b4b439e7e6ca6b45bb8b3e17ac94a7bd4f6799d
child 215063 6eed18d830d2bfd947ff0099fee113ae4ad821c1
push idunknown
push userunknown
push dateunknown
reviewersblassey, gcp
bugs1086693
milestone36.0a1
Bug 1086693 - Part 6: Use generated bindings for AndroidMediaCodec and AndroidSurfaceTexture r=blassey,gcp
dom/media/fmp4/android/AndroidDecoderModule.cpp
dom/media/fmp4/android/AndroidDecoderModule.h
dom/plugins/base/nsNPAPIPluginInstance.cpp
dom/plugins/base/nsNPAPIPluginInstance.h
gfx/gl/AndroidSurfaceTexture.cpp
gfx/gl/AndroidSurfaceTexture.h
gfx/gl/GLBlitHelper.cpp
gfx/layers/opengl/TextureHostOGL.cpp
widget/android/AndroidBridge.cpp
widget/android/AndroidJavaWrappers.cpp
widget/android/GeneratedSDKWrappers.cpp
widget/android/GeneratedSDKWrappers.h
widget/android/moz.build
--- a/dom/media/fmp4/android/AndroidDecoderModule.cpp
+++ b/dom/media/fmp4/android/AndroidDecoderModule.cpp
@@ -1,50 +1,41 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "AndroidDecoderModule.h"
-#include "PlatformDecoderModule.h"
-#include "GeneratedJNIWrappers.h"
-#include "GeneratedSDKWrappers.h"
 #include "AndroidBridge.h"
-#include "MediaTaskQueue.h"
-#include "SharedThreadPool.h"
-#include "TexturePoolOGL.h"
 #include "GLImages.h"
 
 #include "MediaData.h"
 
 #include "mp4_demuxer/Adts.h"
 #include "mp4_demuxer/AnnexB.h"
 #include "mp4_demuxer/DecoderData.h"
 
 #include "nsThreadUtils.h"
 #include "nsAutoPtr.h"
 
 #include <jni.h>
 #include <string.h>
 
 using namespace mozilla;
 using namespace mozilla::gl;
-using namespace mozilla::widget::android;
+using namespace mozilla::widget::android::sdk;
 
 namespace mozilla {
 
 static MediaCodec* CreateDecoder(JNIEnv* aEnv, const char* aMimeType)
 {
   if (!aMimeType) {
     return nullptr;
   }
 
-  nsAutoString mimeType;
-  mimeType.AssignASCII(aMimeType);
-
-  jobject decoder = MediaCodec::CreateDecoderByType(mimeType);
+  jobject decoder = MediaCodec::CreateDecoderByType(nsCString(aMimeType));
 
   return new MediaCodec(decoder, aEnv);
 }
 
 class VideoDataDecoder : public MediaCodecDataDecoder {
 public:
   VideoDataDecoder(const mp4_demuxer::VideoDecoderConfig& aConfig,
                    MediaFormat* aFormat, MediaDataDecoderCallback* aCallback,
@@ -98,50 +89,50 @@ public:
                                                    mConfig.display_width,
                                                    mConfig.display_height)));
     return NS_OK;
   }
 
 protected:
   layers::ImageContainer* mImageContainer;
   const mp4_demuxer::VideoDecoderConfig& mConfig;
-  nsRefPtr<AndroidSurfaceTexture> mSurfaceTexture;
+  RefPtr<AndroidSurfaceTexture> mSurfaceTexture;
 };
 
 class AudioDataDecoder : public MediaCodecDataDecoder {
 public:
   AudioDataDecoder(const char* aMimeType, MediaFormat* aFormat, MediaDataDecoderCallback* aCallback)
   : MediaCodecDataDecoder(MediaData::Type::AUDIO_DATA, aMimeType, aFormat, aCallback)
   {
   }
 
   virtual nsresult Input(mp4_demuxer::MP4Sample* aSample) MOZ_OVERRIDE {
     if (!strcmp(mMimeType, "audio/mp4a-latm")) {
-      uint32_t numChannels = mFormat->GetInteger(NS_LITERAL_STRING("channel-count"));
-      uint32_t sampleRate = mFormat->GetInteger(NS_LITERAL_STRING("sample-rate"));
+      uint32_t numChannels = mFormat->GetInteger(NS_LITERAL_CSTRING("channel-count"));
+      uint32_t sampleRate = mFormat->GetInteger(NS_LITERAL_CSTRING("sample-rate"));
       uint8_t frequencyIndex =
           mp4_demuxer::Adts::GetFrequencyIndex(sampleRate);
-      uint32_t aacProfile = mFormat->GetInteger(NS_LITERAL_STRING("aac-profile"));
+      uint32_t aacProfile = mFormat->GetInteger(NS_LITERAL_CSTRING("aac-profile"));
       bool rv = mp4_demuxer::Adts::ConvertSample(numChannels,
                                                  frequencyIndex,
                                                  aacProfile,
                                                  aSample);
       if (!rv) {
         printf_stderr("Failed to prepend ADTS header\n");
         return NS_ERROR_FAILURE;
       }
     }
     return MediaCodecDataDecoder::Input(aSample);
   }
 
   nsresult Output(BufferInfo* aInfo, void* aBuffer, MediaFormat* aFormat, Microseconds aDuration) {
     // The output on Android is always 16-bit signed
 
-    uint32_t numChannels = aFormat->GetInteger(NS_LITERAL_STRING("channel-count"));
-    uint32_t sampleRate = aFormat->GetInteger(NS_LITERAL_STRING("sample-rate"));
+    uint32_t numChannels = aFormat->GetInteger(NS_LITERAL_CSTRING("channel-count"));
+    uint32_t sampleRate = aFormat->GetInteger(NS_LITERAL_CSTRING("sample-rate"));
     uint32_t numFrames = (aInfo->getSize() / numChannels) / 2;
 
     AudioDataValue* audio = new AudioDataValue[aInfo->getSize()];
     PodCopy(audio, static_cast<AudioDataValue*>(aBuffer), aInfo->getSize());
 
     mCallback->Output(new AudioData(aInfo->getOffset(), aInfo->getPresentationTimeUs(),
                                     aDuration,
                                     numFrames,
@@ -164,20 +155,17 @@ bool AndroidDecoderModule::SupportsAudio
 already_AddRefed<MediaDataDecoder>
 AndroidDecoderModule::CreateH264Decoder(
                                 const mp4_demuxer::VideoDecoderConfig& aConfig,
                                 layers::LayersBackend aLayersBackend,
                                 layers::ImageContainer* aImageContainer,
                                 MediaTaskQueue* aVideoTaskQueue,
                                 MediaDataDecoderCallback* aCallback)
 {
-  nsAutoString mimeType;
-  mimeType.AssignASCII(aConfig.mime_type);
-
-  jobject jFormat = MediaFormat::CreateVideoFormat(mimeType,
+  jobject jFormat = MediaFormat::CreateVideoFormat(nsCString(aConfig.mime_type),
                                                    aConfig.display_width,
                                                    aConfig.display_height);
 
   if (!jFormat) {
     return nullptr;
   }
 
   MediaFormat* format = MediaFormat::Wrap(jFormat);
@@ -194,48 +182,45 @@ AndroidDecoderModule::CreateH264Decoder(
 
 already_AddRefed<MediaDataDecoder>
 AndroidDecoderModule::CreateAudioDecoder(const mp4_demuxer::AudioDecoderConfig& aConfig,
                                          MediaTaskQueue* aAudioTaskQueue,
                                          MediaDataDecoderCallback* aCallback)
 {
   MOZ_ASSERT(aConfig.bits_per_sample == 16, "We only handle 16-bit audio!");
 
-  nsAutoString mimeType;
-  mimeType.AssignASCII(aConfig.mime_type);
-
-  jobject jFormat = MediaFormat::CreateAudioFormat(mimeType,
+  jobject jFormat = MediaFormat::CreateAudioFormat(nsCString(aConfig.mime_type),
                                                    aConfig.samples_per_second,
                                                    aConfig.channel_count);
 
   if (jFormat == nullptr)
     return nullptr;
 
   MediaFormat* format = MediaFormat::Wrap(jFormat);
 
   if(format == nullptr)
     return nullptr;
 
   JNIEnv* env = GetJNIForThread();
 
-  if (!format->GetByteBuffer(NS_LITERAL_STRING("csd-0"))) {
+  if (!format->GetByteBuffer(NS_LITERAL_CSTRING("csd-0"))) {
     uint8_t* csd0 = new uint8_t[2];
 
     csd0[0] = aConfig.audio_specific_config[0];
     csd0[1] = aConfig.audio_specific_config[1];
 
     jobject buffer = env->NewDirectByteBuffer(csd0, 2);
-    format->SetByteBuffer(NS_LITERAL_STRING("csd-0"), buffer);
+    format->SetByteBuffer(NS_LITERAL_CSTRING("csd-0"), buffer);
 
     env->DeleteLocalRef(buffer);
   }
 
-  if (mimeType.EqualsLiteral("audio/mp4a-latm")) {
-    format->SetInteger(NS_LITERAL_STRING("is-adts"), 1);
-    format->SetInteger(NS_LITERAL_STRING("aac-profile"), aConfig.aac_profile);
+  if (strcmp(aConfig.mime_type, "audio/mp4a-latm") == 0) {
+    format->SetInteger(NS_LITERAL_CSTRING("is-adts"), 1);
+    format->SetInteger(NS_LITERAL_CSTRING("aac-profile"), aConfig.aac_profile);
   }
 
   nsRefPtr<MediaDataDecoder> decoder =
     new AudioDataDecoder(aConfig.mime_type, format, aCallback);
 
   return decoder.forget();
 
 }
@@ -289,25 +274,36 @@ nsresult MediaCodecDataDecoder::InitDeco
 {
   JNIEnv* env = GetJNIForThread();
   mDecoder = CreateDecoder(env, mMimeType);
   if (!mDecoder) {
     mCallback->Error();
     return NS_ERROR_FAILURE;
   }
 
-  if (!mDecoder->Configure(mFormat->wrappedObject(), aSurface, nullptr, 0)) {
-    mCallback->Error();
-    return NS_ERROR_FAILURE;
+  nsresult res;
+  mDecoder->Configure(mFormat->wrappedObject(), aSurface, nullptr, 0, &res);
+  if (NS_FAILED(res)) {
+    return res;
   }
 
-  mDecoder->Start();
+  mDecoder->Start(&res);
+  if (NS_FAILED(res)) {
+    return res;
+  }
 
-  ResetInputBuffers();
-  ResetOutputBuffers();
+  res = ResetInputBuffers();
+  if (NS_FAILED(res)) {
+    return res;
+  }
+
+  res = ResetOutputBuffers();
+  if (NS_FAILED(res)) {
+    return res;
+  }
 
   NS_NewNamedThread("MC Decoder", getter_AddRefs(mThread),
                     NS_NewRunnableMethod(this, &MediaCodecDataDecoder::DecoderLoop));
 
   return NS_OK;
 }
 
 // This is in usec, so that's 10ms
@@ -316,16 +312,17 @@ nsresult MediaCodecDataDecoder::InitDeco
 void MediaCodecDataDecoder::DecoderLoop()
 {
   bool outputDone = false;
 
   JNIEnv* env = GetJNIForThread();
   mp4_demuxer::MP4Sample* sample = nullptr;
 
   nsAutoPtr<MediaFormat> outputFormat;
+  nsresult res;
 
   for (;;) {
     {
       MonitorAutoLock lock(mMonitor);
       while (!mStopping && !mDraining && mQueue.empty()) {
         if (mQueue.empty()) {
           // We could be waiting here forever if we don't signal that we need more input
           mCallback->InputExhausted();
@@ -349,51 +346,74 @@ void MediaCodecDataDecoder::DecoderLoop(
       // We're not stopping or draining, so try to get a sample
       if (!mQueue.empty()) {
         sample = mQueue.front();
       }
     }
 
     if (sample) {
       // We have a sample, try to feed it to the decoder
-      int inputIndex = mDecoder->DequeueInputBuffer(DECODER_TIMEOUT);
+      int inputIndex = mDecoder->DequeueInputBuffer(DECODER_TIMEOUT, &res);
+      if (NS_FAILED(res)) {
+        printf_stderr("exiting decoder loop due to exception while dequeuing input\n");
+        mCallback->Error();
+        break;
+      }
+
       if (inputIndex >= 0) {
         jobject buffer = env->GetObjectArrayElement(mInputBuffers, inputIndex);
         void* directBuffer = env->GetDirectBufferAddress(buffer);
 
         // We're feeding this to the decoder, so remove it from the queue
         mMonitor.Lock();
         mQueue.pop();
         mMonitor.Unlock();
 
         MOZ_ASSERT(env->GetDirectBufferCapacity(buffer) >= sample->size,
           "Decoder buffer is not large enough for sample");
 
         PodCopy((uint8_t*)directBuffer, sample->data, sample->size);
 
-        mDecoder->QueueInputBuffer(inputIndex, 0, sample->size, sample->composition_timestamp, 0);
+        mDecoder->QueueInputBuffer(inputIndex, 0, sample->size, sample->composition_timestamp, 0, &res);
+        if (NS_FAILED(res)) {
+          printf_stderr("exiting decoder loop due to exception while queuing input\n");
+          mCallback->Error();
+          break;
+        }
+
         mDurations.push(sample->duration);
 
         delete sample;
         sample = nullptr;
 
         outputDone = false;
         env->DeleteLocalRef(buffer);
       }
     }
 
     if (!outputDone) {
       BufferInfo bufferInfo;
 
-      int outputStatus = mDecoder->DequeueOutputBuffer(bufferInfo.wrappedObject(), DECODER_TIMEOUT);
+      int outputStatus = mDecoder->DequeueOutputBuffer(bufferInfo.wrappedObject(), DECODER_TIMEOUT, &res);
+      if (NS_FAILED(res)) {
+        printf_stderr("exiting decoder loop due to exception while dequeuing output\n");
+        mCallback->Error();
+        break;
+      }
+
       if (outputStatus == MediaCodec::getINFO_TRY_AGAIN_LATER()) {
         // We might want to call mCallback->InputExhausted() here, but there seems to be
         // some possible bad interactions here with the threading
       } else if (outputStatus == MediaCodec::getINFO_OUTPUT_BUFFERS_CHANGED()) {
-        ResetOutputBuffers();
+        res = ResetOutputBuffers();
+        if (NS_FAILED(res)) {
+          printf_stderr("exiting decoder loop due to exception while restting output buffers\n");
+          mCallback->Error();
+          break;
+        }
       } else if (outputStatus == MediaCodec::getINFO_OUTPUT_FORMAT_CHANGED()) {
         outputFormat = new MediaFormat(mDecoder->GetOutputFormat(), GetJNIForThread());
       } else if (outputStatus < 0) {
         printf_stderr("unknown error from decoder! %d\n", outputStatus);
         mCallback->Error();
       } else {
         // We have a valid buffer index >= 0 here
         if (bufferInfo.getFlags() & MediaCodec::getBUFFER_FLAG_END_OF_STREAM()) {
@@ -449,36 +469,48 @@ void MediaCodecDataDecoder::ClearQueue()
 nsresult MediaCodecDataDecoder::Input(mp4_demuxer::MP4Sample* aSample) {
   MonitorAutoLock lock(mMonitor);
   mQueue.push(aSample);
   lock.NotifyAll();
 
   return NS_OK;
 }
 
-void MediaCodecDataDecoder::ResetInputBuffers()
+nsresult MediaCodecDataDecoder::ResetInputBuffers()
 {
   JNIEnv* env = GetJNIForThread();
 
   if (mInputBuffers) {
     env->DeleteGlobalRef(mInputBuffers);
   }
 
-  mInputBuffers = (jobjectArray) env->NewGlobalRef(mDecoder->GetInputBuffers());
+  nsresult res;
+  mInputBuffers = (jobjectArray) env->NewGlobalRef(mDecoder->GetInputBuffers(&res));
+  if (NS_FAILED(res)) {
+    return res;
+  }
+
+  return NS_OK;
 }
 
-void MediaCodecDataDecoder::ResetOutputBuffers()
+nsresult MediaCodecDataDecoder::ResetOutputBuffers()
 {
   JNIEnv* env = GetJNIForThread();
 
   if (mOutputBuffers) {
     env->DeleteGlobalRef(mOutputBuffers);
   }
 
-  mOutputBuffers = (jobjectArray) env->NewGlobalRef(mDecoder->GetOutputBuffers());
+  nsresult res;
+  mOutputBuffers = (jobjectArray) env->NewGlobalRef(mDecoder->GetOutputBuffers(&res));
+  if (NS_FAILED(res)) {
+    return res;
+  }
+
+  return NS_OK;
 }
 
 nsresult MediaCodecDataDecoder::Flush() {
   Drain();
   return NS_OK;
 }
 
 nsresult MediaCodecDataDecoder::Drain() {
@@ -510,12 +542,13 @@ nsresult MediaCodecDataDecoder::Shutdown
     lock.Wait();
   }
 
   mThread->Shutdown();
   mThread = nullptr;
 
   mDecoder->Stop();
   mDecoder->Release();
+
   return NS_OK;
 }
 
 } // mozilla
--- a/dom/media/fmp4/android/AndroidDecoderModule.h
+++ b/dom/media/fmp4/android/AndroidDecoderModule.h
@@ -1,35 +1,36 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef AndroidDecoderModule_h_
 #define AndroidDecoderModule_h_
 
 #include "PlatformDecoderModule.h"
-#include "AndroidJavaWrappers.h"
 #include "AndroidSurfaceTexture.h"
 
-#include "GeneratedSDKWrappers.h"
+#include "MediaCodec.h"
 #include "mozilla/Monitor.h"
 
 #include <queue>
 
 namespace mozilla {
 
 typedef std::queue<mp4_demuxer::MP4Sample*> SampleQueue;
 
 namespace widget {
 namespace android {
+namespace sdk {
   class MediaCodec;
   class MediaFormat;
   class ByteBuffer;
 }
 }
+}
 
 class MediaCodecDataDecoder;
 
 class AndroidDecoderModule : public PlatformDecoderModule {
 public:
   virtual nsresult Shutdown() MOZ_OVERRIDE;
 
   virtual already_AddRefed<MediaDataDecoder>
@@ -51,59 +52,59 @@ public:
   virtual bool SupportsAudioMimeType(const char* aMimeType) MOZ_OVERRIDE;
 };
 
 class MediaCodecDataDecoder : public MediaDataDecoder {
 public:
 
   MediaCodecDataDecoder(MediaData::Type aType,
                         const char* aMimeType,
-                        mozilla::widget::android::MediaFormat* aFormat,
+                        mozilla::widget::android::sdk::MediaFormat* aFormat,
                         MediaDataDecoderCallback* aCallback);
 
   virtual ~MediaCodecDataDecoder();
 
   virtual nsresult Init() MOZ_OVERRIDE;
   virtual nsresult Flush() MOZ_OVERRIDE;
   virtual nsresult Drain() MOZ_OVERRIDE;
   virtual nsresult Shutdown() MOZ_OVERRIDE;
   virtual nsresult Input(mp4_demuxer::MP4Sample* aSample);
 
 protected:
   friend class AndroidDecoderModule;
 
   MediaData::Type mType;
 
   nsAutoPtr<char> mMimeType;
-  nsAutoPtr<mozilla::widget::android::MediaFormat> mFormat;
+  nsAutoPtr<mozilla::widget::android::sdk::MediaFormat> mFormat;
 
   MediaDataDecoderCallback* mCallback;
 
-  nsAutoPtr<mozilla::widget::android::MediaCodec> mDecoder;
+  nsAutoPtr<mozilla::widget::android::sdk::MediaCodec> mDecoder;
 
   jobjectArray mInputBuffers;
   jobjectArray mOutputBuffers;
 
   nsCOMPtr<nsIThread> mThread;
 
   // Only these members are protected by mMonitor.
   Monitor mMonitor;
   bool mDraining;
   bool mStopping;
 
   SampleQueue mQueue;
   std::queue<Microseconds> mDurations;
 
   virtual nsresult InitDecoder(jobject aSurface = nullptr);
 
-  virtual nsresult Output(mozilla::widget::android::BufferInfo* aInfo, void* aBuffer, mozilla::widget::android::MediaFormat* aFormat, Microseconds aDuration) { return NS_OK; }
-  virtual nsresult PostOutput(mozilla::widget::android::BufferInfo* aInfo, mozilla::widget::android::MediaFormat* aFormat, Microseconds aDuration) { return NS_OK; }
+  virtual nsresult Output(mozilla::widget::android::sdk::BufferInfo* aInfo, void* aBuffer, mozilla::widget::android::sdk::MediaFormat* aFormat, Microseconds aDuration) { return NS_OK; }
+  virtual nsresult PostOutput(mozilla::widget::android::sdk::BufferInfo* aInfo, mozilla::widget::android::sdk::MediaFormat* aFormat, Microseconds aDuration) { return NS_OK; }
 
-  void ResetInputBuffers();
-  void ResetOutputBuffers();
+  nsresult ResetInputBuffers();
+  nsresult ResetOutputBuffers();
 
   void DecoderLoop();
   virtual void ClearQueue();
 };
 
 } // namwspace mozilla
 
 #endif
--- a/dom/plugins/base/nsNPAPIPluginInstance.cpp
+++ b/dom/plugins/base/nsNPAPIPluginInstance.cpp
@@ -947,33 +947,34 @@ nsNPAPIPluginInstance::TextureInfo nsNPA
 }
 
 void nsNPAPIPluginInstance::ReleaseContentTexture(nsNPAPIPluginInstance::TextureInfo& aTextureInfo)
 {
   EnsureSharedTexture();
   mContentTexture->Release(aTextureInfo);
 }
 
-AndroidSurfaceTexture* nsNPAPIPluginInstance::CreateSurfaceTexture()
+TemporaryRef<AndroidSurfaceTexture> nsNPAPIPluginInstance::CreateSurfaceTexture()
 {
   if (!EnsureGLContext())
     return nullptr;
 
   GLuint texture = TexturePoolOGL::AcquireTexture();
   if (!texture)
     return nullptr;
 
-  AndroidSurfaceTexture* surface = AndroidSurfaceTexture::Create(TexturePoolOGL::GetGLContext(),
-                                                                 texture);
-  if (!surface)
+  RefPtr<AndroidSurfaceTexture> surface = AndroidSurfaceTexture::Create(TexturePoolOGL::GetGLContext(),
+                                                                        texture);
+  if (!surface) {
     return nullptr;
+  }
 
   nsCOMPtr<nsIRunnable> frameCallback = NS_NewRunnableMethod(this, &nsNPAPIPluginInstance::OnSurfaceTextureFrameAvailable);
   surface->SetFrameAvailableCallback(frameCallback);
-  return surface;
+  return surface.forget();
 }
 
 void nsNPAPIPluginInstance::OnSurfaceTextureFrameAvailable()
 {
   if (mRunning == RUNNING && mOwner)
     AndroidBridge::Bridge()->ScheduleComposite();
 }
 
@@ -1004,19 +1005,20 @@ nsNPAPIPluginInstance::AsSurfaceTexture(
   if (!mContentSurface)
     return nullptr;
 
   return mContentSurface;
 }
 
 void* nsNPAPIPluginInstance::AcquireVideoWindow()
 {
-  AndroidSurfaceTexture* surface = CreateSurfaceTexture();
-  if (!surface)
+  RefPtr<AndroidSurfaceTexture> surface = CreateSurfaceTexture();
+  if (!surface) {
     return nullptr;
+  }
 
   VideoInfo* info = new VideoInfo(surface);
 
   void* window = info->mSurfaceTexture->NativeWindow()->Handle();
   mVideos.insert(std::pair<void*, VideoInfo*>(window, info));
 
   return window;
 }
--- a/dom/plugins/base/nsNPAPIPluginInstance.h
+++ b/dom/plugins/base/nsNPAPIPluginInstance.h
@@ -202,17 +202,17 @@ public:
     {
     }
 
     ~VideoInfo()
     {
       mSurfaceTexture = nullptr;
     }
 
-    nsRefPtr<mozilla::gl::AndroidSurfaceTexture> mSurfaceTexture;
+    mozilla::RefPtr<mozilla::gl::AndroidSurfaceTexture> mSurfaceTexture;
     gfxRect mDimensions;
   };
 
   void* AcquireVideoWindow();
   void ReleaseVideoWindow(void* aWindow);
   void SetVideoDimensions(void* aWindow, gfxRect aDimensions);
 
   void GetVideos(nsTArray<VideoInfo*>& aVideos);
@@ -323,18 +323,18 @@ protected:
   void PopPostedEvent(PluginEventRunnable* r);
   void OnSurfaceTextureFrameAvailable();
 
   uint32_t mFullScreenOrientation;
   bool mWakeLocked;
   bool mFullScreen;
   bool mInverted;
 
-  nsRefPtr<SharedPluginTexture> mContentTexture;
-  nsRefPtr<mozilla::gl::AndroidSurfaceTexture> mContentSurface;
+  mozilla::RefPtr<SharedPluginTexture> mContentTexture;
+  mozilla::RefPtr<mozilla::gl::AndroidSurfaceTexture> mContentSurface;
 #endif
 
   enum {
     NOT_STARTED,
     RUNNING,
     DESTROYING,
     DESTROYED
   } mRunning;
@@ -373,17 +373,17 @@ private:
   void* mCurrentPluginEvent;
 
   // Timestamp for the last time this plugin was stopped.
   // This is only valid when the plugin is actually stopped!
   mozilla::TimeStamp mStopTime;
 
 #ifdef MOZ_WIDGET_ANDROID
   void EnsureSharedTexture();
-  mozilla::gl::AndroidSurfaceTexture* CreateSurfaceTexture();
+  mozilla::TemporaryRef<mozilla::gl::AndroidSurfaceTexture> CreateSurfaceTexture();
 
   std::map<void*, VideoInfo*> mVideos;
   bool mOnScreen;
 
   nsIntSize mCurrentSize;
 #endif
 
   // is this instance Java and affected by bug 750480?
--- a/gfx/gl/AndroidSurfaceTexture.cpp
+++ b/gfx/gl/AndroidSurfaceTexture.cpp
@@ -10,20 +10,22 @@
 #include <map>
 #include <android/log.h>
 #include "AndroidSurfaceTexture.h"
 #include "gfxImageSurface.h"
 #include "AndroidBridge.h"
 #include "nsThreadUtils.h"
 #include "mozilla/gfx/Matrix.h"
 #include "GeneratedJNIWrappers.h"
+#include "SurfaceTexture.h"
 #include "GLContext.h"
 
 using namespace mozilla;
 using namespace mozilla::widget::android;
+using namespace mozilla::widget::android::sdk;
 
 namespace mozilla {
 namespace gl {
 
 // UGH
 static std::map<int, AndroidSurfaceTexture*> sInstances;
 static int sNextID = 0;
 
@@ -34,304 +36,131 @@ IsDetachSupported()
 }
 
 static bool
 IsSTSupported()
 {
   return AndroidBridge::Bridge()->GetAPIVersion() >= 14; /* ICS */
 }
 
-static class JNIFunctions {
-public:
-
-  JNIFunctions() : mInitialized(false)
-  {
-  }
-
-  bool EnsureInitialized()
-  {
-    if (mInitialized) {
-      return true;
-    }
-
-    if (!IsSTSupported()) {
-      return false;
-    }
-
-    JNIEnv* env = GetJNIForThread();
-
-    AutoLocalJNIFrame jniFrame(env);
-
-    jSurfaceTextureClass = (jclass)env->NewGlobalRef(env->FindClass("android/graphics/SurfaceTexture"));
-    jSurfaceTexture_Ctor = env->GetMethodID(jSurfaceTextureClass, "<init>", "(I)V");
-    jSurfaceTexture_updateTexImage = env->GetMethodID(jSurfaceTextureClass, "updateTexImage", "()V");
-    jSurfaceTexture_getTransformMatrix = env->GetMethodID(jSurfaceTextureClass, "getTransformMatrix", "([F)V");
-    jSurfaceTexture_setDefaultBufferSize = env->GetMethodID(jSurfaceTextureClass, "setDefaultBufferSize", "(II)V");
-
-    if (IsDetachSupported()) {
-      jSurfaceTexture_attachToGLContext = env->GetMethodID(jSurfaceTextureClass, "attachToGLContext", "(I)V");
-      jSurfaceTexture_detachFromGLContext = env->GetMethodID(jSurfaceTextureClass, "detachFromGLContext", "()V");
-    } else {
-      jSurfaceTexture_attachToGLContext = jSurfaceTexture_detachFromGLContext = 0;
-    }
-
-    jSurfaceClass = (jclass)env->NewGlobalRef(env->FindClass("android/view/Surface"));
-    jSurface_Ctor = env->GetMethodID(jSurfaceClass, "<init>", "(Landroid/graphics/SurfaceTexture;)V");
-
-    mInitialized = true;
-    return true;
-  }
-
-  jobject CreateSurfaceTexture(GLuint aTexture)
-  {
-    if (!EnsureInitialized())
-      return nullptr;
-
-    JNIEnv* env = GetJNIForThread();
-
-    AutoLocalJNIFrame jniFrame(env);
-
-    return env->NewGlobalRef(env->NewObject(jSurfaceTextureClass, jSurfaceTexture_Ctor, (int) aTexture));
-  }
-
-  jobject CreateSurface(jobject aSurfaceTexture)
-  {
-    if (!EnsureInitialized())
-      return nullptr;
-
-    JNIEnv* env = GetJNIForThread();
-    AutoLocalJNIFrame jniFrame(env);
-    return env->NewGlobalRef(env->NewObject(jSurfaceClass, jSurface_Ctor, aSurfaceTexture));
-  }
-
-  void ReleaseSurfaceTexture(jobject aSurfaceTexture)
-  {
-    JNIEnv* env = GetJNIForThread();
-
-    env->DeleteGlobalRef(aSurfaceTexture);
-  }
-
-  void UpdateTexImage(jobject aSurfaceTexture)
-  {
-    JNIEnv* env = GetJNIForThread();
-
-    AutoLocalJNIFrame jniFrame(env);
-    env->CallVoidMethod(aSurfaceTexture, jSurfaceTexture_updateTexImage);
-  }
-
-  bool GetTransformMatrix(jobject aSurfaceTexture, gfx::Matrix4x4& aMatrix)
-  {
-    JNIEnv* env = GetJNIForThread();
-
-    AutoLocalJNIFrame jniFrame(env);
-
-    jfloatArray jarray = env->NewFloatArray(16);
-    env->CallVoidMethod(aSurfaceTexture, jSurfaceTexture_getTransformMatrix, jarray);
-
-    jfloat* array = env->GetFloatArrayElements(jarray, nullptr);
-
-    aMatrix._11 = array[0];
-    aMatrix._12 = array[1];
-    aMatrix._13 = array[2];
-    aMatrix._14 = array[3];
-
-    aMatrix._21 = array[4];
-    aMatrix._22 = array[5];
-    aMatrix._23 = array[6];
-    aMatrix._24 = array[7];
-
-    aMatrix._31 = array[8];
-    aMatrix._32 = array[9];
-    aMatrix._33 = array[10];
-    aMatrix._34 = array[11];
-
-    aMatrix._41 = array[12];
-    aMatrix._42 = array[13];
-    aMatrix._43 = array[14];
-    aMatrix._44 = array[15];
-
-    env->ReleaseFloatArrayElements(jarray, array, 0);
-
-    return false;
-  }
-
-  void SetDefaultBufferSize(jobject aSurfaceTexture, int32_t width, int32_t height)
-  {
-    JNIEnv* env = GetJNIForThread();
-
-    AutoLocalJNIFrame jniFrame(env);
-    env->CallVoidMethod(aSurfaceTexture, jSurfaceTexture_setDefaultBufferSize, width, height);
-  }
-
-  void AttachToGLContext(jobject aSurfaceTexture, int32_t texName)
-  {
-    MOZ_ASSERT(jSurfaceTexture_attachToGLContext);
-
-    JNIEnv* env = GetJNIForThread();
-
-    env->CallVoidMethod(aSurfaceTexture, jSurfaceTexture_attachToGLContext, texName);
-    if (env->ExceptionCheck()) {
-      env->ExceptionDescribe();
-      env->ExceptionClear();
-    }
-  }
-
-  void DetachFromGLContext(jobject aSurfaceTexture)
-  {
-    MOZ_ASSERT(jSurfaceTexture_detachFromGLContext);
-
-    JNIEnv* env = GetJNIForThread();
-
-    env->CallVoidMethod(aSurfaceTexture, jSurfaceTexture_detachFromGLContext);
-    if (env->ExceptionCheck()) {
-      env->ExceptionDescribe();
-      env->ExceptionClear();
-    }
-  }
-
-private:
-  bool mInitialized;
-
-  jclass jSurfaceTextureClass;
-  jmethodID jSurfaceTexture_Ctor;
-  jmethodID jSurfaceTexture_updateTexImage;
-  jmethodID jSurfaceTexture_getTransformMatrix;
-  jmethodID jSurfaceTexture_setDefaultBufferSize;
-
-  jmethodID jSurfaceTexture_attachToGLContext;
-  jmethodID jSurfaceTexture_detachFromGLContext;
-
-  jclass jSurfaceClass;
-  jmethodID jSurface_Ctor;
-
-} sJNIFunctions;
-
-AndroidSurfaceTexture*
+TemporaryRef<AndroidSurfaceTexture>
 AndroidSurfaceTexture::Create()
 {
   return Create(nullptr, 0);
 }
 
-AndroidSurfaceTexture*
+TemporaryRef<AndroidSurfaceTexture>
 AndroidSurfaceTexture::Create(GLContext* aContext, GLuint aTexture)
 {
   if (!IsSTSupported()) {
     return nullptr;
   }
 
-  AndroidSurfaceTexture* st = new AndroidSurfaceTexture();
+  RefPtr<AndroidSurfaceTexture> st = new AndroidSurfaceTexture();
   if (!st->Init(aContext, aTexture)) {
     printf_stderr("Failed to initialize AndroidSurfaceTexture");
-    delete st;
     st = nullptr;
   }
 
-  return st;
+  return st.forget();
 }
 
 AndroidSurfaceTexture*
 AndroidSurfaceTexture::Find(int id)
 {
   std::map<int, AndroidSurfaceTexture*>::iterator it;
 
   it = sInstances.find(id);
   if (it == sInstances.end())
     return nullptr;
 
   return it->second;
 }
 
-bool
-AndroidSurfaceTexture::Check()
-{
-  return sJNIFunctions.EnsureInitialized();
-}
 
-bool
+nsresult
 AndroidSurfaceTexture::Attach(GLContext* aContext, PRIntervalTime aTimeout)
 {
   MonitorAutoLock lock(mMonitor);
 
   if (mAttachedContext == aContext) {
     NS_WARNING("Tried to attach same GLContext to AndroidSurfaceTexture");
-    return true;
+    return NS_OK;
   }
 
   if (!IsDetachSupported()) {
-    return false;
+    return NS_ERROR_NOT_AVAILABLE;
   }
 
   while (mAttachedContext) {
     // Wait until it's detached (or we time out)
     if (NS_FAILED(lock.Wait(aTimeout))) {
-      return false;
+      return NS_ERROR_NOT_AVAILABLE;
     }
   }
 
   MOZ_ASSERT(aContext->IsOwningThreadCurrent(), "Trying to attach GLContext from different thread");
 
   mAttachedContext = aContext;
   mAttachedContext->MakeCurrent();
   aContext->fGenTextures(1, &mTexture);
 
-  sJNIFunctions.AttachToGLContext(mSurfaceTexture, mTexture);
-  return true;
+  nsresult res;
+  mSurfaceTexture->AttachToGLContext(mTexture, &res);
+  return res;
 }
 
-bool
+nsresult
 AndroidSurfaceTexture::Detach()
 {
   MonitorAutoLock lock(mMonitor);
 
   if (!IsDetachSupported() ||
       !mAttachedContext || !mAttachedContext->IsOwningThreadCurrent()) {
-    return false;
+    return NS_ERROR_FAILURE;
   }
 
   mAttachedContext->MakeCurrent();
 
-  // This call takes care of deleting the texture
-  sJNIFunctions.DetachFromGLContext(mSurfaceTexture);
+  mSurfaceTexture->DetachFromGLContext();
 
   mTexture = 0;
   mAttachedContext = nullptr;
   lock.NotifyAll();
-  return true;
+  return NS_OK;
 }
 
 bool
 AndroidSurfaceTexture::Init(GLContext* aContext, GLuint aTexture)
 {
   if (!aTexture && !IsDetachSupported()) {
     // We have no texture and cannot initialize detached, bail out
     return false;
   }
 
-  if (!sJNIFunctions.EnsureInitialized())
-    return false;
-
-  JNIEnv* env = GetJNIForThread();
-
-  mSurfaceTexture = sJNIFunctions.CreateSurfaceTexture(aTexture);
-  if (!mSurfaceTexture) {
+  nsresult res;
+  mSurfaceTexture = new SurfaceTexture(aTexture, &res);
+  if (NS_FAILED(res)) {
     return false;
   }
 
   if (!aTexture) {
-    sJNIFunctions.DetachFromGLContext(mSurfaceTexture);
+    mSurfaceTexture->DetachFromGLContext();
   }
 
   mAttachedContext = aContext;
 
-  mSurface = sJNIFunctions.CreateSurface(mSurfaceTexture);
-  if (!mSurface) {
+  mSurface = new Surface(mSurfaceTexture->wrappedObject(), &res);
+  if (NS_FAILED(res)) {
     return false;
   }
 
-  mNativeWindow = AndroidNativeWindow::CreateFromSurface(env, mSurface);
+  mNativeWindow = AndroidNativeWindow::CreateFromSurface(GetJNIForThread(),
+                                                         mSurface->wrappedObject());
+  MOZ_ASSERT(mNativeWindow, "Failed to create native window from surface");
 
   mID = ++sNextID;
   sInstances.insert(std::pair<int, AndroidSurfaceTexture*>(mID, this));
 
   return true;
 }
 
 AndroidSurfaceTexture::AndroidSurfaceTexture()
@@ -344,59 +173,79 @@ AndroidSurfaceTexture::AndroidSurfaceTex
 }
 
 AndroidSurfaceTexture::~AndroidSurfaceTexture()
 {
   sInstances.erase(mID);
 
   mFrameAvailableCallback = nullptr;
 
-  JNIEnv* env = GetJNIForThread();
-
   if (mSurfaceTexture) {
-    GeckoAppShell::UnregisterSurfaceTextureFrameListener(mSurfaceTexture);
-
-    env->DeleteGlobalRef(mSurfaceTexture);
+    GeckoAppShell::UnregisterSurfaceTextureFrameListener(mSurfaceTexture->wrappedObject());
     mSurfaceTexture = nullptr;
   }
-
-  if (mSurface) {
-    env->DeleteGlobalRef(mSurface);
-    mSurface = nullptr;
-  }
 }
 
 void
 AndroidSurfaceTexture::UpdateTexImage()
 {
-  sJNIFunctions.UpdateTexImage(mSurfaceTexture);
+  mSurfaceTexture->UpdateTexImage();
 }
 
-bool
+void
 AndroidSurfaceTexture::GetTransformMatrix(gfx::Matrix4x4& aMatrix)
 {
-  return sJNIFunctions.GetTransformMatrix(mSurfaceTexture, aMatrix);
+  JNIEnv* env = GetJNIForThread();
+
+  AutoLocalJNIFrame jniFrame(env);
+
+  jfloatArray jarray = env->NewFloatArray(16);
+  mSurfaceTexture->GetTransformMatrix(jarray);
+
+  jfloat* array = env->GetFloatArrayElements(jarray, nullptr);
+
+  aMatrix._11 = array[0];
+  aMatrix._12 = array[1];
+  aMatrix._13 = array[2];
+  aMatrix._14 = array[3];
+
+  aMatrix._21 = array[4];
+  aMatrix._22 = array[5];
+  aMatrix._23 = array[6];
+  aMatrix._24 = array[7];
+
+  aMatrix._31 = array[8];
+  aMatrix._32 = array[9];
+  aMatrix._33 = array[10];
+  aMatrix._34 = array[11];
+
+  aMatrix._41 = array[12];
+  aMatrix._42 = array[13];
+  aMatrix._43 = array[14];
+  aMatrix._44 = array[15];
+
+  env->ReleaseFloatArrayElements(jarray, array, 0);
 }
 
 void
 AndroidSurfaceTexture::SetFrameAvailableCallback(nsIRunnable* aRunnable)
 {
   if (aRunnable) {
-    GeckoAppShell::RegisterSurfaceTextureFrameListener(mSurfaceTexture, mID);
+    GeckoAppShell::RegisterSurfaceTextureFrameListener(mSurfaceTexture->wrappedObject(), mID);
   } else {
-     GeckoAppShell::UnregisterSurfaceTextureFrameListener(mSurfaceTexture);
+     GeckoAppShell::UnregisterSurfaceTextureFrameListener(mSurfaceTexture->wrappedObject());
   }
 
   mFrameAvailableCallback = aRunnable;
 }
 
 void
 AndroidSurfaceTexture::SetDefaultSize(mozilla::gfx::IntSize size)
 {
-  sJNIFunctions.SetDefaultBufferSize(mSurfaceTexture, size.width, size.height);
+  mSurfaceTexture->SetDefaultBufferSize(size.width, size.height);
 }
 
 void
 AndroidSurfaceTexture::NotifyFrameAvailable()
 {
   if (mFrameAvailableCallback) {
     // Proxy to main thread if we aren't on it
     if (!NS_IsMainThread()) {
--- a/gfx/gl/AndroidSurfaceTexture.h
+++ b/gfx/gl/AndroidSurfaceTexture.h
@@ -10,16 +10,17 @@
 
 #include <jni.h>
 #include "nsIRunnable.h"
 #include "gfxPlatform.h"
 #include "GLDefs.h"
 #include "mozilla/gfx/2D.h"
 #include "mozilla/Monitor.h"
 
+#include "SurfaceTexture.h"
 #include "AndroidNativeWindow.h"
 
 class gfxASurface;
 
 namespace mozilla {
 namespace gfx {
 class Matrix4x4;
 }
@@ -37,74 +38,70 @@ class GLContext;
  */
 class AndroidSurfaceTexture {
   NS_INLINE_DECL_THREADSAFE_REFCOUNTING(AndroidSurfaceTexture)
 
 public:
 
   // The SurfaceTexture is created in an attached state. This method requires
   // Android Ice Cream Sandwich.
-  static AndroidSurfaceTexture* Create(GLContext* aGLContext, GLuint aTexture);
+  static TemporaryRef<AndroidSurfaceTexture> Create(GLContext* aGLContext, GLuint aTexture);
 
   // Here the SurfaceTexture will be created in a detached state. You must call
   // Attach() with the GLContext you wish to composite with. It must be done
   // on the thread where that GLContext is current. This method requires
   // Android Jelly Bean.
-  static AndroidSurfaceTexture* Create();
+  static TemporaryRef<AndroidSurfaceTexture> Create();
 
   static AndroidSurfaceTexture* Find(int id);
 
-  // Returns with reasonable certainty whether or not we'll
-  // be able to create and use a SurfaceTexture
-  static bool Check();
-
   // If we are on Jelly Bean, the SurfaceTexture can be detached and reattached
   // to allow consumption from different GLContexts. It is recommended to only
   // attach while you are consuming in order to allow this.
   //
   // Only one GLContext may be attached at any given time. If another is already
   // attached, we try to wait for it to become detached.
-  bool Attach(GLContext* aContext, PRIntervalTime aTiemout = PR_INTERVAL_NO_TIMEOUT);
+  nsresult Attach(GLContext* aContext, PRIntervalTime aTiemout = PR_INTERVAL_NO_TIMEOUT);
 
   // This is a noop on ICS, and will always fail
-  bool Detach();
+  nsresult Detach();
 
   GLContext* GetAttachedContext() { return mAttachedContext; }
 
   AndroidNativeWindow* NativeWindow() {
     return mNativeWindow;
   }
 
   // This attaches the updated data to the TEXTURE_EXTERNAL target
   void UpdateTexImage();
 
-  bool GetTransformMatrix(mozilla::gfx::Matrix4x4& aMatrix);
+  void GetTransformMatrix(mozilla::gfx::Matrix4x4& aMatrix);
   int ID() { return mID; }
 
   void SetDefaultSize(mozilla::gfx::IntSize size);
 
   // The callback is guaranteed to be called on the main thread even
   // if the upstream callback is received on a different thread
   void SetFrameAvailableCallback(nsIRunnable* aRunnable);
 
   // Only should be called by AndroidJNI when we get a
   // callback from the underlying SurfaceTexture instance
   void NotifyFrameAvailable();
 
   GLuint Texture() { return mTexture; }
-  jobject JavaSurface() { return mSurface; }
+  jobject JavaSurface() { return mSurface->wrappedObject(); }
 private:
   AndroidSurfaceTexture();
   ~AndroidSurfaceTexture();
 
   bool Init(GLContext* aContext, GLuint aTexture);
 
   GLuint mTexture;
-  jobject mSurfaceTexture;
-  jobject mSurface;
+  nsAutoPtr<mozilla::widget::android::sdk::SurfaceTexture> mSurfaceTexture;
+  nsAutoPtr<mozilla::widget::android::sdk::Surface> mSurface;
 
   Monitor mMonitor;
   GLContext* mAttachedContext;
 
   RefPtr<AndroidNativeWindow> mNativeWindow;
   int mID;
   nsRefPtr<nsIRunnable> mFrameAvailableCallback;
 };
--- a/gfx/gl/GLBlitHelper.cpp
+++ b/gfx/gl/GLBlitHelper.cpp
@@ -723,17 +723,17 @@ bool
 GLBlitHelper::BlitSurfaceTextureImage(layers::SurfaceTextureImage* stImage)
 {
     AndroidSurfaceTexture* surfaceTexture = stImage->GetData()->mSurfTex;
     bool yFlip = stImage->GetData()->mInverted;
 
     ScopedBindTextureUnit boundTU(mGL, LOCAL_GL_TEXTURE0);
     mGL->fClear(LOCAL_GL_COLOR_BUFFER_BIT);
 
-    if (!surfaceTexture->Attach(mGL)) {
+    if (NS_FAILED(surfaceTexture->Attach(mGL))) {
         return false;
     }
 
     // UpdateTexImage() changes the EXTERNAL binding, so save it here
     // so we can restore it after.
     int oldBinding = 0;
     mGL->fGetIntegerv(LOCAL_GL_TEXTURE_BINDING_EXTERNAL, &oldBinding);
 
--- a/gfx/layers/opengl/TextureHostOGL.cpp
+++ b/gfx/layers/opengl/TextureHostOGL.cpp
@@ -529,19 +529,17 @@ SurfaceTextureHost::Lock()
     mTextureSource = new SurfaceTextureSource(mCompositor,
                                               mSurfTex,
                                               format,
                                               target,
                                               wrapMode,
                                               mSize);
   }
 
-  mSurfTex->Attach(gl());
-
-  return true;
+  return NS_SUCCEEDED(mSurfTex->Attach(gl()));
 }
 
 void
 SurfaceTextureHost::Unlock()
 {
   mSurfTex->Detach();
 }
 
--- a/widget/android/AndroidBridge.cpp
+++ b/widget/android/AndroidBridge.cpp
@@ -36,17 +36,19 @@
 #include "nsIDOMClientRect.h"
 #include "StrongPointer.h"
 #include "mozilla/ClearOnShutdown.h"
 #include "nsPrintfCString.h"
 #include "NativeJSContainer.h"
 #include "nsContentUtils.h"
 #include "nsIScriptError.h"
 #include "nsIHttpChannel.h"
-#include "GeneratedSDKWrappers.h"
+
+#include "MediaCodec.h"
+#include "SurfaceTexture.h"
 
 using namespace mozilla;
 using namespace mozilla::widget::android;
 using namespace mozilla::gfx;
 
 AndroidBridge* AndroidBridge::sBridge;
 pthread_t AndroidBridge::sJavaUiThread = -1;
 static unsigned sJavaEnvThreadIndex = 0;
@@ -217,18 +219,21 @@ AndroidBridge::Init(JNIEnv *jEnv)
 
     jInputStream = getClassGlobalRef("java/io/InputStream");
     jClose = jEnv->GetMethodID(jInputStream, "close", "()V");
     jAvailable = jEnv->GetMethodID(jInputStream, "available", "()I");
 
     InitAndroidJavaWrappers(jEnv);
 
     if (mAPIVersion >= 16 /* Jelly Bean */) {
-        // We only use this for MediaCodec right now
-        InitSDKStubs(jEnv);
+        sdk::InitMediaCodecStubs(jEnv);
+    }
+
+    if (mAPIVersion >= 14 /* ICS */) {
+        sdk::InitSurfaceTextureStubs(jEnv);
     }
 
     // jEnv should NOT be cached here by anything -- the jEnv here
     // is not valid for the real gecko main thread, which is set
     // at SetMainThread time.
 
     return true;
 }
--- a/widget/android/AndroidJavaWrappers.cpp
+++ b/widget/android/AndroidJavaWrappers.cpp
@@ -6,17 +6,16 @@
 #include "AndroidJavaWrappers.h"
 #include "AndroidBridge.h"
 #include "AndroidBridgeUtilities.h"
 #include "nsIDOMKeyEvent.h"
 #include "nsIWidget.h"
 #include "mozilla/BasicEvents.h"
 #include "mozilla/TimeStamp.h"
 #include "mozilla/TouchEvents.h"
-#include "GeneratedSDKWrappers.h"
 
 using namespace mozilla;
 using namespace mozilla::dom;
 using namespace mozilla::widget::android;
 
 jclass AndroidGeckoEvent::jGeckoEventClass = 0;
 jfieldID AndroidGeckoEvent::jActionField = 0;
 jfieldID AndroidGeckoEvent::jTypeField = 0;
deleted file mode 100644
--- a/widget/android/GeneratedSDKWrappers.cpp
+++ /dev/null
@@ -1,1877 +0,0 @@
-// GENERATED CODE
-// Generated by the Java program at /build/jarClassProcessors at compile time from
-// a given set of jars and a set of requested methods. To update, change the annotations
-// on the corresponding Java methods and rerun the build. Manually updating this file
-// will cause your build to fail.
-
-#include "GeneratedSDKWrappers.h"
-#include "AndroidBridgeUtilities.h"
-#include "nsXPCOMStrings.h"
-#include "AndroidBridge.h"
-#include "nsDebug.h"
-
-namespace mozilla {
-namespace widget {
-namespace android {
-jclass MediaCodec::mMediaCodecClass = 0;
-jmethodID MediaCodec::jConfigure = 0;
-jmethodID MediaCodec::jCreateByCodecName = 0;
-jmethodID MediaCodec::jCreateDecoderByType = 0;
-jmethodID MediaCodec::jCreateEncoderByType = 0;
-jmethodID MediaCodec::jDequeueInputBuffer = 0;
-jmethodID MediaCodec::jDequeueOutputBuffer = 0;
-jmethodID MediaCodec::jFinalize = 0;
-jmethodID MediaCodec::jFlush = 0;
-jmethodID MediaCodec::jGetInputBuffers = 0;
-jmethodID MediaCodec::jGetOutputBuffers = 0;
-jmethodID MediaCodec::jGetOutputFormat = 0;
-jmethodID MediaCodec::jQueueInputBuffer = 0;
-jmethodID MediaCodec::jQueueSecureInputBuffer = 0;
-jmethodID MediaCodec::jRelease = 0;
-jmethodID MediaCodec::jReleaseOutputBuffer = 0;
-jmethodID MediaCodec::jSetVideoScalingMode = 0;
-jmethodID MediaCodec::jStart = 0;
-jmethodID MediaCodec::jStop = 0;
-jfieldID MediaCodec::jBUFFER_FLAG_CODEC_CONFIG = 0;
-jfieldID MediaCodec::jBUFFER_FLAG_END_OF_STREAM = 0;
-jfieldID MediaCodec::jBUFFER_FLAG_SYNC_FRAME = 0;
-jfieldID MediaCodec::jCONFIGURE_FLAG_ENCODE = 0;
-jfieldID MediaCodec::jCRYPTO_MODE_AES_CTR = 0;
-jfieldID MediaCodec::jCRYPTO_MODE_UNENCRYPTED = 0;
-jfieldID MediaCodec::jINFO_OUTPUT_BUFFERS_CHANGED = 0;
-jfieldID MediaCodec::jINFO_OUTPUT_FORMAT_CHANGED = 0;
-jfieldID MediaCodec::jINFO_TRY_AGAIN_LATER = 0;
-jfieldID MediaCodec::jVIDEO_SCALING_MODE_SCALE_TO_FIT = 0;
-jfieldID MediaCodec::jVIDEO_SCALING_MODE_SCALE_TO_FIT_WITH_CROPPING = 0;
-void MediaCodec::InitStubs(JNIEnv *jEnv) {
-    initInit();
-
-    mMediaCodecClass = getClassGlobalRef("android/media/MediaCodec");
-    jConfigure = getMethod("configure", "(Landroid/media/MediaFormat;Landroid/view/Surface;Landroid/media/MediaCrypto;I)V");
-    jCreateByCodecName = getStaticMethod("createByCodecName", "(Ljava/lang/String;)Landroid/media/MediaCodec;");
-    jCreateDecoderByType = getStaticMethod("createDecoderByType", "(Ljava/lang/String;)Landroid/media/MediaCodec;");
-    jCreateEncoderByType = getStaticMethod("createEncoderByType", "(Ljava/lang/String;)Landroid/media/MediaCodec;");
-    jDequeueInputBuffer = getMethod("dequeueInputBuffer", "(J)I");
-    jDequeueOutputBuffer = getMethod("dequeueOutputBuffer", "(Landroid/media/MediaCodec$BufferInfo;J)I");
-    jFinalize = getMethod("finalize", "()V");
-    jFlush = getMethod("flush", "()V");
-    jGetInputBuffers = getMethod("getInputBuffers", "()[Ljava/nio/ByteBuffer;");
-    jGetOutputBuffers = getMethod("getOutputBuffers", "()[Ljava/nio/ByteBuffer;");
-    jGetOutputFormat = getMethod("getOutputFormat", "()Landroid/media/MediaFormat;");
-    jQueueInputBuffer = getMethod("queueInputBuffer", "(IIIJI)V");
-    jQueueSecureInputBuffer = getMethod("queueSecureInputBuffer", "(IILandroid/media/MediaCodec$CryptoInfo;JI)V");
-    jRelease = getMethod("release", "()V");
-    jReleaseOutputBuffer = getMethod("releaseOutputBuffer", "(IZ)V");
-    jSetVideoScalingMode = getMethod("setVideoScalingMode", "(I)V");
-    jStart = getMethod("start", "()V");
-    jStop = getMethod("stop", "()V");
-    jBUFFER_FLAG_CODEC_CONFIG = getStaticField("BUFFER_FLAG_CODEC_CONFIG", "I");
-    jBUFFER_FLAG_END_OF_STREAM = getStaticField("BUFFER_FLAG_END_OF_STREAM", "I");
-    jBUFFER_FLAG_SYNC_FRAME = getStaticField("BUFFER_FLAG_SYNC_FRAME", "I");
-    jCONFIGURE_FLAG_ENCODE = getStaticField("CONFIGURE_FLAG_ENCODE", "I");
-    jCRYPTO_MODE_AES_CTR = getStaticField("CRYPTO_MODE_AES_CTR", "I");
-    jCRYPTO_MODE_UNENCRYPTED = getStaticField("CRYPTO_MODE_UNENCRYPTED", "I");
-    jINFO_OUTPUT_BUFFERS_CHANGED = getStaticField("INFO_OUTPUT_BUFFERS_CHANGED", "I");
-    jINFO_OUTPUT_FORMAT_CHANGED = getStaticField("INFO_OUTPUT_FORMAT_CHANGED", "I");
-    jINFO_TRY_AGAIN_LATER = getStaticField("INFO_TRY_AGAIN_LATER", "I");
-    jVIDEO_SCALING_MODE_SCALE_TO_FIT = getStaticField("VIDEO_SCALING_MODE_SCALE_TO_FIT", "I");
-    jVIDEO_SCALING_MODE_SCALE_TO_FIT_WITH_CROPPING = getStaticField("VIDEO_SCALING_MODE_SCALE_TO_FIT_WITH_CROPPING", "I");
-}
-
-MediaCodec* MediaCodec::Wrap(jobject obj) {
-    JNIEnv *env = GetJNIForThread();
-    MediaCodec* ret = new MediaCodec(obj, env);
-    env->DeleteLocalRef(obj);
-    return ret;
-}
-
-bool MediaCodec::Configure(jobject a0, jobject a1, jobject a2, int32_t a3) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(3) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jvalue args[4];
-    args[0].l = a0;
-    args[1].l = a1;
-    args[2].l = a2;
-    args[3].i = a3;
-
-    env->CallVoidMethodA(wrapped_obj, jConfigure, args);
-    if (env->ExceptionCheck()) {
-        env->ExceptionClear();
-        env->PopLocalFrame(nullptr);
-        return false;
-    }
-    env->PopLocalFrame(nullptr);
-    return true;
-}
-
-jobject MediaCodec::CreateByCodecName(const nsAString& a0) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(2) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jstring j0 = AndroidBridge::NewJavaString(env, a0);
-
-    jobject temp = env->CallStaticObjectMethod(mMediaCodecClass, jCreateByCodecName, j0);
-    AndroidBridge::HandleUncaughtException(env);
-    jobject ret = static_cast<jobject>(env->PopLocalFrame(temp));
-    return ret;
-}
-
-jobject MediaCodec::CreateDecoderByType(const nsAString& a0) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(2) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jstring j0 = AndroidBridge::NewJavaString(env, a0);
-
-    jobject temp = env->CallStaticObjectMethod(mMediaCodecClass, jCreateDecoderByType, j0);
-    AndroidBridge::HandleUncaughtException(env);
-    jobject ret = static_cast<jobject>(env->PopLocalFrame(temp));
-    return ret;
-}
-
-jobject MediaCodec::CreateEncoderByType(const nsAString& a0) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(2) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jstring j0 = AndroidBridge::NewJavaString(env, a0);
-
-    jobject temp = env->CallStaticObjectMethod(mMediaCodecClass, jCreateEncoderByType, j0);
-    AndroidBridge::HandleUncaughtException(env);
-    jobject ret = static_cast<jobject>(env->PopLocalFrame(temp));
-    return ret;
-}
-
-int32_t MediaCodec::DequeueInputBuffer(int64_t a0) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(0) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    int32_t temp = env->CallIntMethod(wrapped_obj, jDequeueInputBuffer, a0);
-    if (env->ExceptionCheck()) {
-        env->ExceptionClear();
-        env->PopLocalFrame(nullptr);
-        return MEDIACODEC_EXCEPTION_INDEX;
-    }
-    env->PopLocalFrame(nullptr);
-    return temp;
-}
-
-int32_t MediaCodec::DequeueOutputBuffer(jobject a0, int64_t a1) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(1) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    int32_t temp = env->CallIntMethod(wrapped_obj, jDequeueOutputBuffer, a0, a1);
-    if (env->ExceptionCheck()) {
-        env->ExceptionClear();
-        env->PopLocalFrame(nullptr);
-        return MEDIACODEC_EXCEPTION_INDEX;
-    }
-    env->PopLocalFrame(nullptr);
-    return temp;
-}
-
-void MediaCodec::Finalize() {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(0) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    env->CallVoidMethod(wrapped_obj, jFinalize);
-    AndroidBridge::HandleUncaughtException(env);
-    env->PopLocalFrame(nullptr);
-}
-
-void MediaCodec::Flush() {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(0) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    env->CallVoidMethod(wrapped_obj, jFlush);
-    AndroidBridge::HandleUncaughtException(env);
-    env->PopLocalFrame(nullptr);
-}
-
-jobjectArray MediaCodec::GetInputBuffers() {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(1) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jobject temp = env->CallObjectMethod(wrapped_obj, jGetInputBuffers);
-    AndroidBridge::HandleUncaughtException(env);
-    jobjectArray ret = static_cast<jobjectArray>(env->PopLocalFrame(temp));
-    return ret;
-}
-
-jobjectArray MediaCodec::GetOutputBuffers() {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(1) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jobject temp = env->CallObjectMethod(wrapped_obj, jGetOutputBuffers);
-    AndroidBridge::HandleUncaughtException(env);
-    jobjectArray ret = static_cast<jobjectArray>(env->PopLocalFrame(temp));
-    return ret;
-}
-
-jobject MediaCodec::GetOutputFormat() {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(1) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jobject temp = env->CallObjectMethod(wrapped_obj, jGetOutputFormat);
-    AndroidBridge::HandleUncaughtException(env);
-    jobject ret = static_cast<jobject>(env->PopLocalFrame(temp));
-    return ret;
-}
-
-void MediaCodec::QueueInputBuffer(int32_t a0, int32_t a1, int32_t a2, int64_t a3, int32_t a4) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(5) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jvalue args[5];
-    args[0].i = a0;
-    args[1].i = a1;
-    args[2].i = a2;
-    args[3].j = a3;
-    args[4].i = a4;
-
-    env->CallVoidMethodA(wrapped_obj, jQueueInputBuffer, args);
-    AndroidBridge::HandleUncaughtException(env);
-    env->PopLocalFrame(nullptr);
-}
-
-void MediaCodec::QueueSecureInputBuffer(int32_t a0, int32_t a1, jobject a2, int64_t a3, int32_t a4) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(1) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jvalue args[5];
-    args[0].i = a0;
-    args[1].i = a1;
-    args[2].l = a2;
-    args[3].j = a3;
-    args[4].i = a4;
-
-    env->CallVoidMethodA(wrapped_obj, jQueueSecureInputBuffer, args);
-    AndroidBridge::HandleUncaughtException(env);
-    env->PopLocalFrame(nullptr);
-}
-
-void MediaCodec::Release() {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(0) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    env->CallVoidMethod(wrapped_obj, jRelease);
-    AndroidBridge::HandleUncaughtException(env);
-    env->PopLocalFrame(nullptr);
-}
-
-void MediaCodec::ReleaseOutputBuffer(int32_t a0, bool a1) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(0) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    env->CallVoidMethod(wrapped_obj, jReleaseOutputBuffer, a0, a1);
-    AndroidBridge::HandleUncaughtException(env);
-    env->PopLocalFrame(nullptr);
-}
-
-void MediaCodec::SetVideoScalingMode(int32_t a0) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(0) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    env->CallVoidMethod(wrapped_obj, jSetVideoScalingMode, a0);
-    AndroidBridge::HandleUncaughtException(env);
-    env->PopLocalFrame(nullptr);
-}
-
-bool MediaCodec::Start() {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(0) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    env->CallVoidMethod(wrapped_obj, jStart);
-    if (env->ExceptionCheck()) {
-        env->ExceptionClear();
-        env->PopLocalFrame(nullptr);
-        return false;
-    }
-    env->PopLocalFrame(nullptr);
-    return true;
-}
-
-void MediaCodec::Stop() {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(0) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    env->CallVoidMethod(wrapped_obj, jStop);
-    AndroidBridge::HandleUncaughtException(env);
-    env->PopLocalFrame(nullptr);
-}
-
-int32_t MediaCodec::getBUFFER_FLAG_CODEC_CONFIG() {
-    JNIEnv *env = GetJNIForThread();
-    return env->GetStaticIntField(mMediaCodecClass, jBUFFER_FLAG_CODEC_CONFIG);
-}
-
-int32_t MediaCodec::getBUFFER_FLAG_END_OF_STREAM() {
-    JNIEnv *env = GetJNIForThread();
-    return env->GetStaticIntField(mMediaCodecClass, jBUFFER_FLAG_END_OF_STREAM);
-}
-
-int32_t MediaCodec::getBUFFER_FLAG_SYNC_FRAME() {
-    JNIEnv *env = GetJNIForThread();
-    return env->GetStaticIntField(mMediaCodecClass, jBUFFER_FLAG_SYNC_FRAME);
-}
-
-int32_t MediaCodec::getCONFIGURE_FLAG_ENCODE() {
-    JNIEnv *env = GetJNIForThread();
-    return env->GetStaticIntField(mMediaCodecClass, jCONFIGURE_FLAG_ENCODE);
-}
-
-int32_t MediaCodec::getCRYPTO_MODE_AES_CTR() {
-    JNIEnv *env = GetJNIForThread();
-    return env->GetStaticIntField(mMediaCodecClass, jCRYPTO_MODE_AES_CTR);
-}
-
-int32_t MediaCodec::getCRYPTO_MODE_UNENCRYPTED() {
-    JNIEnv *env = GetJNIForThread();
-    return env->GetStaticIntField(mMediaCodecClass, jCRYPTO_MODE_UNENCRYPTED);
-}
-
-int32_t MediaCodec::getINFO_OUTPUT_BUFFERS_CHANGED() {
-    JNIEnv *env = GetJNIForThread();
-    return env->GetStaticIntField(mMediaCodecClass, jINFO_OUTPUT_BUFFERS_CHANGED);
-}
-
-int32_t MediaCodec::getINFO_OUTPUT_FORMAT_CHANGED() {
-    JNIEnv *env = GetJNIForThread();
-    return env->GetStaticIntField(mMediaCodecClass, jINFO_OUTPUT_FORMAT_CHANGED);
-}
-
-int32_t MediaCodec::getINFO_TRY_AGAIN_LATER() {
-    JNIEnv *env = GetJNIForThread();
-    return env->GetStaticIntField(mMediaCodecClass, jINFO_TRY_AGAIN_LATER);
-}
-
-int32_t MediaCodec::getVIDEO_SCALING_MODE_SCALE_TO_FIT() {
-    JNIEnv *env = GetJNIForThread();
-    return env->GetStaticIntField(mMediaCodecClass, jVIDEO_SCALING_MODE_SCALE_TO_FIT);
-}
-
-int32_t MediaCodec::getVIDEO_SCALING_MODE_SCALE_TO_FIT_WITH_CROPPING() {
-    JNIEnv *env = GetJNIForThread();
-    return env->GetStaticIntField(mMediaCodecClass, jVIDEO_SCALING_MODE_SCALE_TO_FIT_WITH_CROPPING);
-}
-jclass MediaFormat::mMediaFormatClass = 0;
-jmethodID MediaFormat::jMediaFormat = 0;
-jmethodID MediaFormat::jContainsKey = 0;
-jmethodID MediaFormat::jCreateAudioFormat = 0;
-jmethodID MediaFormat::jCreateVideoFormat = 0;
-jmethodID MediaFormat::jGetByteBuffer = 0;
-jmethodID MediaFormat::jGetFloat = 0;
-jmethodID MediaFormat::jGetInteger = 0;
-jmethodID MediaFormat::jGetLong = 0;
-jmethodID MediaFormat::jGetString = 0;
-jmethodID MediaFormat::jSetByteBuffer = 0;
-jmethodID MediaFormat::jSetFloat = 0;
-jmethodID MediaFormat::jSetInteger = 0;
-jmethodID MediaFormat::jSetLong = 0;
-jmethodID MediaFormat::jSetString = 0;
-jmethodID MediaFormat::jToString = 0;
-jfieldID MediaFormat::jKEY_AAC_PROFILE = 0;
-jfieldID MediaFormat::jKEY_BIT_RATE = 0;
-jfieldID MediaFormat::jKEY_CHANNEL_COUNT = 0;
-jfieldID MediaFormat::jKEY_CHANNEL_MASK = 0;
-jfieldID MediaFormat::jKEY_COLOR_FORMAT = 0;
-jfieldID MediaFormat::jKEY_DURATION = 0;
-jfieldID MediaFormat::jKEY_FLAC_COMPRESSION_LEVEL = 0;
-jfieldID MediaFormat::jKEY_FRAME_RATE = 0;
-jfieldID MediaFormat::jKEY_HEIGHT = 0;
-jfieldID MediaFormat::jKEY_IS_ADTS = 0;
-jfieldID MediaFormat::jKEY_I_FRAME_INTERVAL = 0;
-jfieldID MediaFormat::jKEY_MAX_INPUT_SIZE = 0;
-jfieldID MediaFormat::jKEY_MIME = 0;
-jfieldID MediaFormat::jKEY_SAMPLE_RATE = 0;
-jfieldID MediaFormat::jKEY_WIDTH = 0;
-void MediaFormat::InitStubs(JNIEnv *jEnv) {
-    initInit();
-
-    mMediaFormatClass = getClassGlobalRef("android/media/MediaFormat");
-    jMediaFormat = getMethod("<init>", "()V");
-    jContainsKey = getMethod("containsKey", "(Ljava/lang/String;)Z");
-    jCreateAudioFormat = getStaticMethod("createAudioFormat", "(Ljava/lang/String;II)Landroid/media/MediaFormat;");
-    jCreateVideoFormat = getStaticMethod("createVideoFormat", "(Ljava/lang/String;II)Landroid/media/MediaFormat;");
-    jGetByteBuffer = getMethod("getByteBuffer", "(Ljava/lang/String;)Ljava/nio/ByteBuffer;");
-    jGetFloat = getMethod("getFloat", "(Ljava/lang/String;)F");
-    jGetInteger = getMethod("getInteger", "(Ljava/lang/String;)I");
-    jGetLong = getMethod("getLong", "(Ljava/lang/String;)J");
-    jGetString = getMethod("getString", "(Ljava/lang/String;)Ljava/lang/String;");
-    jSetByteBuffer = getMethod("setByteBuffer", "(Ljava/lang/String;Ljava/nio/ByteBuffer;)V");
-    jSetFloat = getMethod("setFloat", "(Ljava/lang/String;F)V");
-    jSetInteger = getMethod("setInteger", "(Ljava/lang/String;I)V");
-    jSetLong = getMethod("setLong", "(Ljava/lang/String;J)V");
-    jSetString = getMethod("setString", "(Ljava/lang/String;Ljava/lang/String;)V");
-    jToString = getMethod("toString", "()Ljava/lang/String;");
-    jKEY_AAC_PROFILE = getStaticField("KEY_AAC_PROFILE", "Ljava/lang/String;");
-    jKEY_BIT_RATE = getStaticField("KEY_BIT_RATE", "Ljava/lang/String;");
-    jKEY_CHANNEL_COUNT = getStaticField("KEY_CHANNEL_COUNT", "Ljava/lang/String;");
-    jKEY_CHANNEL_MASK = getStaticField("KEY_CHANNEL_MASK", "Ljava/lang/String;");
-    jKEY_COLOR_FORMAT = getStaticField("KEY_COLOR_FORMAT", "Ljava/lang/String;");
-    jKEY_DURATION = getStaticField("KEY_DURATION", "Ljava/lang/String;");
-    jKEY_FLAC_COMPRESSION_LEVEL = getStaticField("KEY_FLAC_COMPRESSION_LEVEL", "Ljava/lang/String;");
-    jKEY_FRAME_RATE = getStaticField("KEY_FRAME_RATE", "Ljava/lang/String;");
-    jKEY_HEIGHT = getStaticField("KEY_HEIGHT", "Ljava/lang/String;");
-    jKEY_IS_ADTS = getStaticField("KEY_IS_ADTS", "Ljava/lang/String;");
-    jKEY_I_FRAME_INTERVAL = getStaticField("KEY_I_FRAME_INTERVAL", "Ljava/lang/String;");
-    jKEY_MAX_INPUT_SIZE = getStaticField("KEY_MAX_INPUT_SIZE", "Ljava/lang/String;");
-    jKEY_MIME = getStaticField("KEY_MIME", "Ljava/lang/String;");
-    jKEY_SAMPLE_RATE = getStaticField("KEY_SAMPLE_RATE", "Ljava/lang/String;");
-    jKEY_WIDTH = getStaticField("KEY_WIDTH", "Ljava/lang/String;");
-}
-
-MediaFormat* MediaFormat::Wrap(jobject obj) {
-    JNIEnv *env = GetJNIForThread();
-    MediaFormat* ret = new MediaFormat(obj, env);
-    env->DeleteLocalRef(obj);
-    return ret;
-}
-
-MediaFormat::MediaFormat() {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(0) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    Init(env->NewObject(mMediaFormatClass, jMediaFormat), env);
-    env->PopLocalFrame(nullptr);
-}
-
-bool MediaFormat::ContainsKey(const nsAString& a0) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(1) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jstring j0 = AndroidBridge::NewJavaString(env, a0);
-
-    bool temp = env->CallBooleanMethod(wrapped_obj, jContainsKey, j0);
-    AndroidBridge::HandleUncaughtException(env);
-    env->PopLocalFrame(nullptr);
-    return temp;
-}
-
-jobject MediaFormat::CreateAudioFormat(const nsAString& a0, int32_t a1, int32_t a2) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(2) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jvalue args[3];
-    args[0].l = AndroidBridge::NewJavaString(env, a0);
-    args[1].i = a1;
-    args[2].i = a2;
-
-    jobject temp = env->CallStaticObjectMethodA(mMediaFormatClass, jCreateAudioFormat, args);
-    AndroidBridge::HandleUncaughtException(env);
-    jobject ret = static_cast<jobject>(env->PopLocalFrame(temp));
-    return ret;
-}
-
-jobject MediaFormat::CreateVideoFormat(const nsAString& a0, int32_t a1, int32_t a2) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(2) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jvalue args[3];
-    args[0].l = AndroidBridge::NewJavaString(env, a0);
-    args[1].i = a1;
-    args[2].i = a2;
-
-    jobject temp = env->CallStaticObjectMethodA(mMediaFormatClass, jCreateVideoFormat, args);
-    AndroidBridge::HandleUncaughtException(env);
-    jobject ret = static_cast<jobject>(env->PopLocalFrame(temp));
-    return ret;
-}
-
-jobject MediaFormat::GetByteBuffer(const nsAString& a0) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(2) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jstring j0 = AndroidBridge::NewJavaString(env, a0);
-
-    jobject temp = env->CallObjectMethod(wrapped_obj, jGetByteBuffer, j0);
-    AndroidBridge::HandleUncaughtException(env);
-    jobject ret = static_cast<jobject>(env->PopLocalFrame(temp));
-    return ret;
-}
-
-jfloat MediaFormat::GetFloat(const nsAString& a0) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(1) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jstring j0 = AndroidBridge::NewJavaString(env, a0);
-
-    jfloat temp = env->CallFloatMethod(wrapped_obj, jGetFloat, j0);
-    AndroidBridge::HandleUncaughtException(env);
-    env->PopLocalFrame(nullptr);
-    return temp;
-}
-
-int32_t MediaFormat::GetInteger(const nsAString& a0) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(1) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jstring j0 = AndroidBridge::NewJavaString(env, a0);
-
-    int32_t temp = env->CallIntMethod(wrapped_obj, jGetInteger, j0);
-    AndroidBridge::HandleUncaughtException(env);
-    env->PopLocalFrame(nullptr);
-    return temp;
-}
-
-int64_t MediaFormat::GetLong(const nsAString& a0) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(1) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jstring j0 = AndroidBridge::NewJavaString(env, a0);
-
-    int64_t temp = env->CallLongMethod(wrapped_obj, jGetLong, j0);
-    AndroidBridge::HandleUncaughtException(env);
-    env->PopLocalFrame(nullptr);
-    return temp;
-}
-
-jstring MediaFormat::GetString(const nsAString& a0) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(2) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jstring j0 = AndroidBridge::NewJavaString(env, a0);
-
-    jobject temp = env->CallObjectMethod(wrapped_obj, jGetString, j0);
-    AndroidBridge::HandleUncaughtException(env);
-    jstring ret = static_cast<jstring>(env->PopLocalFrame(temp));
-    return ret;
-}
-
-void MediaFormat::SetByteBuffer(const nsAString& a0, jobject a1) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(2) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jstring j0 = AndroidBridge::NewJavaString(env, a0);
-
-    env->CallVoidMethod(wrapped_obj, jSetByteBuffer, j0, a1);
-    AndroidBridge::HandleUncaughtException(env);
-    env->PopLocalFrame(nullptr);
-}
-
-void MediaFormat::SetFloat(const nsAString& a0, jfloat a1) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(1) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jstring j0 = AndroidBridge::NewJavaString(env, a0);
-
-    env->CallVoidMethod(wrapped_obj, jSetFloat, j0, a1);
-    AndroidBridge::HandleUncaughtException(env);
-    env->PopLocalFrame(nullptr);
-}
-
-void MediaFormat::SetInteger(const nsAString& a0, int32_t a1) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(1) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jstring j0 = AndroidBridge::NewJavaString(env, a0);
-
-    env->CallVoidMethod(wrapped_obj, jSetInteger, j0, a1);
-    AndroidBridge::HandleUncaughtException(env);
-    env->PopLocalFrame(nullptr);
-}
-
-void MediaFormat::SetLong(const nsAString& a0, int64_t a1) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(1) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jstring j0 = AndroidBridge::NewJavaString(env, a0);
-
-    env->CallVoidMethod(wrapped_obj, jSetLong, j0, a1);
-    AndroidBridge::HandleUncaughtException(env);
-    env->PopLocalFrame(nullptr);
-}
-
-void MediaFormat::SetString(const nsAString& a0, const nsAString& a1) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(2) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jstring j0 = AndroidBridge::NewJavaString(env, a0);
-    jstring j1 = AndroidBridge::NewJavaString(env, a1);
-
-    env->CallVoidMethod(wrapped_obj, jSetString, j0, j1);
-    AndroidBridge::HandleUncaughtException(env);
-    env->PopLocalFrame(nullptr);
-}
-
-jstring MediaFormat::ToString() {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(1) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jobject temp = env->CallObjectMethod(wrapped_obj, jToString);
-    AndroidBridge::HandleUncaughtException(env);
-    jstring ret = static_cast<jstring>(env->PopLocalFrame(temp));
-    return ret;
-}
-
-jstring MediaFormat::getKEY_AAC_PROFILE() {
-    JNIEnv *env = GetJNIForThread();
-    return static_cast<jstring>(env->GetStaticObjectField(mMediaFormatClass, jKEY_AAC_PROFILE));
-}
-
-jstring MediaFormat::getKEY_BIT_RATE() {
-    JNIEnv *env = GetJNIForThread();
-    return static_cast<jstring>(env->GetStaticObjectField(mMediaFormatClass, jKEY_BIT_RATE));
-}
-
-jstring MediaFormat::getKEY_CHANNEL_COUNT() {
-    JNIEnv *env = GetJNIForThread();
-    return static_cast<jstring>(env->GetStaticObjectField(mMediaFormatClass, jKEY_CHANNEL_COUNT));
-}
-
-jstring MediaFormat::getKEY_CHANNEL_MASK() {
-    JNIEnv *env = GetJNIForThread();
-    return static_cast<jstring>(env->GetStaticObjectField(mMediaFormatClass, jKEY_CHANNEL_MASK));
-}
-
-jstring MediaFormat::getKEY_COLOR_FORMAT() {
-    JNIEnv *env = GetJNIForThread();
-    return static_cast<jstring>(env->GetStaticObjectField(mMediaFormatClass, jKEY_COLOR_FORMAT));
-}
-
-jstring MediaFormat::getKEY_DURATION() {
-    JNIEnv *env = GetJNIForThread();
-    return static_cast<jstring>(env->GetStaticObjectField(mMediaFormatClass, jKEY_DURATION));
-}
-
-jstring MediaFormat::getKEY_FLAC_COMPRESSION_LEVEL() {
-    JNIEnv *env = GetJNIForThread();
-    return static_cast<jstring>(env->GetStaticObjectField(mMediaFormatClass, jKEY_FLAC_COMPRESSION_LEVEL));
-}
-
-jstring MediaFormat::getKEY_FRAME_RATE() {
-    JNIEnv *env = GetJNIForThread();
-    return static_cast<jstring>(env->GetStaticObjectField(mMediaFormatClass, jKEY_FRAME_RATE));
-}
-
-jstring MediaFormat::getKEY_HEIGHT() {
-    JNIEnv *env = GetJNIForThread();
-    return static_cast<jstring>(env->GetStaticObjectField(mMediaFormatClass, jKEY_HEIGHT));
-}
-
-jstring MediaFormat::getKEY_IS_ADTS() {
-    JNIEnv *env = GetJNIForThread();
-    return static_cast<jstring>(env->GetStaticObjectField(mMediaFormatClass, jKEY_IS_ADTS));
-}
-
-jstring MediaFormat::getKEY_I_FRAME_INTERVAL() {
-    JNIEnv *env = GetJNIForThread();
-    return static_cast<jstring>(env->GetStaticObjectField(mMediaFormatClass, jKEY_I_FRAME_INTERVAL));
-}
-
-jstring MediaFormat::getKEY_MAX_INPUT_SIZE() {
-    JNIEnv *env = GetJNIForThread();
-    return static_cast<jstring>(env->GetStaticObjectField(mMediaFormatClass, jKEY_MAX_INPUT_SIZE));
-}
-
-jstring MediaFormat::getKEY_MIME() {
-    JNIEnv *env = GetJNIForThread();
-    return static_cast<jstring>(env->GetStaticObjectField(mMediaFormatClass, jKEY_MIME));
-}
-
-jstring MediaFormat::getKEY_SAMPLE_RATE() {
-    JNIEnv *env = GetJNIForThread();
-    return static_cast<jstring>(env->GetStaticObjectField(mMediaFormatClass, jKEY_SAMPLE_RATE));
-}
-
-jstring MediaFormat::getKEY_WIDTH() {
-    JNIEnv *env = GetJNIForThread();
-    return static_cast<jstring>(env->GetStaticObjectField(mMediaFormatClass, jKEY_WIDTH));
-}
-jclass ByteBuffer::mByteBufferClass = 0;
-jmethodID ByteBuffer::j_get = 0;
-jmethodID ByteBuffer::j_put = 0;
-jmethodID ByteBuffer::jAllocate = 0;
-jmethodID ByteBuffer::jAllocateDirect = 0;
-jmethodID ByteBuffer::jArray = 0;
-jmethodID ByteBuffer::jArray1 = 0;
-jmethodID ByteBuffer::jArrayOffset = 0;
-jmethodID ByteBuffer::jAsCharBuffer = 0;
-jmethodID ByteBuffer::jAsDoubleBuffer = 0;
-jmethodID ByteBuffer::jAsFloatBuffer = 0;
-jmethodID ByteBuffer::jAsIntBuffer = 0;
-jmethodID ByteBuffer::jAsLongBuffer = 0;
-jmethodID ByteBuffer::jAsReadOnlyBuffer = 0;
-jmethodID ByteBuffer::jAsShortBuffer = 0;
-jmethodID ByteBuffer::jCompact = 0;
-jmethodID ByteBuffer::jCompareTo = 0;
-jmethodID ByteBuffer::jCompareTo1 = 0;
-jmethodID ByteBuffer::jDuplicate = 0;
-jmethodID ByteBuffer::jEquals = 0;
-jmethodID ByteBuffer::jGet = 0;
-jmethodID ByteBuffer::jGet1 = 0;
-jmethodID ByteBuffer::jGet10 = 0;
-jmethodID ByteBuffer::jGet11 = 0;
-jmethodID ByteBuffer::jGetChar = 0;
-jmethodID ByteBuffer::jGetChar1 = 0;
-jmethodID ByteBuffer::jGetDouble = 0;
-jmethodID ByteBuffer::jGetDouble1 = 0;
-jmethodID ByteBuffer::jGetFloat = 0;
-jmethodID ByteBuffer::jGetFloat1 = 0;
-jmethodID ByteBuffer::jGetInt = 0;
-jmethodID ByteBuffer::jGetInt1 = 0;
-jmethodID ByteBuffer::jGetLong = 0;
-jmethodID ByteBuffer::jGetLong1 = 0;
-jmethodID ByteBuffer::jGetShort = 0;
-jmethodID ByteBuffer::jGetShort1 = 0;
-jmethodID ByteBuffer::jHasArray = 0;
-jmethodID ByteBuffer::jHashCode = 0;
-jmethodID ByteBuffer::jIsDirect = 0;
-jmethodID ByteBuffer::jOrder = 0;
-jmethodID ByteBuffer::jOrder1 = 0;
-jmethodID ByteBuffer::jPut = 0;
-jmethodID ByteBuffer::jPut1 = 0;
-jmethodID ByteBuffer::jPut12 = 0;
-jmethodID ByteBuffer::jPut13 = 0;
-jmethodID ByteBuffer::jPut14 = 0;
-jmethodID ByteBuffer::jPutChar = 0;
-jmethodID ByteBuffer::jPutChar1 = 0;
-jmethodID ByteBuffer::jPutDouble = 0;
-jmethodID ByteBuffer::jPutDouble1 = 0;
-jmethodID ByteBuffer::jPutFloat = 0;
-jmethodID ByteBuffer::jPutFloat1 = 0;
-jmethodID ByteBuffer::jPutInt = 0;
-jmethodID ByteBuffer::jPutInt1 = 0;
-jmethodID ByteBuffer::jPutLong = 0;
-jmethodID ByteBuffer::jPutLong1 = 0;
-jmethodID ByteBuffer::jPutShort = 0;
-jmethodID ByteBuffer::jPutShort1 = 0;
-jmethodID ByteBuffer::jSlice = 0;
-jmethodID ByteBuffer::jToString = 0;
-jmethodID ByteBuffer::jWrap = 0;
-jmethodID ByteBuffer::jWrap1 = 0;
-jfieldID ByteBuffer::jBigEndian = 0;
-jfieldID ByteBuffer::jHb = 0;
-jfieldID ByteBuffer::jIsReadOnly = 0;
-jfieldID ByteBuffer::jNativeByteOrder = 0;
-jfieldID ByteBuffer::jOffset = 0;
-void ByteBuffer::InitStubs(JNIEnv *jEnv) {
-    initInit();
-
-    mByteBufferClass = getClassGlobalRef("java/nio/ByteBuffer");
-    //j_get = getMethod("_get", "(I)B");
-    //j_put = getMethod("_put", "(IB)V");
-    jAllocate = getStaticMethod("allocate", "(I)Ljava/nio/ByteBuffer;");
-    jAllocateDirect = getStaticMethod("allocateDirect", "(I)Ljava/nio/ByteBuffer;");
-    jArray = getMethod("array", "()Ljava/lang/Object;");
-    jArray1 = getMethod("array", "()[B");
-    jArrayOffset = getMethod("arrayOffset", "()I");
-    jAsCharBuffer = getMethod("asCharBuffer", "()Ljava/nio/CharBuffer;");
-    jAsDoubleBuffer = getMethod("asDoubleBuffer", "()Ljava/nio/DoubleBuffer;");
-    jAsFloatBuffer = getMethod("asFloatBuffer", "()Ljava/nio/FloatBuffer;");
-    jAsIntBuffer = getMethod("asIntBuffer", "()Ljava/nio/IntBuffer;");
-    jAsLongBuffer = getMethod("asLongBuffer", "()Ljava/nio/LongBuffer;");
-    jAsReadOnlyBuffer = getMethod("asReadOnlyBuffer", "()Ljava/nio/ByteBuffer;");
-    jAsShortBuffer = getMethod("asShortBuffer", "()Ljava/nio/ShortBuffer;");
-    jCompact = getMethod("compact", "()Ljava/nio/ByteBuffer;");
-    jCompareTo = getMethod("compareTo", "(Ljava/lang/Object;)I");
-    jCompareTo1 = getMethod("compareTo", "(Ljava/nio/ByteBuffer;)I");
-    jDuplicate = getMethod("duplicate", "()Ljava/nio/ByteBuffer;");
-    jEquals = getMethod("equals", "(Ljava/lang/Object;)Z");
-    jGet = getMethod("get", "()B");
-    jGet1 = getMethod("get", "(I)B");
-    jGet10 = getMethod("get", "([B)Ljava/nio/ByteBuffer;");
-    jGet11 = getMethod("get", "([BII)Ljava/nio/ByteBuffer;");
-    jGetChar = getMethod("getChar", "()C");
-    jGetChar1 = getMethod("getChar", "(I)C");
-    jGetDouble = getMethod("getDouble", "()D");
-    jGetDouble1 = getMethod("getDouble", "(I)D");
-    jGetFloat = getMethod("getFloat", "()F");
-    jGetFloat1 = getMethod("getFloat", "(I)F");
-    jGetInt = getMethod("getInt", "()I");
-    jGetInt1 = getMethod("getInt", "(I)I");
-    jGetLong = getMethod("getLong", "()J");
-    jGetLong1 = getMethod("getLong", "(I)J");
-    jGetShort = getMethod("getShort", "()S");
-    jGetShort1 = getMethod("getShort", "(I)S");
-    jHasArray = getMethod("hasArray", "()Z");
-    jHashCode = getMethod("hashCode", "()I");
-    jIsDirect = getMethod("isDirect", "()Z");
-    jOrder = getMethod("order", "()Ljava/nio/ByteOrder;");
-    jOrder1 = getMethod("order", "(Ljava/nio/ByteOrder;)Ljava/nio/ByteBuffer;");
-    jPut = getMethod("put", "(B)Ljava/nio/ByteBuffer;");
-    jPut1 = getMethod("put", "(IB)Ljava/nio/ByteBuffer;");
-    jPut12 = getMethod("put", "(Ljava/nio/ByteBuffer;)Ljava/nio/ByteBuffer;");
-    jPut13 = getMethod("put", "([B)Ljava/nio/ByteBuffer;");
-    jPut14 = getMethod("put", "([BII)Ljava/nio/ByteBuffer;");
-    jPutChar = getMethod("putChar", "(C)Ljava/nio/ByteBuffer;");
-    jPutChar1 = getMethod("putChar", "(IC)Ljava/nio/ByteBuffer;");
-    jPutDouble = getMethod("putDouble", "(D)Ljava/nio/ByteBuffer;");
-    jPutDouble1 = getMethod("putDouble", "(ID)Ljava/nio/ByteBuffer;");
-    jPutFloat = getMethod("putFloat", "(F)Ljava/nio/ByteBuffer;");
-    jPutFloat1 = getMethod("putFloat", "(IF)Ljava/nio/ByteBuffer;");
-    jPutInt = getMethod("putInt", "(I)Ljava/nio/ByteBuffer;");
-    jPutInt1 = getMethod("putInt", "(II)Ljava/nio/ByteBuffer;");
-    jPutLong = getMethod("putLong", "(IJ)Ljava/nio/ByteBuffer;");
-    jPutLong1 = getMethod("putLong", "(J)Ljava/nio/ByteBuffer;");
-    jPutShort = getMethod("putShort", "(IS)Ljava/nio/ByteBuffer;");
-    jPutShort1 = getMethod("putShort", "(S)Ljava/nio/ByteBuffer;");
-    jSlice = getMethod("slice", "()Ljava/nio/ByteBuffer;");
-    jToString = getMethod("toString", "()Ljava/lang/String;");
-    jWrap = getStaticMethod("wrap", "([B)Ljava/nio/ByteBuffer;");
-    jWrap1 = getStaticMethod("wrap", "([BII)Ljava/nio/ByteBuffer;");
-    /*
-    jBigEndian = getField("bigEndian", "Z");
-    jHb = getField("hb", "[B");
-    jIsReadOnly = getField("isReadOnly", "Z");
-    jNativeByteOrder = getField("nativeByteOrder", "Z");
-    jOffset = getField("offset", "I");
-  */
-}
-
-ByteBuffer* ByteBuffer::Wrap(jobject obj) {
-    JNIEnv *env = GetJNIForThread();
-    ByteBuffer* ret = new ByteBuffer(obj, env);
-    env->DeleteLocalRef(obj);
-    return ret;
-}
-
-int8_t ByteBuffer::_get(int32_t a0) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(0) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    int8_t temp = env->CallByteMethod(wrapped_obj, j_get, a0);
-    AndroidBridge::HandleUncaughtException(env);
-    env->PopLocalFrame(nullptr);
-    return temp;
-}
-
-void ByteBuffer::_put(int32_t a0, int8_t a1) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(0) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    env->CallVoidMethod(wrapped_obj, j_put, a0, a1);
-    AndroidBridge::HandleUncaughtException(env);
-    env->PopLocalFrame(nullptr);
-}
-
-jobject ByteBuffer::Allocate(int32_t a0) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(1) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jobject temp = env->CallStaticObjectMethod(mByteBufferClass, jAllocate, a0);
-    AndroidBridge::HandleUncaughtException(env);
-    jobject ret = static_cast<jobject>(env->PopLocalFrame(temp));
-    return ret;
-}
-
-jobject ByteBuffer::AllocateDirect(int32_t a0) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(1) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jobject temp = env->CallStaticObjectMethod(mByteBufferClass, jAllocateDirect, a0);
-    AndroidBridge::HandleUncaughtException(env);
-    jobject ret = static_cast<jobject>(env->PopLocalFrame(temp));
-    return ret;
-}
-
-jobject ByteBuffer::Array() {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(1) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jobject temp = env->CallObjectMethod(wrapped_obj, jArray);
-    AndroidBridge::HandleUncaughtException(env);
-    jobject ret = static_cast<jobject>(env->PopLocalFrame(temp));
-    return ret;
-}
-
-jbyteArray ByteBuffer::Array1() {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(1) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jobject temp = env->CallObjectMethod(wrapped_obj, jArray1);
-    AndroidBridge::HandleUncaughtException(env);
-    jbyteArray ret = static_cast<jbyteArray>(env->PopLocalFrame(temp));
-    return ret;
-}
-
-int32_t ByteBuffer::ArrayOffset() {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(0) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    int32_t temp = env->CallIntMethod(wrapped_obj, jArrayOffset);
-    AndroidBridge::HandleUncaughtException(env);
-    env->PopLocalFrame(nullptr);
-    return temp;
-}
-
-jstring ByteBuffer::AsCharBuffer() {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(1) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jobject temp = env->CallObjectMethod(wrapped_obj, jAsCharBuffer);
-    AndroidBridge::HandleUncaughtException(env);
-    jstring ret = static_cast<jstring>(env->PopLocalFrame(temp));
-    return ret;
-}
-
-jobject ByteBuffer::AsDoubleBuffer() {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(1) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jobject temp = env->CallObjectMethod(wrapped_obj, jAsDoubleBuffer);
-    AndroidBridge::HandleUncaughtException(env);
-    jobject ret = static_cast<jobject>(env->PopLocalFrame(temp));
-    return ret;
-}
-
-jobject ByteBuffer::AsFloatBuffer() {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(1) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jobject temp = env->CallObjectMethod(wrapped_obj, jAsFloatBuffer);
-    AndroidBridge::HandleUncaughtException(env);
-    jobject ret = static_cast<jobject>(env->PopLocalFrame(temp));
-    return ret;
-}
-
-jobject ByteBuffer::AsIntBuffer() {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(1) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jobject temp = env->CallObjectMethod(wrapped_obj, jAsIntBuffer);
-    AndroidBridge::HandleUncaughtException(env);
-    jobject ret = static_cast<jobject>(env->PopLocalFrame(temp));
-    return ret;
-}
-
-jobject ByteBuffer::AsLongBuffer() {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(1) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jobject temp = env->CallObjectMethod(wrapped_obj, jAsLongBuffer);
-    AndroidBridge::HandleUncaughtException(env);
-    jobject ret = static_cast<jobject>(env->PopLocalFrame(temp));
-    return ret;
-}
-
-jobject ByteBuffer::AsReadOnlyBuffer() {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(1) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jobject temp = env->CallObjectMethod(wrapped_obj, jAsReadOnlyBuffer);
-    AndroidBridge::HandleUncaughtException(env);
-    jobject ret = static_cast<jobject>(env->PopLocalFrame(temp));
-    return ret;
-}
-
-jobject ByteBuffer::AsShortBuffer() {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(1) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jobject temp = env->CallObjectMethod(wrapped_obj, jAsShortBuffer);
-    AndroidBridge::HandleUncaughtException(env);
-    jobject ret = static_cast<jobject>(env->PopLocalFrame(temp));
-    return ret;
-}
-
-jobject ByteBuffer::Compact() {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(1) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jobject temp = env->CallObjectMethod(wrapped_obj, jCompact);
-    AndroidBridge::HandleUncaughtException(env);
-    jobject ret = static_cast<jobject>(env->PopLocalFrame(temp));
-    return ret;
-}
-
-int32_t ByteBuffer::CompareTo(jobject a0) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(1) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    int32_t temp = env->CallIntMethod(wrapped_obj, jCompareTo, a0);
-    AndroidBridge::HandleUncaughtException(env);
-    env->PopLocalFrame(nullptr);
-    return temp;
-}
-
-int32_t ByteBuffer::CompareTo1(jobject a0) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(1) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    int32_t temp = env->CallIntMethod(wrapped_obj, jCompareTo1, a0);
-    AndroidBridge::HandleUncaughtException(env);
-    env->PopLocalFrame(nullptr);
-    return temp;
-}
-
-jobject ByteBuffer::Duplicate() {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(1) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jobject temp = env->CallObjectMethod(wrapped_obj, jDuplicate);
-    AndroidBridge::HandleUncaughtException(env);
-    jobject ret = static_cast<jobject>(env->PopLocalFrame(temp));
-    return ret;
-}
-
-bool ByteBuffer::Equals(jobject a0) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(1) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    bool temp = env->CallBooleanMethod(wrapped_obj, jEquals, a0);
-    AndroidBridge::HandleUncaughtException(env);
-    env->PopLocalFrame(nullptr);
-    return temp;
-}
-
-int8_t ByteBuffer::Get() {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(0) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    int8_t temp = env->CallByteMethod(wrapped_obj, jGet);
-    AndroidBridge::HandleUncaughtException(env);
-    env->PopLocalFrame(nullptr);
-    return temp;
-}
-
-int8_t ByteBuffer::Get1(int32_t a0) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(0) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    int8_t temp = env->CallByteMethod(wrapped_obj, jGet1, a0);
-    AndroidBridge::HandleUncaughtException(env);
-    env->PopLocalFrame(nullptr);
-    return temp;
-}
-
-jobject ByteBuffer::Get1(jbyteArray a0) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(2) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jobject temp = env->CallObjectMethod(wrapped_obj, jGet10, a0);
-    AndroidBridge::HandleUncaughtException(env);
-    jobject ret = static_cast<jobject>(env->PopLocalFrame(temp));
-    return ret;
-}
-
-jobject ByteBuffer::Get1(jbyteArray a0, int32_t a1, int32_t a2) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(2) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jvalue args[3];
-    args[0].l = a0;
-    args[1].i = a1;
-    args[2].i = a2;
-
-    jobject temp = env->CallObjectMethodA(wrapped_obj, jGet11, args);
-    AndroidBridge::HandleUncaughtException(env);
-    jobject ret = static_cast<jobject>(env->PopLocalFrame(temp));
-    return ret;
-}
-
-uint16_t ByteBuffer::GetChar() {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(0) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    uint16_t temp = env->CallCharMethod(wrapped_obj, jGetChar);
-    AndroidBridge::HandleUncaughtException(env);
-    env->PopLocalFrame(nullptr);
-    return temp;
-}
-
-uint16_t ByteBuffer::GetChar1(int32_t a0) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(0) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    uint16_t temp = env->CallCharMethod(wrapped_obj, jGetChar1, a0);
-    AndroidBridge::HandleUncaughtException(env);
-    env->PopLocalFrame(nullptr);
-    return temp;
-}
-
-jdouble ByteBuffer::GetDouble() {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(0) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jdouble temp = env->CallDoubleMethod(wrapped_obj, jGetDouble);
-    AndroidBridge::HandleUncaughtException(env);
-    env->PopLocalFrame(nullptr);
-    return temp;
-}
-
-jdouble ByteBuffer::GetDouble1(int32_t a0) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(0) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jdouble temp = env->CallDoubleMethod(wrapped_obj, jGetDouble1, a0);
-    AndroidBridge::HandleUncaughtException(env);
-    env->PopLocalFrame(nullptr);
-    return temp;
-}
-
-jfloat ByteBuffer::GetFloat() {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(0) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jfloat temp = env->CallFloatMethod(wrapped_obj, jGetFloat);
-    AndroidBridge::HandleUncaughtException(env);
-    env->PopLocalFrame(nullptr);
-    return temp;
-}
-
-jfloat ByteBuffer::GetFloat1(int32_t a0) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(0) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jfloat temp = env->CallFloatMethod(wrapped_obj, jGetFloat1, a0);
-    AndroidBridge::HandleUncaughtException(env);
-    env->PopLocalFrame(nullptr);
-    return temp;
-}
-
-int32_t ByteBuffer::GetInt() {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(0) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    int32_t temp = env->CallIntMethod(wrapped_obj, jGetInt);
-    AndroidBridge::HandleUncaughtException(env);
-    env->PopLocalFrame(nullptr);
-    return temp;
-}
-
-int32_t ByteBuffer::GetInt1(int32_t a0) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(0) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    int32_t temp = env->CallIntMethod(wrapped_obj, jGetInt1, a0);
-    AndroidBridge::HandleUncaughtException(env);
-    env->PopLocalFrame(nullptr);
-    return temp;
-}
-
-int64_t ByteBuffer::GetLong() {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(0) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    int64_t temp = env->CallLongMethod(wrapped_obj, jGetLong);
-    AndroidBridge::HandleUncaughtException(env);
-    env->PopLocalFrame(nullptr);
-    return temp;
-}
-
-int64_t ByteBuffer::GetLong1(int32_t a0) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(0) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    int64_t temp = env->CallLongMethod(wrapped_obj, jGetLong1, a0);
-    AndroidBridge::HandleUncaughtException(env);
-    env->PopLocalFrame(nullptr);
-    return temp;
-}
-
-int16_t ByteBuffer::GetShort() {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(0) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    int16_t temp = env->CallShortMethod(wrapped_obj, jGetShort);
-    AndroidBridge::HandleUncaughtException(env);
-    env->PopLocalFrame(nullptr);
-    return temp;
-}
-
-int16_t ByteBuffer::GetShort1(int32_t a0) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(0) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    int16_t temp = env->CallShortMethod(wrapped_obj, jGetShort1, a0);
-    AndroidBridge::HandleUncaughtException(env);
-    env->PopLocalFrame(nullptr);
-    return temp;
-}
-
-bool ByteBuffer::HasArray() {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(0) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    bool temp = env->CallBooleanMethod(wrapped_obj, jHasArray);
-    AndroidBridge::HandleUncaughtException(env);
-    env->PopLocalFrame(nullptr);
-    return temp;
-}
-
-int32_t ByteBuffer::HashCode() {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(0) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    int32_t temp = env->CallIntMethod(wrapped_obj, jHashCode);
-    AndroidBridge::HandleUncaughtException(env);
-    env->PopLocalFrame(nullptr);
-    return temp;
-}
-
-bool ByteBuffer::IsDirect() {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(0) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    bool temp = env->CallBooleanMethod(wrapped_obj, jIsDirect);
-    AndroidBridge::HandleUncaughtException(env);
-    env->PopLocalFrame(nullptr);
-    return temp;
-}
-
-jobject ByteBuffer::Order() {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(1) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jobject temp = env->CallObjectMethod(wrapped_obj, jOrder);
-    AndroidBridge::HandleUncaughtException(env);
-    jobject ret = static_cast<jobject>(env->PopLocalFrame(temp));
-    return ret;
-}
-
-jobject ByteBuffer::Order1(jobject a0) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(2) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jobject temp = env->CallObjectMethod(wrapped_obj, jOrder1, a0);
-    AndroidBridge::HandleUncaughtException(env);
-    jobject ret = static_cast<jobject>(env->PopLocalFrame(temp));
-    return ret;
-}
-
-jobject ByteBuffer::Put(int8_t a0) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(1) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jobject temp = env->CallObjectMethod(wrapped_obj, jPut, a0);
-    AndroidBridge::HandleUncaughtException(env);
-    jobject ret = static_cast<jobject>(env->PopLocalFrame(temp));
-    return ret;
-}
-
-jobject ByteBuffer::Put1(int32_t a0, int8_t a1) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(1) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jobject temp = env->CallObjectMethod(wrapped_obj, jPut1, a0, a1);
-    AndroidBridge::HandleUncaughtException(env);
-    jobject ret = static_cast<jobject>(env->PopLocalFrame(temp));
-    return ret;
-}
-
-jobject ByteBuffer::Put1(jobject a0) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(2) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jobject temp = env->CallObjectMethod(wrapped_obj, jPut12, a0);
-    AndroidBridge::HandleUncaughtException(env);
-    jobject ret = static_cast<jobject>(env->PopLocalFrame(temp));
-    return ret;
-}
-
-jobject ByteBuffer::Put1(jbyteArray a0) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(2) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jobject temp = env->CallObjectMethod(wrapped_obj, jPut13, a0);
-    AndroidBridge::HandleUncaughtException(env);
-    jobject ret = static_cast<jobject>(env->PopLocalFrame(temp));
-    return ret;
-}
-
-jobject ByteBuffer::Put1(jbyteArray a0, int32_t a1, int32_t a2) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(2) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jvalue args[3];
-    args[0].l = a0;
-    args[1].i = a1;
-    args[2].i = a2;
-
-    jobject temp = env->CallObjectMethodA(wrapped_obj, jPut14, args);
-    AndroidBridge::HandleUncaughtException(env);
-    jobject ret = static_cast<jobject>(env->PopLocalFrame(temp));
-    return ret;
-}
-
-jobject ByteBuffer::PutChar(uint16_t a0) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(1) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jobject temp = env->CallObjectMethod(wrapped_obj, jPutChar, a0);
-    AndroidBridge::HandleUncaughtException(env);
-    jobject ret = static_cast<jobject>(env->PopLocalFrame(temp));
-    return ret;
-}
-
-jobject ByteBuffer::PutChar1(int32_t a0, uint16_t a1) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(1) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jobject temp = env->CallObjectMethod(wrapped_obj, jPutChar1, a0, a1);
-    AndroidBridge::HandleUncaughtException(env);
-    jobject ret = static_cast<jobject>(env->PopLocalFrame(temp));
-    return ret;
-}
-
-jobject ByteBuffer::PutDouble(jdouble a0) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(1) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jobject temp = env->CallObjectMethod(wrapped_obj, jPutDouble, a0);
-    AndroidBridge::HandleUncaughtException(env);
-    jobject ret = static_cast<jobject>(env->PopLocalFrame(temp));
-    return ret;
-}
-
-jobject ByteBuffer::PutDouble1(int32_t a0, jdouble a1) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(1) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jobject temp = env->CallObjectMethod(wrapped_obj, jPutDouble1, a0, a1);
-    AndroidBridge::HandleUncaughtException(env);
-    jobject ret = static_cast<jobject>(env->PopLocalFrame(temp));
-    return ret;
-}
-
-jobject ByteBuffer::PutFloat(jfloat a0) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(1) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jobject temp = env->CallObjectMethod(wrapped_obj, jPutFloat, a0);
-    AndroidBridge::HandleUncaughtException(env);
-    jobject ret = static_cast<jobject>(env->PopLocalFrame(temp));
-    return ret;
-}
-
-jobject ByteBuffer::PutFloat1(int32_t a0, jfloat a1) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(1) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jobject temp = env->CallObjectMethod(wrapped_obj, jPutFloat1, a0, a1);
-    AndroidBridge::HandleUncaughtException(env);
-    jobject ret = static_cast<jobject>(env->PopLocalFrame(temp));
-    return ret;
-}
-
-jobject ByteBuffer::PutInt(int32_t a0) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(1) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jobject temp = env->CallObjectMethod(wrapped_obj, jPutInt, a0);
-    AndroidBridge::HandleUncaughtException(env);
-    jobject ret = static_cast<jobject>(env->PopLocalFrame(temp));
-    return ret;
-}
-
-jobject ByteBuffer::PutInt1(int32_t a0, int32_t a1) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(1) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jobject temp = env->CallObjectMethod(wrapped_obj, jPutInt1, a0, a1);
-    AndroidBridge::HandleUncaughtException(env);
-    jobject ret = static_cast<jobject>(env->PopLocalFrame(temp));
-    return ret;
-}
-
-jobject ByteBuffer::PutLong(int32_t a0, int64_t a1) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(1) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jobject temp = env->CallObjectMethod(wrapped_obj, jPutLong, a0, a1);
-    AndroidBridge::HandleUncaughtException(env);
-    jobject ret = static_cast<jobject>(env->PopLocalFrame(temp));
-    return ret;
-}
-
-jobject ByteBuffer::PutLong1(int64_t a0) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(1) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jobject temp = env->CallObjectMethod(wrapped_obj, jPutLong1, a0);
-    AndroidBridge::HandleUncaughtException(env);
-    jobject ret = static_cast<jobject>(env->PopLocalFrame(temp));
-    return ret;
-}
-
-jobject ByteBuffer::PutShort(int32_t a0, int16_t a1) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(1) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jobject temp = env->CallObjectMethod(wrapped_obj, jPutShort, a0, a1);
-    AndroidBridge::HandleUncaughtException(env);
-    jobject ret = static_cast<jobject>(env->PopLocalFrame(temp));
-    return ret;
-}
-
-jobject ByteBuffer::PutShort1(int16_t a0) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(1) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jobject temp = env->CallObjectMethod(wrapped_obj, jPutShort1, a0);
-    AndroidBridge::HandleUncaughtException(env);
-    jobject ret = static_cast<jobject>(env->PopLocalFrame(temp));
-    return ret;
-}
-
-jobject ByteBuffer::Slice() {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(1) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jobject temp = env->CallObjectMethod(wrapped_obj, jSlice);
-    AndroidBridge::HandleUncaughtException(env);
-    jobject ret = static_cast<jobject>(env->PopLocalFrame(temp));
-    return ret;
-}
-
-jstring ByteBuffer::ToString() {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(1) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jobject temp = env->CallObjectMethod(wrapped_obj, jToString);
-    AndroidBridge::HandleUncaughtException(env);
-    jstring ret = static_cast<jstring>(env->PopLocalFrame(temp));
-    return ret;
-}
-
-jobject ByteBuffer::Wrap1(jbyteArray a0) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(2) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jobject temp = env->CallStaticObjectMethod(mByteBufferClass, jWrap, a0);
-    AndroidBridge::HandleUncaughtException(env);
-    jobject ret = static_cast<jobject>(env->PopLocalFrame(temp));
-    return ret;
-}
-
-jobject ByteBuffer::Wrap2(jbyteArray a0, int32_t a1, int32_t a2) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(2) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jvalue args[3];
-    args[0].l = a0;
-    args[1].i = a1;
-    args[2].i = a2;
-
-    jobject temp = env->CallStaticObjectMethodA(mByteBufferClass, jWrap1, args);
-    AndroidBridge::HandleUncaughtException(env);
-    jobject ret = static_cast<jobject>(env->PopLocalFrame(temp));
-    return ret;
-}
-
-bool ByteBuffer::getBigEndian() {
-    JNIEnv *env = GetJNIForThread();
-    return env->GetBooleanField(wrapped_obj, jBigEndian);
-}
-
-void ByteBuffer::setBigEndian(bool a0) {
-    JNIEnv *env = GetJNIForThread();
-    env->SetBooleanField(wrapped_obj, jBigEndian, a0);
-}
-
-jbyteArray ByteBuffer::getHb() {
-    JNIEnv *env = GetJNIForThread();
-    return static_cast<jbyteArray>(env->GetObjectField(wrapped_obj, jHb));
-}
-
-bool ByteBuffer::getIsReadOnly() {
-    JNIEnv *env = GetJNIForThread();
-    return env->GetBooleanField(wrapped_obj, jIsReadOnly);
-}
-
-void ByteBuffer::setIsReadOnly(bool a0) {
-    JNIEnv *env = GetJNIForThread();
-    env->SetBooleanField(wrapped_obj, jIsReadOnly, a0);
-}
-
-bool ByteBuffer::getNativeByteOrder() {
-    JNIEnv *env = GetJNIForThread();
-    return env->GetBooleanField(wrapped_obj, jNativeByteOrder);
-}
-
-void ByteBuffer::setNativeByteOrder(bool a0) {
-    JNIEnv *env = GetJNIForThread();
-    env->SetBooleanField(wrapped_obj, jNativeByteOrder, a0);
-}
-
-int32_t ByteBuffer::getOffset() {
-    JNIEnv *env = GetJNIForThread();
-    return env->GetIntField(wrapped_obj, jOffset);
-}
-
-jclass BufferInfo::mBufferInfoClass = 0;
-jmethodID BufferInfo::jBufferInfo = 0;
-jmethodID BufferInfo::jSet = 0;
-jfieldID BufferInfo::jFlags = 0;
-jfieldID BufferInfo::jOffset = 0;
-jfieldID BufferInfo::jPresentationTimeUs = 0;
-jfieldID BufferInfo::jSize = 0;
-void BufferInfo::InitStubs(JNIEnv *jEnv) {
-    initInit();
-
-    mBufferInfoClass = getClassGlobalRef("android/media/MediaCodec$BufferInfo");
-    jBufferInfo = getMethod("<init>", "()V");
-    jSet = getMethod("set", "(IIJI)V");
-    jFlags = getField("flags", "I");
-    jOffset = getField("offset", "I");
-    jPresentationTimeUs = getField("presentationTimeUs", "J");
-    jSize = getField("size", "I");
-}
-
-BufferInfo* BufferInfo::Wrap(jobject obj) {
-    JNIEnv *env = GetJNIForThread();
-    BufferInfo* ret = new BufferInfo(obj, env);
-    env->DeleteLocalRef(obj);
-    return ret;
-}
-
-BufferInfo::BufferInfo() {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(0) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    Init(env->NewObject(mBufferInfoClass, jBufferInfo), env);
-    env->PopLocalFrame(nullptr);
-}
-
-void BufferInfo::Set(int32_t a0, int32_t a1, int64_t a2, int32_t a3) {
-    JNIEnv *env = GetJNIForThread();
-    if (env->PushLocalFrame(0) != 0) {
-        AndroidBridge::HandleUncaughtException(env);
-        MOZ_CRASH("Exception should have caused crash.");
-    }
-
-    jvalue args[4];
-    args[0].i = a0;
-    args[1].i = a1;
-    args[2].j = a2;
-    args[3].i = a3;
-
-    env->CallVoidMethodA(wrapped_obj, jSet, args);
-    AndroidBridge::HandleUncaughtException(env);
-    env->PopLocalFrame(nullptr);
-}
-
-int32_t BufferInfo::getFlags() {
-    JNIEnv *env = GetJNIForThread();
-    return env->GetIntField(wrapped_obj, jFlags);
-}
-
-void BufferInfo::setFlags(int32_t a0) {
-    JNIEnv *env = GetJNIForThread();
-    env->SetIntField(wrapped_obj, jFlags, a0);
-}
-
-int32_t BufferInfo::getOffset() {
-    JNIEnv *env = GetJNIForThread();
-    return env->GetIntField(wrapped_obj, jOffset);
-}
-
-void BufferInfo::setOffset(int32_t a0) {
-    JNIEnv *env = GetJNIForThread();
-    env->SetIntField(wrapped_obj, jOffset, a0);
-}
-
-int64_t BufferInfo::getPresentationTimeUs() {
-    JNIEnv *env = GetJNIForThread();
-    return env->GetLongField(wrapped_obj, jPresentationTimeUs);
-}
-
-void BufferInfo::setPresentationTimeUs(int64_t a0) {
-    JNIEnv *env = GetJNIForThread();
-    env->SetLongField(wrapped_obj, jPresentationTimeUs, a0);
-}
-
-int32_t BufferInfo::getSize() {
-    JNIEnv *env = GetJNIForThread();
-    return env->GetIntField(wrapped_obj, jSize);
-}
-
-void BufferInfo::setSize(int32_t a0) {
-    JNIEnv *env = GetJNIForThread();
-    env->SetIntField(wrapped_obj, jSize, a0);
-}
-
-void InitSDKStubs(JNIEnv *jEnv) {
-    MediaCodec::InitStubs(jEnv);
-    MediaFormat::InitStubs(jEnv);
-    ByteBuffer::InitStubs(jEnv);
-    BufferInfo::InitStubs(jEnv);
-}
-} /* android */
-} /* widget */
-} /* mozilla */
deleted file mode 100644
--- a/widget/android/GeneratedSDKWrappers.h
+++ /dev/null
@@ -1,335 +0,0 @@
-// GENERATED CODE
-
-// NOTE: This code has been doctored. The JarClassProcessor is still a work in progress,
-// and so additions and deletions have been made to make this file valid.
-
-// Generated by the Java program at /build/jarClassProcessors at compile time from
-// a given set of jars and a set of requested methods. To update, change the annotations
-// on the corresponding Java methods and rerun the build. Manually updating this file
-// will cause your build to fail.
-
-#ifndef GeneratedSDKWrappers_h__
-#define GeneratedSDKWrappers_h__
-
-#include "nsXPCOMStrings.h"
-#include "AndroidJavaWrappers.h"
-
-namespace mozilla {
-namespace widget {
-namespace android {
-
-#define MEDIACODEC_EXCEPTION_INDEX -255
-
-void InitSDKStubs(JNIEnv *jEnv);
-
-class MediaCodec : public AutoGlobalWrappedJavaObject {
-public:
-    static void InitStubs(JNIEnv *jEnv);
-    static MediaCodec* Wrap(jobject obj);
-    MediaCodec(jobject obj, JNIEnv* env) : AutoGlobalWrappedJavaObject(obj, env) {};
-    bool Configure(jobject a0, jobject a1, jobject a2, int32_t a3);
-    static jobject CreateByCodecName(const nsAString& a0);
-    static jobject CreateDecoderByType(const nsAString& a0);
-    static jobject CreateEncoderByType(const nsAString& a0);
-    int32_t DequeueInputBuffer(int64_t a0);
-    int32_t DequeueOutputBuffer(jobject a0, int64_t a1);
-    void Finalize();
-    void Flush();
-    jobjectArray GetInputBuffers();
-    jobjectArray GetOutputBuffers();
-    jobject GetOutputFormat();
-    void QueueInputBuffer(int32_t a0, int32_t a1, int32_t a2, int64_t a3, int32_t a4);
-    void QueueSecureInputBuffer(int32_t a0, int32_t a1, jobject a2, int64_t a3, int32_t a4);
-    void Release();
-    void ReleaseOutputBuffer(int32_t a0, bool a1);
-    void SetVideoScalingMode(int32_t a0);
-    bool Start();
-    void Stop();
-    static int32_t getBUFFER_FLAG_CODEC_CONFIG();
-    static int32_t getBUFFER_FLAG_END_OF_STREAM();
-    static int32_t getBUFFER_FLAG_SYNC_FRAME();
-    static int32_t getCONFIGURE_FLAG_ENCODE();
-    static int32_t getCRYPTO_MODE_AES_CTR();
-    static int32_t getCRYPTO_MODE_UNENCRYPTED();
-    static int32_t getINFO_OUTPUT_BUFFERS_CHANGED();
-    static int32_t getINFO_OUTPUT_FORMAT_CHANGED();
-    static int32_t getINFO_TRY_AGAIN_LATER();
-    static int32_t getVIDEO_SCALING_MODE_SCALE_TO_FIT();
-    static int32_t getVIDEO_SCALING_MODE_SCALE_TO_FIT_WITH_CROPPING();
-    MediaCodec() : AutoGlobalWrappedJavaObject() {};
-protected:
-    static jclass mMediaCodecClass;
-    static jmethodID jConfigure;
-    static jmethodID jCreateByCodecName;
-    static jmethodID jCreateDecoderByType;
-    static jmethodID jCreateEncoderByType;
-    static jmethodID jDequeueInputBuffer;
-    static jmethodID jDequeueOutputBuffer;
-    static jmethodID jFinalize;
-    static jmethodID jFlush;
-    static jmethodID jGetInputBuffers;
-    static jmethodID jGetOutputBuffers;
-    static jmethodID jGetOutputFormat;
-    static jmethodID jQueueInputBuffer;
-    static jmethodID jQueueSecureInputBuffer;
-    static jmethodID jRelease;
-    static jmethodID jReleaseOutputBuffer;
-    static jmethodID jSetVideoScalingMode;
-    static jmethodID jStart;
-    static jmethodID jStop;
-    static jfieldID jBUFFER_FLAG_CODEC_CONFIG;
-    static jfieldID jBUFFER_FLAG_END_OF_STREAM;
-    static jfieldID jBUFFER_FLAG_SYNC_FRAME;
-    static jfieldID jCONFIGURE_FLAG_ENCODE;
-    static jfieldID jCRYPTO_MODE_AES_CTR;
-    static jfieldID jCRYPTO_MODE_UNENCRYPTED;
-    static jfieldID jINFO_OUTPUT_BUFFERS_CHANGED;
-    static jfieldID jINFO_OUTPUT_FORMAT_CHANGED;
-    static jfieldID jINFO_TRY_AGAIN_LATER;
-    static jfieldID jVIDEO_SCALING_MODE_SCALE_TO_FIT;
-    static jfieldID jVIDEO_SCALING_MODE_SCALE_TO_FIT_WITH_CROPPING;
-};
-
-class MediaFormat : public AutoGlobalWrappedJavaObject {
-public:
-    static void InitStubs(JNIEnv *jEnv);
-    static MediaFormat* Wrap(jobject obj);
-    MediaFormat(jobject obj, JNIEnv* env) : AutoGlobalWrappedJavaObject(obj, env) {};
-    MediaFormat();
-    bool ContainsKey(const nsAString& a0);
-    static jobject CreateAudioFormat(const nsAString& a0, int32_t a1, int32_t a2);
-    static jobject CreateVideoFormat(const nsAString& a0, int32_t a1, int32_t a2);
-    jobject GetByteBuffer(const nsAString& a0);
-    jfloat GetFloat(const nsAString& a0);
-    int32_t GetInteger(const nsAString& a0);
-    int64_t GetLong(const nsAString& a0);
-    jstring GetString(const nsAString& a0);
-    void SetByteBuffer(const nsAString& a0, jobject a1);
-    void SetFloat(const nsAString& a0, jfloat a1);
-    void SetInteger(const nsAString& a0, int32_t a1);
-    void SetLong(const nsAString& a0, int64_t a1);
-    void SetString(const nsAString& a0, const nsAString& a1);
-    jstring ToString();
-    static jstring getKEY_AAC_PROFILE();
-    static jstring getKEY_BIT_RATE();
-    static jstring getKEY_CHANNEL_COUNT();
-    static jstring getKEY_CHANNEL_MASK();
-    static jstring getKEY_COLOR_FORMAT();
-    static jstring getKEY_DURATION();
-    static jstring getKEY_FLAC_COMPRESSION_LEVEL();
-    static jstring getKEY_FRAME_RATE();
-    static jstring getKEY_HEIGHT();
-    static jstring getKEY_IS_ADTS();
-    static jstring getKEY_I_FRAME_INTERVAL();
-    static jstring getKEY_MAX_INPUT_SIZE();
-    static jstring getKEY_MIME();
-    static jstring getKEY_SAMPLE_RATE();
-    static jstring getKEY_WIDTH();
-protected:
-    static jclass mMediaFormatClass;
-    static jmethodID jMediaFormat;
-    static jmethodID jContainsKey;
-    static jmethodID jCreateAudioFormat;
-    static jmethodID jCreateVideoFormat;
-    static jmethodID jGetByteBuffer;
-    static jmethodID jGetFloat;
-    static jmethodID jGetInteger;
-    static jmethodID jGetLong;
-    static jmethodID jGetString;
-    static jmethodID jSetByteBuffer;
-    static jmethodID jSetFloat;
-    static jmethodID jSetInteger;
-    static jmethodID jSetLong;
-    static jmethodID jSetString;
-    static jmethodID jToString;
-    static jfieldID jKEY_AAC_PROFILE;
-    static jfieldID jKEY_BIT_RATE;
-    static jfieldID jKEY_CHANNEL_COUNT;
-    static jfieldID jKEY_CHANNEL_MASK;
-    static jfieldID jKEY_COLOR_FORMAT;
-    static jfieldID jKEY_DURATION;
-    static jfieldID jKEY_FLAC_COMPRESSION_LEVEL;
-    static jfieldID jKEY_FRAME_RATE;
-    static jfieldID jKEY_HEIGHT;
-    static jfieldID jKEY_IS_ADTS;
-    static jfieldID jKEY_I_FRAME_INTERVAL;
-    static jfieldID jKEY_MAX_INPUT_SIZE;
-    static jfieldID jKEY_MIME;
-    static jfieldID jKEY_SAMPLE_RATE;
-    static jfieldID jKEY_WIDTH;
-};
-
-class ByteBuffer : public AutoGlobalWrappedJavaObject {
-public:
-    static void InitStubs(JNIEnv *jEnv);
-    static ByteBuffer* Wrap(jobject obj);
-    ByteBuffer(jobject obj, JNIEnv* env) : AutoGlobalWrappedJavaObject(obj, env) {};
-    int8_t _get(int32_t a0);
-    void _put(int32_t a0, int8_t a1);
-    static jobject Allocate(int32_t a0);
-    static jobject AllocateDirect(int32_t a0);
-    jobject Array();
-    jbyteArray Array1();
-    int32_t ArrayOffset();
-    jstring AsCharBuffer();
-    jobject AsDoubleBuffer();
-    jobject AsFloatBuffer();
-    jobject AsIntBuffer();
-    jobject AsLongBuffer();
-    jobject AsReadOnlyBuffer();
-    jobject AsShortBuffer();
-    jobject Compact();
-    int32_t CompareTo(jobject a0);
-    int32_t CompareTo1(jobject a0);
-    jobject Duplicate();
-    bool Equals(jobject a0);
-    int8_t Get();
-    int8_t Get1(int32_t a0);
-    jobject Get1(jbyteArray a0);
-    jobject Get1(jbyteArray a0, int32_t a1, int32_t a2);
-    uint16_t GetChar();
-    uint16_t GetChar1(int32_t a0);
-    jdouble GetDouble();
-    jdouble GetDouble1(int32_t a0);
-    jfloat GetFloat();
-    jfloat GetFloat1(int32_t a0);
-    int32_t GetInt();
-    int32_t GetInt1(int32_t a0);
-    int64_t GetLong();
-    int64_t GetLong1(int32_t a0);
-    int16_t GetShort();
-    int16_t GetShort1(int32_t a0);
-    bool HasArray();
-    int32_t HashCode();
-    bool IsDirect();
-    jobject Order();
-    jobject Order1(jobject a0);
-    jobject Put(int8_t a0);
-    jobject Put1(int32_t a0, int8_t a1);
-    jobject Put1(jobject a0);
-    jobject Put1(jbyteArray a0);
-    jobject Put1(jbyteArray a0, int32_t a1, int32_t a2);
-    jobject PutChar(uint16_t a0);
-    jobject PutChar1(int32_t a0, uint16_t a1);
-    jobject PutDouble(jdouble a0);
-    jobject PutDouble1(int32_t a0, jdouble a1);
-    jobject PutFloat(jfloat a0);
-    jobject PutFloat1(int32_t a0, jfloat a1);
-    jobject PutInt(int32_t a0);
-    jobject PutInt1(int32_t a0, int32_t a1);
-    jobject PutLong(int32_t a0, int64_t a1);
-    jobject PutLong1(int64_t a0);
-    jobject PutShort(int32_t a0, int16_t a1);
-    jobject PutShort1(int16_t a0);
-    jobject Slice();
-    jstring ToString();
-    static jobject Wrap1(jbyteArray a0);
-    static jobject Wrap2(jbyteArray a0, int32_t a1, int32_t a2);
-    bool getBigEndian();
-    void setBigEndian(bool a0);
-    jbyteArray getHb();
-    bool getIsReadOnly();
-    void setIsReadOnly(bool a0);
-    bool getNativeByteOrder();
-    void setNativeByteOrder(bool a0);
-    int32_t getOffset();
-    ByteBuffer() : AutoGlobalWrappedJavaObject() {};
-protected:
-    static jclass mByteBufferClass;
-    static jmethodID j_get;
-    static jmethodID j_put;
-    static jmethodID jAllocate;
-    static jmethodID jAllocateDirect;
-    static jmethodID jArray;
-    static jmethodID jArray1;
-    static jmethodID jArrayOffset;
-    static jmethodID jAsCharBuffer;
-    static jmethodID jAsDoubleBuffer;
-    static jmethodID jAsFloatBuffer;
-    static jmethodID jAsIntBuffer;
-    static jmethodID jAsLongBuffer;
-    static jmethodID jAsReadOnlyBuffer;
-    static jmethodID jAsShortBuffer;
-    static jmethodID jCompact;
-    static jmethodID jCompareTo;
-    static jmethodID jCompareTo1;
-    static jmethodID jDuplicate;
-    static jmethodID jEquals;
-    static jmethodID jGet;
-    static jmethodID jGet1;
-    static jmethodID jGet10;
-    static jmethodID jGet11;
-    static jmethodID jGetChar;
-    static jmethodID jGetChar1;
-    static jmethodID jGetDouble;
-    static jmethodID jGetDouble1;
-    static jmethodID jGetFloat;
-    static jmethodID jGetFloat1;
-    static jmethodID jGetInt;
-    static jmethodID jGetInt1;
-    static jmethodID jGetLong;
-    static jmethodID jGetLong1;
-    static jmethodID jGetShort;
-    static jmethodID jGetShort1;
-    static jmethodID jHasArray;
-    static jmethodID jHashCode;
-    static jmethodID jIsDirect;
-    static jmethodID jOrder;
-    static jmethodID jOrder1;
-    static jmethodID jPut;
-    static jmethodID jPut1;
-    static jmethodID jPut12;
-    static jmethodID jPut13;
-    static jmethodID jPut14;
-    static jmethodID jPutChar;
-    static jmethodID jPutChar1;
-    static jmethodID jPutDouble;
-    static jmethodID jPutDouble1;
-    static jmethodID jPutFloat;
-    static jmethodID jPutFloat1;
-    static jmethodID jPutInt;
-    static jmethodID jPutInt1;
-    static jmethodID jPutLong;
-    static jmethodID jPutLong1;
-    static jmethodID jPutShort;
-    static jmethodID jPutShort1;
-    static jmethodID jSlice;
-    static jmethodID jToString;
-    static jmethodID jWrap;
-    static jmethodID jWrap1;
-    static jfieldID jBigEndian;
-    static jfieldID jHb;
-    static jfieldID jIsReadOnly;
-    static jfieldID jNativeByteOrder;
-    static jfieldID jOffset;
-};
-
-class BufferInfo : public AutoGlobalWrappedJavaObject {
-public:
-    static void InitStubs(JNIEnv *jEnv);
-    static BufferInfo* Wrap(jobject obj);
-    BufferInfo(jobject obj, JNIEnv* env) : AutoGlobalWrappedJavaObject(obj, env) {};
-    BufferInfo();
-    void Set(int32_t a0, int32_t a1, int64_t a2, int32_t a3);
-    int32_t getFlags();
-    void setFlags(int32_t a0);
-    int32_t getOffset();
-    void setOffset(int32_t a0);
-    int64_t getPresentationTimeUs();
-    void setPresentationTimeUs(int64_t a0);
-    int32_t getSize();
-    void setSize(int32_t a0);
-protected:
-    static jclass mBufferInfoClass;
-    static jmethodID jBufferInfo;
-    static jmethodID jSet;
-    static jfieldID jFlags;
-    static jfieldID jOffset;
-    static jfieldID jPresentationTimeUs;
-    static jfieldID jSize;
-};
-
-} /* android */
-} /* widget */
-} /* mozilla */
-#endif
--- a/widget/android/moz.build
+++ b/widget/android/moz.build
@@ -14,29 +14,27 @@ XPIDL_SOURCES += [
 
 XPIDL_MODULE = 'widget_android'
 
 EXPORTS += [
     'AndroidBridge.h',
     'AndroidJavaWrappers.h',
     'AndroidJNIWrapper.h',
     'GeneratedJNIWrappers.h',
-    'GeneratedSDKWrappers.h',
 ]
 
 SOURCES += [
     'AndroidBridge.cpp',
     'AndroidDirectTexture.cpp',
     'AndroidGraphicBuffer.cpp',
     'AndroidJavaWrappers.cpp',
     'AndroidJNI.cpp',
     'AndroidJNIWrapper.cpp',
     'APZCCallbackHandler.cpp',
     'GeneratedJNIWrappers.cpp',
-    'GeneratedSDKWrappers.cpp',
     'GfxInfo.cpp',
     'NativeJSContainer.cpp',
     'nsAndroidProtocolHandler.cpp',
     'nsAppShell.cpp',
     'nsClipboard.cpp',
     'nsDeviceContextAndroid.cpp',
     'nsIdleServiceAndroid.cpp',
     'nsIMEPicker.cpp',