Replaced eglbase_jni with with holding a EglBase in PeerConnectionFactory.

webrtc/api/java/jni/androidmediaencoder_jni.cc

 /*
  *  Copyright 2015 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 1146 matching lines @@
 }
 
 int MediaCodecVideoEncoder::GetTargetFramerate() {
   return scale_ ? quality_scaler_.GetTargetFramerate() : -1;
 }
 
 const char* MediaCodecVideoEncoder::ImplementationName() const {
   return "MediaCodec";
 }
 
-MediaCodecVideoEncoderFactory::MediaCodecVideoEncoderFactory() {
+MediaCodecVideoEncoderFactory::MediaCodecVideoEncoderFactory()
+    : egl_context_(nullptr) {
   JNIEnv* jni = AttachCurrentThreadIfNeeded();
   ScopedLocalRefFrame local_ref_frame(jni);
   jclass j_encoder_class = FindClass(jni, "org/webrtc/MediaCodecVideoEncoder");
   supported_codecs_.clear();
 
   bool is_vp8_hw_supported = jni->CallStaticBooleanMethod(
       j_encoder_class,
       GetStaticMethodID(jni, j_encoder_class, "isVp8HwSupported", "()Z"));
   CHECK_EXCEPTION(jni);
   if (is_vp8_hw_supported) {
@@ skipping 18 matching lines @@
   CHECK_EXCEPTION(jni);
   if (is_h264_hw_supported) {
     ALOGD << "H.264 HW Encoder supported.";
     supported_codecs_.push_back(VideoCodec(kVideoCodecH264, "H264",
         MAX_VIDEO_WIDTH, MAX_VIDEO_HEIGHT, MAX_VIDEO_FPS));
   }
 }
 
 MediaCodecVideoEncoderFactory::~MediaCodecVideoEncoderFactory() {
   ALOGD << "MediaCodecVideoEncoderFactory dtor";
+  if (egl_context_) {
+    JNIEnv* jni = AttachCurrentThreadIfNeeded();
+    jni->DeleteGlobalRef(egl_context_);
+  }
 }
 
 void MediaCodecVideoEncoderFactory::SetEGLContext(
-    JNIEnv* jni, jobject render_egl_context) {
+    JNIEnv* jni, jobject egl_context) {
   ALOGD << "MediaCodecVideoEncoderFactory::SetEGLContext";
-  if (!egl_base_.CreateEglBase(jni, render_egl_context)) {
-    ALOGW << "Invalid EGL context - HW surface encoding is disabled.";
+  RTC_DCHECK(!egl_context_);
+  egl_context_ = jni->NewGlobalRef(egl_context);
+  if (CheckException(jni)) {
+    ALOGE << "error calling NewGlobalRef for EGL Context.";
   }
 }
 
 webrtc::VideoEncoder* MediaCodecVideoEncoderFactory::CreateVideoEncoder(
     VideoCodecType type) {
   if (supported_codecs_.empty()) {
     ALOGW << "No HW video encoder for type " << (int)type;
     return nullptr;
   }
   for (std::vector<VideoCodec>::const_iterator it = supported_codecs_.begin();
          it != supported_codecs_.end(); ++it) {
     if (it->type == type) {
       ALOGD << "Create HW video encoder for type " << (int)type <<
           " (" << it->name << ").";
       return new MediaCodecVideoEncoder(AttachCurrentThreadIfNeeded(), type,
-          egl_base_.egl_base_context());
+                                        egl_context_);
     }
   }
   ALOGW << "Can not find HW video encoder for type " << (int)type;
   return nullptr;
 }
 
 const std::vector<MediaCodecVideoEncoderFactory::VideoCodec>&
 MediaCodecVideoEncoderFactory::codecs() const {
   return supported_codecs_;
 }
 
 void MediaCodecVideoEncoderFactory::DestroyVideoEncoder(
     webrtc::VideoEncoder* encoder) {
   ALOGD << "Destroy video encoder.";
   delete encoder;
 }
 
 }  // namespace webrtc_jni