Remove now-unnecessary .obj() in Java method calls.

media/base/android/sdk_media_codec_bridge.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/base/android/sdk_media_codec_bridge.h"
 
 #include <algorithm>
 #include <limits>
 #include <memory>
 #include <utility>
@@ skipping 71 matching lines @@
 
 SdkMediaCodecBridge::SdkMediaCodecBridge(const std::string& mime,
                                          bool is_secure,
                                          MediaCodecDirection direction,
                                          bool require_software_codec) {
   JNIEnv* env = AttachCurrentThread();
   CHECK(env);
   DCHECK(!mime.empty());
   ScopedJavaLocalRef<jstring> j_mime = ConvertUTF8ToJavaString(env, mime);
   j_media_codec_.Reset(Java_MediaCodecBridge_create(
-      env, j_mime.obj(), is_secure, direction, require_software_codec));
+      env, j_mime, is_secure, direction, require_software_codec));
 }
 
 SdkMediaCodecBridge::~SdkMediaCodecBridge() {
   JNIEnv* env = AttachCurrentThread();
   CHECK(env);
   if (j_media_codec_.obj())
-    Java_MediaCodecBridge_release(env, j_media_codec_.obj());
+    Java_MediaCodecBridge_release(env, j_media_codec_);
 }
 
 bool SdkMediaCodecBridge::Start() {
   JNIEnv* env = AttachCurrentThread();
-  return Java_MediaCodecBridge_start(env, j_media_codec_.obj());
+  return Java_MediaCodecBridge_start(env, j_media_codec_);
 }
 
 void SdkMediaCodecBridge::Stop() {
   JNIEnv* env = AttachCurrentThread();
-  Java_MediaCodecBridge_stop(env, j_media_codec_.obj());
+  Java_MediaCodecBridge_stop(env, j_media_codec_);
 }
 
 MediaCodecStatus SdkMediaCodecBridge::Flush() {
   JNIEnv* env = AttachCurrentThread();
   return static_cast<MediaCodecStatus>(
-      Java_MediaCodecBridge_flush(env, j_media_codec_.obj()));
+      Java_MediaCodecBridge_flush(env, j_media_codec_));
 }
 
 MediaCodecStatus SdkMediaCodecBridge::GetOutputSize(gfx::Size* size) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> result =
-      Java_MediaCodecBridge_getOutputFormat(env, j_media_codec_.obj());
+      Java_MediaCodecBridge_getOutputFormat(env, j_media_codec_);
   MediaCodecStatus status = static_cast<MediaCodecStatus>(
-      Java_GetOutputFormatResult_status(env, result.obj()));
+      Java_GetOutputFormatResult_status(env, result));
   if (status == MEDIA_CODEC_OK) {
-    size->SetSize(Java_GetOutputFormatResult_width(env, result.obj()),
-                  Java_GetOutputFormatResult_height(env, result.obj()));
+    size->SetSize(Java_GetOutputFormatResult_width(env, result),
+                  Java_GetOutputFormatResult_height(env, result));
   }
   return status;
 }
 
 MediaCodecStatus SdkMediaCodecBridge::GetOutputSamplingRate(
     int* sampling_rate) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> result =
-      Java_MediaCodecBridge_getOutputFormat(env, j_media_codec_.obj());
+      Java_MediaCodecBridge_getOutputFormat(env, j_media_codec_);
   MediaCodecStatus status = static_cast<MediaCodecStatus>(
-      Java_GetOutputFormatResult_status(env, result.obj()));
+      Java_GetOutputFormatResult_status(env, result));
   if (status == MEDIA_CODEC_OK)
-    *sampling_rate = Java_GetOutputFormatResult_sampleRate(env, result.obj());
+    *sampling_rate = Java_GetOutputFormatResult_sampleRate(env, result);
   return status;
 }
 
 MediaCodecStatus SdkMediaCodecBridge::GetOutputChannelCount(
     int* channel_count) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> result =
-      Java_MediaCodecBridge_getOutputFormat(env, j_media_codec_.obj());
+      Java_MediaCodecBridge_getOutputFormat(env, j_media_codec_);
   MediaCodecStatus status = static_cast<MediaCodecStatus>(
-      Java_GetOutputFormatResult_status(env, result.obj()));
+      Java_GetOutputFormatResult_status(env, result));
   if (status == MEDIA_CODEC_OK)
