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

media/base/android/media_player_bridge.cc

 // Copyright (c) 2012 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_player_bridge.h"
 
 #include <utility>
 
 #include "base/android/context_utils.h"
 #include "base/android/jni_android.h"
@@ skipping 57 matching lines @@
       allow_credentials_(allow_credentials),
       is_active_(false),
       has_error_(false),
       has_ever_started_(false),
       weak_factory_(this) {}
 
 MediaPlayerBridge::~MediaPlayerBridge() {
   if (!j_media_player_bridge_.is_null()) {
     JNIEnv* env = base::android::AttachCurrentThread();
     CHECK(env);
-    Java_MediaPlayerBridge_destroy(env, j_media_player_bridge_.obj());
+    Java_MediaPlayerBridge_destroy(env, j_media_player_bridge_);
   }
   Release();
 
   if (has_ever_started_) {
     UMA_HISTOGRAM_ENUMERATION("Media.Android.MediaPlayerSuccess",
                               has_error_ ? UMA_EXIT_ERROR : UMA_EXIT_SUCCESS,
                               UMA_EXIT_STATUS_MAX + 1);
   }
 }
 
@@ skipping 45 matching lines @@
 
 void MediaPlayerBridge::SetVideoSurface(gl::ScopedJavaSurface surface) {
   surface_ = std::move(surface);
 
   if (j_media_player_bridge_.is_null())
     return;
 
   JNIEnv* env = base::android::AttachCurrentThread();
   CHECK(env);
 
-  Java_MediaPlayerBridge_setSurface(
-      env, j_media_player_bridge_.obj(), surface_.j_surface().obj());
+  Java_MediaPlayerBridge_setSurface(env, j_media_player_bridge_,
+                                    surface_.j_surface());
 }
 
 void MediaPlayerBridge::Prepare() {
   DCHECK(j_media_player_bridge_.is_null());
   CreateJavaMediaPlayerBridge();
   if (url_.SchemeIsFileSystem() || url_.SchemeIsBlob()) {
     manager()->GetMediaResourceGetter()->GetPlatformPathFromURL(
         url_,
         base::Bind(&MediaPlayerBridge::SetDataSource,
                    weak_factory_.GetWeakPtr()));
     return;
   }
 
   SetDataSource(url_.spec());
 }
 
 void MediaPlayerBridge::SetDataSource(const std::string& url) {
   if (j_media_player_bridge_.is_null())
     return;
 
   JNIEnv* env = base::android::AttachCurrentThread();
   CHECK(env);
 
   int fd;
   int64_t offset;
   int64_t size;
   if (InterceptMediaUrl(url, &fd, &offset, &size)) {
-    if (!Java_MediaPlayerBridge_setDataSourceFromFd(
-        env, j_media_player_bridge_.obj(), fd, offset, size)) {
+    if (!Java_MediaPlayerBridge_setDataSourceFromFd(env, j_media_player_bridge_,
+                                                    fd, offset, size)) {
       OnMediaError(MEDIA_ERROR_FORMAT);
       return;
     }
   } else {
     // Create a Java String for the URL.
     ScopedJavaLocalRef<jstring> j_url_string =
         ConvertUTF8ToJavaString(env, url);
 
     const JavaRef<jobject>& j_context = base::android::GetApplicationContext();
 
     const std::string data_uri_prefix("data:");
     if (base::StartsWith(url, data_uri_prefix, base::CompareCase::SENSITIVE)) {
       if (!Java_MediaPlayerBridge_setDataUriDataSource(
-          env, j_media_player_bridge_.obj(), j_context, j_url_string.obj())) {
+              env, j_media_player_bridge_, j_context, j_url_string)) {
         OnMediaError(MEDIA_ERROR_FORMAT);
       }
       return;
     }
 
     ScopedJavaLocalRef<jstring> j_cookies = ConvertUTF8ToJavaString(
         env, cookies_);
     ScopedJavaLocalRef<jstring> j_user_agent = ConvertUTF8ToJavaString(
         env, user_agent_);
 
     if (!Java_MediaPlayerBridge_setDataSource(
-        env, j_media_player_bridge_.obj(), j_context, j_url_string.obj(),
-        j_cookies.obj(), j_user_agent.obj(), hide_url_log_)) {
+            env, j_media_player_bridge_, j_context, j_url_string, j_cookies,
+            j_user_agent, hide_url_log_)) {
       OnMediaError(MEDIA_ERROR_FORMAT);
       return;
     }
   }
 
