Pass JavaRef to Java methods in media.

Update code in media to use JavaRef when calling Java methods via JNI,
instead of passing bar jobject. Various function parameter types are
converted from jobject to JavaRef to enable calls to obj() higher up the
call chain to be removed.

BUG=506850

Cq-Include-Trybots: master.tryserver.chromium.android:android_optional_gpu_tests_rel;master.tryserver.chromium.linux:linux_optional_gpu_tests_rel;master.tryserver.chromium.mac:mac_optional_gpu_tests_rel;master.tryserver.chromium.win:win_optional_gpu_tests_rel
Change-Id: I3ea85d7934655549e1f04feaf885f249cb9019c4
Reviewed-on: https://chromium-review.googlesource.com/585627Reviewed-by: Dale Curtis <dalecurtis@chromium.org>
Commit-Queue: Richard Coles <torne@chromium.org>
Cr-Commit-Position: refs/heads/master@{#490799}

media/audio/android/audio_manager_android.cc

@@ -28,6 +28,7 @@ using base::android::AttachCurrentThread;
 using base::android::ConvertJavaStringToUTF8;
 using base::android::ConvertUTF8ToJavaString;
 using base::android::JavaParamRef;
+using base::android::JavaRef;
 using base::android::ScopedJavaLocalRef;
 
 namespace media {
@@ -369,7 +370,7 @@ bool AudioManagerAndroid::HasNoAudioInputStreams() {
   return input_stream_count() == 0;
 }
 
-jobject AudioManagerAndroid::GetJavaAudioManager() {
+const JavaRef<jobject>& AudioManagerAndroid::GetJavaAudioManager() {
   DCHECK(GetTaskRunner()->BelongsToCurrentThread());
   if (j_audio_manager_.is_null()) {
     // Create the Android audio manager on the audio thread.
@@ -383,7 +384,7 @@ jobject AudioManagerAndroid::GetJavaAudioManager() {
     Java_AudioManagerAndroid_init(base::android::AttachCurrentThread(),
                                   j_audio_manager_);
   }
-  return j_audio_manager_.obj();
+  return j_audio_manager_;
 }
 
 void AudioManagerAndroid::SetCommunicationAudioModeOn(bool on) {

media/audio/android/audio_manager_android.h

@@ -90,7 +90,7 @@ class MEDIA_EXPORT AudioManagerAndroid : public AudioManagerBase {
       const AudioParameters& input_params) override;
 
  private:
-  jobject GetJavaAudioManager();
+  const base::android::JavaRef<jobject>& GetJavaAudioManager();
   bool HasNoAudioInputStreams();
   void SetCommunicationAudioModeOn(bool on);
   bool SetAudioDevice(const std::string& device_id);

media/base/android/media_codec_bridge.h

@@ -12,6 +12,7 @@
 #include <vector>
 
 #include "base/android/jni_android.h"
+#include "base/android/scoped_java_ref.h"
 #include "base/macros.h"
 #include "base/time/time.h"
 #include "media/base/media_export.h"
@@ -134,7 +135,7 @@ class MEDIA_EXPORT MediaCodecBridge {
 
   // Changes the output surface for the MediaCodec. May only be used on API
   // level 23 and higher (Marshmallow).
-  virtual bool SetSurface(jobject surface) = 0;
+  virtual bool SetSurface(const base::android::JavaRef<jobject>& surface) = 0;
 
   // Sets the video encoder target bitrate and framerate.
   virtual void SetVideoBitrate(int bps, int frame_rate) = 0;

media/base/android/media_codec_bridge_impl.cc

@@ -28,6 +28,7 @@ using base::android::AttachCurrentThread;
 using base::android::ConvertJavaStringToUTF8;
 using base::android::ConvertUTF8ToJavaString;
 using base::android::JavaIntArrayToIntVector;
+using base::android::JavaRef;
 using base::android::ScopedJavaLocalRef;
 
 #define RETURN_ON_ERROR(condition)                             \
@@ -48,7 +49,7 @@ enum {
 };
 
 // Parses |extra_data| and sets the appropriate fields of the given MediaFormat.
-bool ConfigureMediaFormatForAudio(jobject j_format,
+bool ConfigureMediaFormatForAudio(const JavaRef<jobject>& j_format,
                                   AudioCodec codec,
                                   const uint8_t* extra_data,
                                   size_t extra_data_size,
@@ -183,9 +184,9 @@ bool ConfigureMediaFormatForAudio(jobject j_format,
 // static
 std::unique_ptr<MediaCodecBridge> MediaCodecBridgeImpl::CreateAudioDecoder(
     const AudioDecoderConfig& config,
-    jobject media_crypto) {
+    const JavaRef<jobject>& media_crypto) {
   DVLOG(2) << __func__ << ": " << config.AsHumanReadableString()
-           << " media_crypto:" << media_crypto;
+           << " media_crypto:" << media_crypto.obj();
 
   if (!MediaCodecUtil::IsMediaCodecAvailable())
     return nullptr;
@@ -217,7 +218,7 @@ std::unique_ptr<MediaCodecBridge> MediaCodecBridgeImpl::CreateAudioDecoder(
   const int64_t seek_preroll_ns = config.seek_preroll().InMicroseconds() *
                                   base::Time::kNanosecondsPerMicrosecond;
   if (!ConfigureMediaFormatForAudio(
-          j_format.obj(), config.codec(), config.extra_data().data(),
+          j_format, config.codec(), config.extra_data().data(),
           config.extra_data().size(), codec_delay_ns, seek_preroll_ns)) {
     return nullptr;
   }
@@ -235,8 +236,8 @@ std::unique_ptr<MediaCodecBridge> MediaCodecBridgeImpl::CreateVideoDecoder(
     VideoCodec codec,
     CodecType codec_type,
     const gfx::Size& size,
-    jobject surface,
-    jobject media_crypto,
+    const JavaRef<jobject>& surface,
+    const JavaRef<jobject>& media_crypto,
     const std::vector<uint8_t>& csd0,
     const std::vector<uint8_t>& csd1,
     bool allow_adaptive_playback) {
@@ -458,9 +459,8 @@ MediaCodecStatus MediaCodecBridgeImpl::QueueSecureInputBuffer(
 
   return static_cast<MediaCodecStatus>(
       Java_MediaCodecBridge_queueSecureInputBuffer(
-          env, j_bridge_.obj(), index, 0, j_iv.obj(), j_key_id.obj(),
-          clear_array, cypher_array, num_subsamples,
-          static_cast<int>(encryption_scheme.mode()),
+          env, j_bridge_, index, 0, j_iv, j_key_id, clear_array, cypher_array,
+          num_subsamples, static_cast<int>(encryption_scheme.mode()),
           static_cast<int>(encryption_scheme.pattern().encrypt_blocks()),
           static_cast<int>(encryption_scheme.pattern().skip_blocks()),
           presentation_time.InMicroseconds()));
@@ -584,7 +584,7 @@ std::string MediaCodecBridgeImpl::GetName() {
   return ConvertJavaStringToUTF8(env, j_name);
 }
 
-bool MediaCodecBridgeImpl::SetSurface(jobject surface) {
+bool MediaCodecBridgeImpl::SetSurface(const JavaRef<jobject>& surface) {
   DCHECK_GE(base::android::BuildInfo::GetInstance()->sdk_int(), 23);
   JNIEnv* env = AttachCurrentThread();
   return Java_MediaCodecBridge_setSurface(env, j_bridge_, surface);

media/base/android/media_codec_bridge_impl.h

@@ -38,8 +38,10 @@ class MEDIA_EXPORT MediaCodecBridgeImpl : public MediaCodecBridge {
       VideoCodec codec,
       CodecType codec_type,
       const gfx::Size& size,  // Output frame size.
-      jobject surface,        // Output surface, optional.
-      jobject media_crypto,   // MediaCrypto object, optional.
+      const base::android::JavaRef<jobject>&
+          surface,  // Output surface, optional.
+      const base::android::JavaRef<jobject>&
+          media_crypto,  // MediaCrypto object, optional.
       // Codec specific data. See MediaCodec docs.
       const std::vector<uint8_t>& csd0,
       const std::vector<uint8_t>& csd1,
@@ -60,7 +62,7 @@ class MEDIA_EXPORT MediaCodecBridgeImpl : public MediaCodecBridge {
   // nullptr on failure.
   static std::unique_ptr<MediaCodecBridge> CreateAudioDecoder(
       const AudioDecoderConfig& config,
-      jobject media_crypto);
+      const base::android::JavaRef<jobject>& media_crypto);
 
   ~MediaCodecBridgeImpl() override;
 
@@ -103,7 +105,7 @@ class MEDIA_EXPORT MediaCodecBridgeImpl : public MediaCodecBridge {
                                         void* dst,
                                         size_t num) override;
   std::string GetName() override;
-  bool SetSurface(jobject surface) override;
+  bool SetSurface(const base::android::JavaRef<jobject>& surface) override;
   void SetVideoBitrate(int bps, int frame_rate) override;
   void RequestKeyFrameSoon() override;
   bool IsAdaptivePlaybackSupported() override;

media/base/android/media_codec_util.cc

@@ -50,7 +50,7 @@ const char kVp9MimeType[] = "video/x-vnd.on2.vp9";
 
 static CodecProfileLevel MediaCodecProfileLevelToChromiumProfileLevel(
     JNIEnv* env,
-    const jobject& j_codec_profile_level) {
+    const JavaRef<jobject>& j_codec_profile_level) {
   VideoCodec codec = static_cast<VideoCodec>(
       Java_CodecProfileLevelAdapter_getCodec(env, j_codec_profile_level));
   VideoCodecProfile profile = static_cast<VideoCodecProfile>(
@@ -258,8 +258,8 @@ bool MediaCodecUtil::AddSupportedCodecProfileLevels(
       Java_MediaCodecUtil_getSupportedCodecProfileLevels(env));
   int java_array_length = env->GetArrayLength(j_codec_profile_levels.obj());
   for (int i = 0; i < java_array_length; ++i) {
-    const jobject& java_codec_profile_level =
-        env->GetObjectArrayElement(j_codec_profile_levels.obj(), i);
+    ScopedJavaLocalRef<jobject> java_codec_profile_level(
+        env, env->GetObjectArrayElement(j_codec_profile_levels.obj(), i));
     result->push_back(MediaCodecProfileLevelToChromiumProfileLevel(
         env, java_codec_profile_level));
   }

media/base/android/media_drm_storage_bridge.cc

@@ -97,14 +97,14 @@ void MediaDrmStorageBridge::OnSaveInfo(
   DCHECK(impl_);
   std::vector<uint8_t> key_set_id;
   JavaByteArrayToByteVector(
-      env, Java_PersistentInfo_keySetId(env, j_persist_info.obj()).obj(),
+      env, Java_PersistentInfo_keySetId(env, j_persist_info).obj(),
       &key_set_id);
 
   std::string mime = ConvertJavaStringToUTF8(
-      env, Java_PersistentInfo_mimeType(env, j_persist_info.obj()));
+      env, Java_PersistentInfo_mimeType(env, j_persist_info));
 
   std::string session_id = JavaBytesToString(
-      env, Java_PersistentInfo_emeId(env, j_persist_info.obj()).obj());
+      env, Java_PersistentInfo_emeId(env, j_persist_info).obj());
 
   task_runner_->PostTask(
       FROM_HERE,

media/base/android/mock_media_codec_bridge.h

@@ -5,6 +5,7 @@
 #ifndef MEDIA_BASE_ANDROID_MOCK_MEDIA_CODEC_BRIDGE_H_
 #define MEDIA_BASE_ANDROID_MOCK_MEDIA_CODEC_BRIDGE_H_
 
+#include "base/android/scoped_java_ref.h"
 #include "media/base/android/media_codec_bridge.h"
 #include "media/base/android/test_destruction_observable.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ -56,7 +57,8 @@ class MockMediaCodecBridge : public MediaCodecBridge,
       CopyFromOutputBuffer,
       MediaCodecStatus(int index, size_t offset, void* dst, size_t num));
   MOCK_METHOD0(GetName, std::string());
-  MOCK_METHOD1(SetSurface, bool(jobject surface));
+  MOCK_METHOD1(SetSurface,
+               bool(const base::android::JavaRef<jobject>& surface));
   MOCK_METHOD2(SetVideoBitrate, void(int bps, int frame_rate));
   MOCK_METHOD0(RequestKeyFrameSoon, void());
   MOCK_METHOD0(IsAdaptivePlaybackSupported, bool());

media/capture/content/android/screen_capture_machine_android.cc

@@ -11,6 +11,7 @@
 #include "third_party/libyuv/include/libyuv.h"
 
 using base::android::AttachCurrentThread;
+using base::android::JavaRef;
 using base::android::ScopedJavaLocalRef;
 
 namespace media {
@@ -32,15 +33,16 @@ ScreenCaptureMachineAndroid::createScreenCaptureMachineAndroid(
       AttachCurrentThread(), nativeScreenCaptureMachineAndroid));
 }
 
-void ScreenCaptureMachineAndroid::OnRGBAFrameAvailable(JNIEnv* env,
-                                                       jobject obj,
-                                                       jobject buf,
-                                                       jint row_stride,
-                                                       jint left,
-                                                       jint top,
-                                                       jint width,
-                                                       jint height,
-                                                       jlong timestamp) {
+void ScreenCaptureMachineAndroid::OnRGBAFrameAvailable(
+    JNIEnv* env,
+    const JavaRef<jobject>& obj,
+    const JavaRef<jobject>& buf,
+    jint row_stride,
+    jint left,
+    jint top,
+    jint width,
+    jint height,
+    jlong timestamp) {
   const VideoCaptureOracle::Event event = VideoCaptureOracle::kCompositorUpdate;
   const uint64_t absolute_micro =
       timestamp / base::Time::kNanosecondsPerMicrosecond;
@@ -66,7 +68,7 @@ void ScreenCaptureMachineAndroid::OnRGBAFrameAvailable(JNIEnv* env,
   }
 
   uint8_t* const src =
-      reinterpret_cast<uint8_t*>(env->GetDirectBufferAddress(buf));
+      reinterpret_cast<uint8_t*>(env->GetDirectBufferAddress(buf.obj()));
   CHECK(src);
 
   const int offset = top * row_stride + left * 4;
@@ -103,19 +105,20 @@ void ScreenCaptureMachineAndroid::OnRGBAFrameAvailable(JNIEnv* env,
   lastFrame_ = frame;
 }
 
-void ScreenCaptureMachineAndroid::OnI420FrameAvailable(JNIEnv* env,
-                                                       jobject obj,
-                                                       jobject y_buffer,
-                                                       jint y_stride,
-                                                       jobject u_buffer,
-                                                       jobject v_buffer,
-                                                       jint uv_row_stride,
-                                                       jint uv_pixel_stride,
-                                                       jint left,
-                                                       jint top,
-                                                       jint width,
-                                                       jint height,
-                                                       jlong timestamp) {
+void ScreenCaptureMachineAndroid::OnI420FrameAvailable(
+    JNIEnv* env,
+    const JavaRef<jobject>& obj,
+    const JavaRef<jobject>& y_buffer,
+    jint y_stride,
+    const JavaRef<jobject>& u_buffer,
+    const JavaRef<jobject>& v_buffer,
+    jint uv_row_stride,
+    jint uv_pixel_stride,
+    jint left,
+    jint top,
+    jint width,
+    jint height,
+    jlong timestamp) {
   const VideoCaptureOracle::Event event = VideoCaptureOracle::kCompositorUpdate;
   const uint64_t absolute_micro =
       timestamp / base::Time::kNanosecondsPerMicrosecond;
@@ -141,13 +144,13 @@ void ScreenCaptureMachineAndroid::OnI420FrameAvailable(JNIEnv* env,
   }
 
   uint8_t* const y_src =
-      reinterpret_cast<uint8_t*>(env->GetDirectBufferAddress(y_buffer));
+      reinterpret_cast<uint8_t*>(env->GetDirectBufferAddress(y_buffer.obj()));
   CHECK(y_src);
   uint8_t* u_src =
-      reinterpret_cast<uint8_t*>(env->GetDirectBufferAddress(u_buffer));
+      reinterpret_cast<uint8_t*>(env->GetDirectBufferAddress(u_buffer.obj()));
   CHECK(u_src);
   uint8_t* v_src =
-      reinterpret_cast<uint8_t*>(env->GetDirectBufferAddress(v_buffer));
+      reinterpret_cast<uint8_t*>(env->GetDirectBufferAddress(v_buffer.obj()));
   CHECK(v_src);
 
   const int y_offset = top * y_stride + left;
@@ -187,7 +190,7 @@ void ScreenCaptureMachineAndroid::OnI420FrameAvailable(JNIEnv* env,
 }
 
 void ScreenCaptureMachineAndroid::OnActivityResult(JNIEnv* env,
-                                                   jobject obj,
+                                                   const JavaRef<jobject>& obj,
                                                    jboolean result) {
   if (!result) {
     oracle_proxy_->ReportError(FROM_HERE, "The user denied screen capture");
@@ -200,9 +203,10 @@ void ScreenCaptureMachineAndroid::OnActivityResult(JNIEnv* env,
     oracle_proxy_->ReportError(FROM_HERE, "Failed to start Screen Capture");
 }
 
-void ScreenCaptureMachineAndroid::OnOrientationChange(JNIEnv* env,
-                                                      jobject obj,
-                                                      jint rotation) {
+void ScreenCaptureMachineAndroid::OnOrientationChange(
+    JNIEnv* env,
+    const JavaRef<jobject>& obj,
+    jint rotation) {
   DeviceOrientation orientation = kDefault;
   switch (rotation) {
     case 0:

media/capture/content/android/screen_capture_machine_android.h

@@ -26,8 +26,8 @@ class CAPTURE_EXPORT ScreenCaptureMachineAndroid : public VideoCaptureMachine {
 
   // Implement org.chromium.media.ScreenCapture.nativeOnRGBAFrameAvailable.
   void OnRGBAFrameAvailable(JNIEnv* env,
-                            jobject obj,
-                            jobject buf,
+                            const base::android::JavaRef<jobject>& obj,
+                            const base::android::JavaRef<jobject>& buf,
                             jint row_stride,
                             jint left,
                             jint top,
@@ -36,11 +36,11 @@ class CAPTURE_EXPORT ScreenCaptureMachineAndroid : public VideoCaptureMachine {
                             jlong timestamp);
   // Implement org.chromium.media.ScreenCapture.nativeOnI420FrameAvailable.
   void OnI420FrameAvailable(JNIEnv* env,
-                            jobject obj,
-                            jobject y_buffer,
+                            const base::android::JavaRef<jobject>& obj,
+                            const base::android::JavaRef<jobject>& y_buffer,
                             jint y_stride,
-                            jobject u_buffer,
-                            jobject v_buffer,
+                            const base::android::JavaRef<jobject>& u_buffer,
+                            const base::android::JavaRef<jobject>& v_buffer,
                             jint uv_row_stride,
                             jint uv_pixel_stride,
                             jint left,
@@ -50,10 +50,14 @@ class CAPTURE_EXPORT ScreenCaptureMachineAndroid : public VideoCaptureMachine {
                             jlong timestamp);
 
   // Implement org.chromium.media.ScreenCapture.nativeOnActivityResult.
-  void OnActivityResult(JNIEnv* env, jobject obj, jboolean result);
+  void OnActivityResult(JNIEnv* env,
+                        const base::android::JavaRef<jobject>& obj,
+                        jboolean result);
 
   // Implement org.chromium.media.ScreenCaptuer.nativeOnOrientationChange.
-  void OnOrientationChange(JNIEnv* env, jobject obj, jint rotation);
+  void OnOrientationChange(JNIEnv* env,
+                           const base::android::JavaRef<jobject>& obj,
+                           jint rotation);
 
   // VideoCaptureMachine overrides.
   void Start(const scoped_refptr<media::ThreadSafeCaptureOracle>& oracle_proxy,

media/filters/android/media_codec_audio_decoder.cc

@@ -130,9 +130,10 @@ bool MediaCodecAudioDecoder::CreateMediaCodecLoop() {
   DVLOG(1) << __func__ << ": config:" << config_.AsHumanReadableString();
 
   codec_loop_.reset();
-  jobject media_crypto_obj = media_crypto_ ? media_crypto_->obj() : nullptr;
+  const base::android::JavaRef<jobject>& media_crypto =
+      media_crypto_ ? *media_crypto_ : nullptr;
   std::unique_ptr<MediaCodecBridge> audio_codec_bridge(
-      MediaCodecBridgeImpl::CreateAudioDecoder(config_, media_crypto_obj));
+      MediaCodecBridgeImpl::CreateAudioDecoder(config_, media_crypto));
   if (!audio_codec_bridge) {
     DLOG(ERROR) << __func__ << " failed: cannot create MediaCodecBridge";
     return false;

media/gpu/android_video_decode_accelerator.cc

@@ -500,7 +500,7 @@ void AndroidVideoDecodeAccelerator::InitializePictureBufferManager() {
   // If we get here with a codec, then we must setSurface.
   if (media_codec_) {
     // TODO(liberato): fail on api check?
-    if (!media_codec_->SetSurface(incoming_bundle_->GetJavaSurface().obj())) {
+    if (!media_codec_->SetSurface(incoming_bundle_->GetJavaSurface())) {
       NOTIFY_ERROR(PLATFORM_FAILURE, "MediaCodec failed to switch surfaces.");
       // We're not going to use |incoming_bundle_|.
     } else {

media/gpu/avda_codec_allocator.cc

@@ -40,11 +40,11 @@ std::unique_ptr<MediaCodecBridge> CreateMediaCodecInternal(
     bool requires_software_codec) {
   TRACE_EVENT0("media", "CreateMediaCodecInternal");
 
-  jobject media_crypto =
-      codec_config->media_crypto ? codec_config->media_crypto->obj() : nullptr;
+  const base::android::JavaRef<jobject>& media_crypto =
+      codec_config->media_crypto ? *codec_config->media_crypto : nullptr;
 
   // |requires_secure_codec| implies that it's an encrypted stream.
-  DCHECK(!codec_config->requires_secure_codec || media_crypto);
+  DCHECK(!codec_config->requires_secure_codec || !media_crypto.is_null());
 
   CodecType codec_type = CodecType::kAny;
   if (codec_config->requires_secure_codec && requires_software_codec) {
@@ -60,7 +60,7 @@ std::unique_ptr<MediaCodecBridge> CreateMediaCodecInternal(
       MediaCodecBridgeImpl::CreateVideoDecoder(
           codec_config->codec, codec_type,
           codec_config->initial_expected_coded_size,
-          codec_config->surface_bundle->GetJavaSurface().obj(), media_crypto,
+          codec_config->surface_bundle->GetJavaSurface(), media_crypto,
           codec_config->csd0, codec_config->csd1, true));
 
   return codec;

media/midi/midi_device_android.cc

@@ -11,6 +11,7 @@
 #include "jni/MidiDeviceAndroid_jni.h"
 #include "media/midi/midi_output_port_android.h"
 
+using base::android::JavaRef;
 using base::android::ScopedJavaLocalRef;
 
 namespace midi {
@@ -26,9 +27,9 @@ std::string ConvertMaybeJavaString(JNIEnv* env,
 }
 
 MidiDeviceAndroid::MidiDeviceAndroid(JNIEnv* env,
-                                     jobject raw_device,
+                                     const JavaRef<jobject>& raw_device,
                                      MidiInputPortAndroid::Delegate* delegate)
-    : raw_device_(env, raw_device) {
+    : raw_device_(raw_device) {
   ScopedJavaLocalRef<jobjectArray> raw_input_ports =
       Java_MidiDeviceAndroid_getInputPorts(env, raw_device);
   jsize num_input_ports = env->GetArrayLength(raw_input_ports.obj());

media/midi/midi_device_android.h

@@ -20,7 +20,7 @@ class MidiOutputPortAndroid;
 class MidiDeviceAndroid final {
  public:
   MidiDeviceAndroid(JNIEnv* env,
-                    jobject raw_device,
+                    const base::android::JavaRef<jobject>& raw_device,
                     MidiInputPortAndroid::Delegate* delegate);
   ~MidiDeviceAndroid();
 

media/midi/midi_manager_android.cc

@@ -132,7 +132,8 @@ void MidiManagerAndroid::OnInitialized(
   jsize length = env->GetArrayLength(devices);
 
   for (jsize i = 0; i < length; ++i) {
-    jobject raw_device = env->GetObjectArrayElement(devices, i);
+    base::android::ScopedJavaLocalRef<jobject> raw_device(
+        env, env->GetObjectArrayElement(devices, i));
     AddDevice(base::MakeUnique<MidiDeviceAndroid>(env, raw_device, this));
   }
   CompleteInitialization(Result::OK);