-    *channel_count = Java_GetOutputFormatResult_channelCount(env, result.obj());
+    *channel_count = Java_GetOutputFormatResult_channelCount(env, result);
   return status;
 }
 
 MediaCodecStatus SdkMediaCodecBridge::QueueInputBuffer(
     int index,
     const uint8_t* data,
     size_t data_size,
     base::TimeDelta presentation_time) {
   DVLOG(3) << __PRETTY_FUNCTION__ << index << ": " << data_size;
   if (data_size >
       base::checked_cast<size_t>(std::numeric_limits<int32_t>::max())) {
     return MEDIA_CODEC_ERROR;
   }
   if (data && !FillInputBuffer(index, data, data_size))
     return MEDIA_CODEC_ERROR;
   JNIEnv* env = AttachCurrentThread();
   return static_cast<MediaCodecStatus>(Java_MediaCodecBridge_queueInputBuffer(
-      env, j_media_codec_.obj(), index, 0, data_size,
+      env, j_media_codec_, index, 0, data_size,
       presentation_time.InMicroseconds(), 0));
 }
 
 // TODO(timav): Combine this and above methods together keeping only the first
 // interface after we switch to Spitzer pipeline.
 MediaCodecStatus SdkMediaCodecBridge::QueueSecureInputBuffer(
     int index,
     const uint8_t* data,
     size_t data_size,
     const std::vector<char>& key_id,
@@ skipping 44 matching lines @@
   }
 
   ScopedJavaLocalRef<jintArray> clear_array =
       ToJavaIntArray(env, std::move(native_clear_array), new_subsamples_size);
   ScopedJavaLocalRef<jintArray> cypher_array =
       ToJavaIntArray(env, std::move(native_cypher_array), new_subsamples_size);
 
   return static_cast<MediaCodecStatus>(
       Java_MediaCodecBridge_queueSecureInputBuffer(
           env, j_media_codec_.obj(), index, 0, j_iv.obj(), j_key_id.obj(),
-          clear_array.obj(), cypher_array.obj(), new_subsamples_size,
+          clear_array, cypher_array, new_subsamples_size,
           presentation_time.InMicroseconds()));
 }
 
 void SdkMediaCodecBridge::QueueEOS(int input_buffer_index) {
   DVLOG(3) << __PRETTY_FUNCTION__ << ": " << input_buffer_index;
   JNIEnv* env = AttachCurrentThread();
-  Java_MediaCodecBridge_queueInputBuffer(env, j_media_codec_.obj(),
-                                         input_buffer_index, 0, 0, 0,
-                                         kBufferFlagEndOfStream);
+  Java_MediaCodecBridge_queueInputBuffer(
+      env, j_media_codec_, input_buffer_index, 0, 0, 0, kBufferFlagEndOfStream);
 }
 
 MediaCodecStatus SdkMediaCodecBridge::DequeueInputBuffer(
     base::TimeDelta timeout,
     int* index) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> result = Java_MediaCodecBridge_dequeueInputBuffer(
-      env, j_media_codec_.obj(), timeout.InMicroseconds());
-  *index = Java_DequeueInputResult_index(env, result.obj());
+      env, j_media_codec_, timeout.InMicroseconds());
+  *index = Java_DequeueInputResult_index(env, result);
   MediaCodecStatus status = static_cast<MediaCodecStatus>(
-      Java_DequeueInputResult_status(env, result.obj()));
+      Java_DequeueInputResult_status(env, result));
   DVLOG(3) << __PRETTY_FUNCTION__ << ": status: " << status
            << ", index: " << *index;
   return status;
 }
 
 MediaCodecStatus SdkMediaCodecBridge::DequeueOutputBuffer(
     base::TimeDelta timeout,
     int* index,
     size_t* offset,
     size_t* size,
     base::TimeDelta* presentation_time,
     bool* end_of_stream,
     bool* key_frame) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> result =
-      Java_MediaCodecBridge_dequeueOutputBuffer(env, j_media_codec_.obj(),
+      Java_MediaCodecBridge_dequeueOutputBuffer(env, j_media_codec_,
                                                 timeout.InMicroseconds());
-  *index = Java_DequeueOutputResult_index(env, result.obj());
-  *offset = base::checked_cast<size_t>(
-      Java_DequeueOutputResult_offset(env, result.obj()));
+  *index = Java_DequeueOutputResult_index(env, result);
+  *offset =
+      base::checked_cast<size_t>(Java_DequeueOutputResult_offset(env, result));
   *size = base::checked_cast<size_t>(
-      Java_DequeueOutputResult_numBytes(env, result.obj()));
+      Java_DequeueOutputResult_numBytes(env, result));
   if (presentation_time) {
     *presentation_time = base::TimeDelta::FromMicroseconds(
-        Java_DequeueOutputResult_presentationTimeMicroseconds(env,
-                                                              result.obj()));
+        Java_DequeueOutputResult_presentationTimeMicroseconds(env, result));
   }