-  if (!Java_MediaPlayerBridge_prepareAsync(env, j_media_player_bridge_.obj()))
+  if (!Java_MediaPlayerBridge_prepareAsync(env, j_media_player_bridge_))
     OnMediaError(MEDIA_ERROR_FORMAT);
 }
 
 bool MediaPlayerBridge::InterceptMediaUrl(const std::string& url,
                                           int* fd,
                                           int64_t* offset,
                                           int64_t* size) {
   // Sentinel value to check whether the output arguments have been set.
   const int kUnsetValue = -1;
 
@@ skipping 13 matching lines @@
 
 void MediaPlayerBridge::OnDidSetDataUriDataSource(
     JNIEnv* env,
     const JavaParamRef<jobject>& obj,
     jboolean success) {
   if (!success) {
     OnMediaError(MEDIA_ERROR_FORMAT);
     return;
   }
 
-  if (!Java_MediaPlayerBridge_prepareAsync(env, j_media_player_bridge_.obj()))
+  if (!Java_MediaPlayerBridge_prepareAsync(env, j_media_player_bridge_))
     OnMediaError(MEDIA_ERROR_FORMAT);
 }
 
 void MediaPlayerBridge::OnCookiesRetrieved(const std::string& cookies) {
   cookies_ = cookies;
   manager()->GetMediaResourceGetter()->GetAuthCredentials(
       url_,
       base::Bind(&MediaPlayerBridge::OnAuthCredentialsRetrieved,
                  weak_factory_.GetWeakPtr()));
 }
@@ skipping 80 matching lines @@
 
   is_active_ = false;
 }
 
 bool MediaPlayerBridge::IsPlaying() {
   if (!prepared_)
     return pending_play_;
 
   JNIEnv* env = base::android::AttachCurrentThread();
   CHECK(env);
-  jboolean result = Java_MediaPlayerBridge_isPlaying(
-      env, j_media_player_bridge_.obj());
+  jboolean result =
+      Java_MediaPlayerBridge_isPlaying(env, j_media_player_bridge_);
   return result;
 }
 
 bool MediaPlayerBridge::HasVideo() const {
   DCHECK(prepared_);
   JNIEnv* env = base::android::AttachCurrentThread();
-  return Java_MediaPlayerBridge_hasVideo(env, j_media_player_bridge_.obj());
+  return Java_MediaPlayerBridge_hasVideo(env, j_media_player_bridge_);
 }
 
 bool MediaPlayerBridge::HasAudio() const {
   DCHECK(prepared_);
   JNIEnv* env = base::android::AttachCurrentThread();
-  return Java_MediaPlayerBridge_hasAudio(env, j_media_player_bridge_.obj());
+  return Java_MediaPlayerBridge_hasAudio(env, j_media_player_bridge_);
 }
 
 int MediaPlayerBridge::GetVideoWidth() {
   if (!prepared_)
     return width_;
   JNIEnv* env = base::android::AttachCurrentThread();
-  return Java_MediaPlayerBridge_getVideoWidth(
-      env, j_media_player_bridge_.obj());
+  return Java_MediaPlayerBridge_getVideoWidth(env, j_media_player_bridge_);
 }
 
 int MediaPlayerBridge::GetVideoHeight() {
   if (!prepared_)
     return height_;
   JNIEnv* env = base::android::AttachCurrentThread();
-  return Java_MediaPlayerBridge_getVideoHeight(
-      env, j_media_player_bridge_.obj());
+  return Java_MediaPlayerBridge_getVideoHeight(env, j_media_player_bridge_);
 }
 
 void MediaPlayerBridge::SeekTo(base::TimeDelta timestamp) {
   // Record the time to seek when OnMediaPrepared() is called.
   pending_seek_ = timestamp;
   should_seek_on_prepare_ = true;
 
   if (prepared_)
     SeekInternal(GetCurrentTime(), timestamp);
 }
 
 base::TimeDelta MediaPlayerBridge::GetCurrentTime() {
   if (!prepared_)
     return pending_seek_;
   JNIEnv* env = base::android::AttachCurrentThread();
   return base::TimeDelta::FromMilliseconds(
-      Java_MediaPlayerBridge_getCurrentPosition(
-          env, j_media_player_bridge_.obj()));
+      Java_MediaPlayerBridge_getCurrentPosition(env, j_media_player_bridge_));
 }
 
 base::TimeDelta MediaPlayerBridge::GetDuration() {
   if (!prepared_)
     return duration_;
   JNIEnv* env = base::android::AttachCurrentThread();
   const int duration_ms =
-      Java_MediaPlayerBridge_getDuration(env, j_media_player_bridge_.obj());
+      Java_MediaPlayerBridge_getDuration(env, j_media_player_bridge_);
   return duration_ms < 0 ? media::kInfiniteDuration
                          : base::TimeDelta::FromMilliseconds(duration_ms);
 }
 
 void MediaPlayerBridge::Release() {
   is_active_ = false;
 
   on_decoder_resources_released_cb_.Run(player_id());
   if (j_media_player_bridge_.is_null())
     return;
 
   time_update_timer_.Stop();
   if (prepared_) {
     pending_seek_ = GetCurrentTime();
     should_seek_on_prepare_ = true;
   }
 
   prepared_ = false;
   pending_play_ = false;
   SetVideoSurface(gl::ScopedJavaSurface());
   JNIEnv* env = base::android::AttachCurrentThread();
-  Java_MediaPlayerBridge_release(env, j_media_player_bridge_.obj());
+  Java_MediaPlayerBridge_release(env, j_media_player_bridge_);
   j_media_player_bridge_.Reset();
   DetachListener();
 }
 
 void MediaPlayerBridge::UpdateEffectiveVolumeInternal(double effective_volume) {
   if (j_media_player_bridge_.is_null()) {
     return;
   }
 
   JNIEnv* env = base::android::AttachCurrentThread();
   CHECK(env);
 
-  Java_MediaPlayerBridge_setVolume(env, j_media_player_bridge_.obj(),
+  Java_MediaPlayerBridge_setVolume(env, j_media_player_bridge_,
                                    effective_volume);
 }
 
 void MediaPlayerBridge::OnVideoSizeChanged(int width, int height) {
   width_ = width;
   height_ = height;
   MediaPlayerAndroid::OnVideoSizeChanged(width, height);
 }
 
 void MediaPlayerBridge::OnMediaError(int error_type) {
@@ skipping 47 matching lines @@
 
   UpdateAllowedOperations();
   manager()->OnMediaMetadataChanged(
       player_id(), duration_, width_, height_, true);
 }
 
 ScopedJavaLocalRef<jobject> MediaPlayerBridge::GetAllowedOperations() {
   JNIEnv* env = base::android::AttachCurrentThread();
   CHECK(env);
 
-  return Java_MediaPlayerBridge_getAllowedOperations(
-      env, j_media_player_bridge_.obj());
+  return Java_MediaPlayerBridge_getAllowedOperations(env,
+                                                     j_media_player_bridge_);
 }
 
 void MediaPlayerBridge::UpdateAllowedOperations() {
   JNIEnv* env = base::android::AttachCurrentThread();
   CHECK(env);
 
   ScopedJavaLocalRef<jobject> allowedOperations = GetAllowedOperations();
 
-  can_pause_ = Java_AllowedOperations_canPause(env, allowedOperations.obj());
-  can_seek_forward_ = Java_AllowedOperations_canSeekForward(
-      env, allowedOperations.obj());
-  can_seek_backward_ = Java_AllowedOperations_canSeekBackward(
-      env, allowedOperations.obj());
+  can_pause_ = Java_AllowedOperations_canPause(env, allowedOperations);
+  can_seek_forward_ =
+      Java_AllowedOperations_canSeekForward(env, allowedOperations);
+  can_seek_backward_ =
+      Java_AllowedOperations_canSeekBackward(env, allowedOperations);
 }
 
 void MediaPlayerBridge::StartInternal() {
   if (!manager()->RequestPlay(player_id(), duration_, HasAudio())) {
     Pause(true);
     return;
   }
 
   JNIEnv* env = base::android::AttachCurrentThread();
-  Java_MediaPlayerBridge_start(env, j_media_player_bridge_.obj());
+  Java_MediaPlayerBridge_start(env, j_media_player_bridge_);
   if (!time_update_timer_.IsRunning()) {
     time_update_timer_.Start(
         FROM_HERE,
         base::TimeDelta::FromMilliseconds(kTimeUpdateInterval),
         this, &MediaPlayerBridge::OnTimeUpdateTimerFired);
   }
 }
 
 void MediaPlayerBridge::PauseInternal() {
   JNIEnv* env = base::android::AttachCurrentThread();
-  Java_MediaPlayerBridge_pause(env, j_media_player_bridge_.obj());
+  Java_MediaPlayerBridge_pause(env, j_media_player_bridge_);
   time_update_timer_.Stop();
 }
 
 void MediaPlayerBridge::PendingSeekInternal(const base::TimeDelta& time) {
   SeekInternal(GetCurrentTime(), time);
 }
 
 bool MediaPlayerBridge::SeekInternal(base::TimeDelta current_time,
                                      base::TimeDelta time) {
   // Seeking on content like live streams may cause the media player to
@@ skipping 10 matching lines @@
   // Seeking to an invalid position may cause media player to stuck in an
   // error state.
   if (time < base::TimeDelta()) {
     DCHECK_EQ(-1.0, time.InMillisecondsF());
     return false;
   }
 
   JNIEnv* env = base::android::AttachCurrentThread();
   CHECK(env);
   int time_msec = static_cast<int>(time.InMilliseconds());
-  Java_MediaPlayerBridge_seekTo(
-      env, j_media_player_bridge_.obj(), time_msec);
+  Java_MediaPlayerBridge_seekTo(env, j_media_player_bridge_, time_msec);
   return true;
 }
 
 void MediaPlayerBridge::OnTimeUpdateTimerFired() {
   base::TimeDelta current_timestamp = GetCurrentTime();
   if (last_time_update_timestamp_ == current_timestamp)
     return;
   manager()->OnTimeUpdate(player_id(), current_timestamp,
                           base::TimeTicks::Now());
   last_time_update_timestamp_ = current_timestamp;
@@ skipping 21 matching lines @@
 
 GURL MediaPlayerBridge::GetUrl() {
   return url_;
 }
 
 GURL MediaPlayerBridge::GetFirstPartyForCookies() {
   return first_party_for_cookies_;
 }
 
 }  // namespace media