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

media/base/android/media_codec_util.cc

 // Copyright 2015 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/media_codec_util.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
@@ skipping 55 matching lines @@
          supported.end();
 }
 
 static std::string GetDefaultCodecName(const std::string& mime_type,
                                        MediaCodecDirection direction,
                                        bool require_software_codec) {
   DCHECK(MediaCodecUtil::IsMediaCodecAvailable());
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jstring> j_mime = ConvertUTF8ToJavaString(env, mime_type);
   ScopedJavaLocalRef<jstring> j_codec_name =
-      Java_MediaCodecUtil_getDefaultCodecName(env, j_mime.obj(), direction,
+      Java_MediaCodecUtil_getDefaultCodecName(env, j_mime, direction,
                                               require_software_codec);
   return ConvertJavaStringToUTF8(env, j_codec_name.obj());
 }
 
 static bool IsDecoderSupportedByDevice(const std::string& android_mime_type) {
   DCHECK(MediaCodecUtil::IsMediaCodecAvailable());
   DCHECK(IsSupportedAndroidMimeType(android_mime_type));
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jstring> j_mime =
       ConvertUTF8ToJavaString(env, android_mime_type);
-  return Java_MediaCodecUtil_isDecoderSupportedForDevice(env, j_mime.obj());
+  return Java_MediaCodecUtil_isDecoderSupportedForDevice(env, j_mime);
 }
 
 // static
 bool MediaCodecUtil::IsMediaCodecAvailable() {
   // MediaCodec is only available on JB and greater.
   if (base::android::BuildInfo::GetInstance()->sdk_int() < 16)
     return false;
 
   // Blacklist some devices on Jellybean as for MediaCodec support is buggy.
   // http://crbug.com/365494, http://crbug.com/615872
@@ skipping 14 matching lines @@
 // static
 std::set<int> MediaCodecUtil::GetEncoderColorFormats(
     const std::string& mime_type) {
   std::set<int> color_formats;
   if (!IsMediaCodecAvailable())
     return color_formats;
 
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jstring> j_mime = ConvertUTF8ToJavaString(env, mime_type);
   ScopedJavaLocalRef<jintArray> j_color_format_array =
-      Java_MediaCodecUtil_getEncoderColorFormatsForMime(env, j_mime.obj());
+      Java_MediaCodecUtil_getEncoderColorFormatsForMime(env, j_mime);
 
   if (j_color_format_array.obj()) {
     std::vector<int> formats;
     JavaIntArrayToIntVector(env, j_color_format_array.obj(), &formats);
     color_formats = std::set<int>(formats.begin(), formats.end());
   }
 
   return color_formats;
 }
 
 // static
 bool MediaCodecUtil::CanDecode(const std::string& codec, bool is_secure) {
   if (!IsMediaCodecAvailable())
     return false;
 
   JNIEnv* env = AttachCurrentThread();
   std::string mime = CodecTypeToAndroidMimeType(codec);
   if (mime.empty())
     return false;
   ScopedJavaLocalRef<jstring> j_mime = ConvertUTF8ToJavaString(env, mime);
-  return Java_MediaCodecUtil_canDecode(env, j_mime.obj(), is_secure);
+  return Java_MediaCodecUtil_canDecode(env, j_mime, is_secure);
 }
 
 // static
 bool MediaCodecUtil::IsKnownUnaccelerated(const std::string& android_mime_type,
                                           MediaCodecDirection direction) {
   DCHECK(IsSupportedAndroidMimeType(android_mime_type));
   if (!IsMediaCodecAvailable())
     return true;
 
   std::string codec_name =
@@ skipping 90 matching lines @@
          (sdk_int == 18 && ("OMX.SEC.avc.dec" == codec_name ||
                             "OMX.SEC.avc.dec.secure" == codec_name)) ||
          (sdk_int == 19 &&
           base::StartsWith(base::android::BuildInfo::GetInstance()->model(),
                            "SM-G800", base::CompareCase::INSENSITIVE_ASCII) &&
           ("OMX.Exynos.avc.dec" == codec_name ||
            "OMX.Exynos.avc.dec.secure" == codec_name));
 }
 
 }  // namespace media