-  int flags = Java_DequeueOutputResult_flags(env, result.obj());
+  int flags = Java_DequeueOutputResult_flags(env, result);
   if (end_of_stream)
     *end_of_stream = flags & kBufferFlagEndOfStream;
   if (key_frame)
     *key_frame = flags & kBufferFlagSyncFrame;
   MediaCodecStatus status = static_cast<MediaCodecStatus>(
-      Java_DequeueOutputResult_status(env, result.obj()));
+      Java_DequeueOutputResult_status(env, result));
   DVLOG(3) << __PRETTY_FUNCTION__ << ": status: " << status
            << ", index: " << *index << ", offset: " << *offset
            << ", size: " << *size << ", flags: " << flags;
   return status;
 }
 
 void SdkMediaCodecBridge::ReleaseOutputBuffer(int index, bool render) {
   DVLOG(3) << __PRETTY_FUNCTION__ << ": " << index;
   JNIEnv* env = AttachCurrentThread();
   CHECK(env);
 
-  Java_MediaCodecBridge_releaseOutputBuffer(env, j_media_codec_.obj(), index,
-                                            render);
+  Java_MediaCodecBridge_releaseOutputBuffer(env, j_media_codec_, index, render);
 }
 
 MediaCodecStatus SdkMediaCodecBridge::GetInputBuffer(int input_buffer_index,
                                                      uint8_t** data,
                                                      size_t* capacity) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> j_buffer(Java_MediaCodecBridge_getInputBuffer(
-      env, j_media_codec_.obj(), input_buffer_index));
+      env, j_media_codec_, input_buffer_index));
   if (j_buffer.is_null())
     return MEDIA_CODEC_ERROR;
 
   *data = static_cast<uint8_t*>(env->GetDirectBufferAddress(j_buffer.obj()));
   *capacity =
       base::checked_cast<size_t>(env->GetDirectBufferCapacity(j_buffer.obj()));
   return MEDIA_CODEC_OK;
 }
 
 MediaCodecStatus SdkMediaCodecBridge::GetOutputBufferAddress(
     int index,
     size_t offset,
     const uint8_t** addr,
     size_t* capacity) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> j_buffer(
-      Java_MediaCodecBridge_getOutputBuffer(env, j_media_codec_.obj(), index));
+      Java_MediaCodecBridge_getOutputBuffer(env, j_media_codec_, index));
   if (j_buffer.is_null())
     return MEDIA_CODEC_ERROR;
   const size_t total_capacity = env->GetDirectBufferCapacity(j_buffer.obj());
   CHECK_GE(total_capacity, offset);
   *addr = reinterpret_cast<const uint8_t*>(
               env->GetDirectBufferAddress(j_buffer.obj())) +
           offset;
   *capacity = total_capacity - offset;
   return MEDIA_CODEC_OK;
 }
 
 std::string SdkMediaCodecBridge::GetName() {
   if (base::android::BuildInfo::GetInstance()->sdk_int() < 18)
     return "";
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jstring> j_name =
-      Java_MediaCodecBridge_getName(env, j_media_codec_.obj());
-  return ConvertJavaStringToUTF8(env, j_name.obj());
+      Java_MediaCodecBridge_getName(env, j_media_codec_);
+  return ConvertJavaStringToUTF8(env, j_name);
 }
 
 // static
 AudioCodecBridge* AudioCodecBridge::Create(const AudioCodec& codec) {
   if (!MediaCodecUtil::IsMediaCodecAvailable())
     return nullptr;
 
   const std::string mime = AudioCodecToAndroidMimeType(codec);
   if (mime.empty())
     return nullptr;
@@ skipping 54 matching lines @@
 
   std::string codec_string = AudioCodecToAndroidMimeType(codec);
   if (codec_string.empty())
     return false;
 
   JNIEnv* env = AttachCurrentThread();
 
   ScopedJavaLocalRef<jstring> j_mime =
       ConvertUTF8ToJavaString(env, codec_string);
   ScopedJavaLocalRef<jobject> j_format(Java_MediaCodecBridge_createAudioFormat(
-      env, j_mime.obj(), sample_rate, channel_count));
+      env, j_mime, sample_rate, channel_count));
   DCHECK(!j_format.is_null());
 
   if (!ConfigureMediaFormat(j_format.obj(), codec, extra_data, extra_data_size,
                             codec_delay_ns, seek_preroll_ns)) {
     return false;
   }
 
-  if (!Java_MediaCodecBridge_configureAudio(env, media_codec(), j_format.obj(),
+  if (!Java_MediaCodecBridge_configureAudio(env, media_codec(), j_format,
                                             media_crypto, 0, play_audio)) {
     return false;
   }
 
   return Start();
 }
 
 bool AudioCodecBridge::ConfigureMediaFormat(jobject j_format,
                                             const AudioCodec& codec,
                                             const uint8_t* extra_data,
@@ skipping 34 matching lines @@
         if (total_length >= extra_data_size) {
           LOG(ERROR) << "Invalid vorbis header size in the extra data";
           return false;
         }
       }
       current_pos++;
       // The first header is identification header.
       ScopedJavaLocalRef<jbyteArray> first_header =
           base::android::ToJavaByteArray(env, current_pos, header_length[0]);
       Java_MediaCodecBridge_setCodecSpecificData(env, j_format, 0,
-                                                 first_header.obj());
+                                                 first_header);
       // The last header is codec header.
       ScopedJavaLocalRef<jbyteArray> last_header =
           base::android::ToJavaByteArray(env, extra_data + total_length,
                                          extra_data_size - total_length);
-      Java_MediaCodecBridge_setCodecSpecificData(env, j_format, 1,
-                                                 last_header.obj());
+      Java_MediaCodecBridge_setCodecSpecificData(env, j_format, 1, last_header);
       break;
     }
     case kCodecAAC: {
       media::BitReader reader(extra_data, extra_data_size);
 
       // The following code is copied from aac.cc
       // TODO(qinmin): refactor the code in aac.cc to make it more reusable.
       uint8_t profile = 0;
       uint8_t frequency_index = 0;
       uint8_t channel_config = 0;
@@ skipping 17 matching lines @@
         LOG(ERROR) << "Invalid AAC header";
         return false;
       }
 
       const size_t kCsdLength = 2;
       uint8_t csd[kCsdLength];
       csd[0] = profile << 3 | frequency_index >> 1;
       csd[1] = (frequency_index & 0x01) << 7 | channel_config << 3;
       ScopedJavaLocalRef<jbyteArray> byte_array =
           base::android::ToJavaByteArray(env, csd, kCsdLength);
-      Java_MediaCodecBridge_setCodecSpecificData(env, j_format, 0,
-                                                 byte_array.obj());
+      Java_MediaCodecBridge_setCodecSpecificData(env, j_format, 0, byte_array);
 
       // TODO(qinmin): pass an extra variable to this function to determine
       // whether we need to call this.
       Java_MediaCodecBridge_setFrameHasADTSHeader(env, j_format);
       break;
     }
     case kCodecOpus: {
       if (!extra_data || extra_data_size == 0 || codec_delay_ns < 0 ||
           seek_preroll_ns < 0) {
         LOG(ERROR) << "Invalid Opus Header";
         return false;
       }
 
       // csd0 - Opus Header
       ScopedJavaLocalRef<jbyteArray> csd0 =
           base::android::ToJavaByteArray(env, extra_data, extra_data_size);
-      Java_MediaCodecBridge_setCodecSpecificData(env, j_format, 0, csd0.obj());
+      Java_MediaCodecBridge_setCodecSpecificData(env, j_format, 0, csd0);
 
       // csd1 - Codec Delay
       ScopedJavaLocalRef<jbyteArray> csd1 = base::android::ToJavaByteArray(
           env, reinterpret_cast<const uint8_t*>(&codec_delay_ns),
           sizeof(int64_t));
-      Java_MediaCodecBridge_setCodecSpecificData(env, j_format, 1, csd1.obj());
+      Java_MediaCodecBridge_setCodecSpecificData(env, j_format, 1, csd1);
 
       // csd2 - Seek Preroll
       ScopedJavaLocalRef<jbyteArray> csd2 = base::android::ToJavaByteArray(
           env, reinterpret_cast<const uint8_t*>(&seek_preroll_ns),
           sizeof(int64_t));
-      Java_MediaCodecBridge_setCodecSpecificData(env, j_format, 2, csd2.obj());
+      Java_MediaCodecBridge_setCodecSpecificData(env, j_format, 2, csd2);
       break;
     }
     default:
       LOG(ERROR) << "Invalid header encountered for codec: "
                  << AudioCodecToAndroidMimeType(codec);
       return false;
   }
   return true;
 }
 
@@ skipping 23 matching lines @@
                 << ": GetOutputBufferAddress() failed for index:" << index;
     return status;
   }
 
   numBytes = std::min(base::checked_cast<int>(capacity), numBytes);
   CHECK_GE(numBytes, 0);
 
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jbyteArray> byte_array =
       base::android::ToJavaByteArray(env, buffer, numBytes);
-  *playback_pos = Java_MediaCodecBridge_playOutputBuffer(
-      env, media_codec(), byte_array.obj(), postpone);
+  *playback_pos = Java_MediaCodecBridge_playOutputBuffer(env, media_codec(),
+                                                         byte_array, postpone);
   return status;
 }
 
 void AudioCodecBridge::SetVolume(double volume) {
   JNIEnv* env = AttachCurrentThread();
   Java_MediaCodecBridge_setVolume(env, media_codec(), volume);
 }
 
 // static
 bool VideoCodecBridge::IsKnownUnaccelerated(const VideoCodec& codec,
@@ skipping 18 matching lines @@
     return nullptr;
 
   std::unique_ptr<VideoCodecBridge> bridge(new VideoCodecBridge(
       mime, is_secure, MEDIA_CODEC_DECODER, require_software_codec));
   if (!bridge->media_codec())
     return nullptr;
 
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jstring> j_mime = ConvertUTF8ToJavaString(env, mime);
   ScopedJavaLocalRef<jobject> j_format(
-      Java_MediaCodecBridge_createVideoDecoderFormat(
-          env, j_mime.obj(), size.width(), size.height()));
+      Java_MediaCodecBridge_createVideoDecoderFormat(env, j_mime, size.width(),
+                                                     size.height()));
   DCHECK(!j_format.is_null());
-  if (!Java_MediaCodecBridge_configureVideo(
-          env, bridge->media_codec(), j_format.obj(), surface, media_crypto, 0,
-          allow_adaptive_playback)) {
+  if (!Java_MediaCodecBridge_configureVideo(env, bridge->media_codec(),
+                                            j_format, surface, media_crypto, 0,
+                                            allow_adaptive_playback)) {
     return nullptr;
   }
 
   return bridge->Start() ? bridge.release() : nullptr;
 }
 
 // static
 VideoCodecBridge* VideoCodecBridge::CreateEncoder(const VideoCodec& codec,
                                                   const gfx::Size& size,
                                                   int bit_rate,
                                                   int frame_rate,
                                                   int i_frame_interval,
                                                   int color_format) {
   if (!MediaCodecUtil::IsMediaCodecAvailable())
     return nullptr;
 
   const std::string mime = VideoCodecToAndroidMimeType(codec);
   if (mime.empty())
     return nullptr;
 
   std::unique_ptr<VideoCodecBridge> bridge(
       new VideoCodecBridge(mime, false, MEDIA_CODEC_ENCODER, false));
   if (!bridge->media_codec())
     return nullptr;
 
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jstring> j_mime = ConvertUTF8ToJavaString(env, mime);
   ScopedJavaLocalRef<jobject> j_format(
       Java_MediaCodecBridge_createVideoEncoderFormat(
-          env, j_mime.obj(), size.width(), size.height(), bit_rate, frame_rate,
+          env, j_mime, size.width(), size.height(), bit_rate, frame_rate,
           i_frame_interval, color_format));
   DCHECK(!j_format.is_null());
   if (!Java_MediaCodecBridge_configureVideo(env, bridge->media_codec(),
-                                            j_format.obj(), nullptr, nullptr,
+                                            j_format, nullptr, nullptr,
                                             kConfigureFlagEncode, true)) {
     return nullptr;
   }
 
   return bridge->Start() ? bridge.release() : nullptr;
 }
 
 VideoCodecBridge::VideoCodecBridge(const std::string& mime,
                                    bool is_secure,
                                    MediaCodecDirection direction,
@@ skipping 15 matching lines @@
   if (adaptive_playback_supported_for_testing_ == 0)
     return false;
   else if (adaptive_playback_supported_for_testing_ > 0)
     return true;
   JNIEnv* env = AttachCurrentThread();
   return Java_MediaCodecBridge_isAdaptivePlaybackSupported(env, media_codec(),
                                                            width, height);
 }
 
 }  // namespace media