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

chrome/browser/media/android/remote/remote_media_player_bridge.cc

 // Copyright 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 "chrome/browser/media/android/remote/remote_media_player_bridge.h"
 
 #include <utility>
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
@@ skipping 60 matching lines @@
     // Create a Java String for the URL.
     j_url_string = ConvertUTF8ToJavaString(env, escaped_url);
   }
   ScopedJavaLocalRef<jstring> j_frame_url_string;
   GURL frameUrl = GetLocalPlayer()->frame_url();
   if (frameUrl.is_valid()) {
     // Create a Java String for the URL.
     j_frame_url_string = ConvertUTF8ToJavaString(env, frameUrl.spec());
   }
   java_bridge_.Reset(Java_RemoteMediaPlayerBridge_create(
-      env, reinterpret_cast<intptr_t>(this), j_url_string.obj(),
-      j_frame_url_string.obj(),
-      ConvertUTF8ToJavaString(env, user_agent).obj()));
+      env, reinterpret_cast<intptr_t>(this), j_url_string, j_frame_url_string,
+      ConvertUTF8ToJavaString(env, user_agent)));
 }
 
 RemoteMediaPlayerBridge::~RemoteMediaPlayerBridge() {
   JNIEnv* env = base::android::AttachCurrentThread();
   CHECK(env);
-  Java_RemoteMediaPlayerBridge_destroy(env, java_bridge_.obj());
+  Java_RemoteMediaPlayerBridge_destroy(env, java_bridge_);
   Release();
 }
 
 bool RemoteMediaPlayerBridge::HasVideo() const {
   NOTIMPLEMENTED();
   return true;
 }
 
 bool RemoteMediaPlayerBridge::HasAudio() const {
   NOTIMPLEMENTED();
@@ skipping 23 matching lines @@
 void RemoteMediaPlayerBridge::OnPlaybackComplete() {
   time_update_timer_.Stop();
   MediaPlayerAndroid::OnPlaybackComplete();
 }
 
 void RemoteMediaPlayerBridge::OnMediaInterrupted() {}
 
 void RemoteMediaPlayerBridge::StartInternal() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   JNIEnv* env = AttachCurrentThread();
-  Java_RemoteMediaPlayerBridge_start(env, java_bridge_.obj());
+  Java_RemoteMediaPlayerBridge_start(env, java_bridge_);
   if (!time_update_timer_.IsRunning()) {
     time_update_timer_.Start(
         FROM_HERE,
         base::TimeDelta::FromMilliseconds(media::kTimeUpdateInterval),
         this, &RemoteMediaPlayerBridge::OnTimeUpdateTimerFired);
   }
 }
 
 void RemoteMediaPlayerBridge::PauseInternal() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   JNIEnv* env = AttachCurrentThread();
-  Java_RemoteMediaPlayerBridge_pause(env, java_bridge_.obj());
+  Java_RemoteMediaPlayerBridge_pause(env, java_bridge_);
   time_update_timer_.Stop();
 }
 
 void RemoteMediaPlayerBridge::OnTimeUpdateTimerFired() {
   manager()->OnTimeUpdate(
       player_id(), GetCurrentTime(), base::TimeTicks::Now());
 }
 
 void RemoteMediaPlayerBridge::PauseLocal(JNIEnv* env,
                                          const JavaParamRef<jobject>& obj) {
@@ skipping 42 matching lines @@
 }
 
 void RemoteMediaPlayerBridge::Pause(bool is_media_related_action) {
   // Ignore the pause if it's not from an event that is explicitly telling
   // the video to pause. It's possible for Pause() to be called for other
   // reasons, such as freeing resources, etc. and during those times, the
   // remote video playback should not be paused.
   if (is_media_related_action) {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
     JNIEnv* env = AttachCurrentThread();
-    Java_RemoteMediaPlayerBridge_pause(env, java_bridge_.obj());
+    Java_RemoteMediaPlayerBridge_pause(env, java_bridge_);
     time_update_timer_.Stop();
   }
 }
 
 void RemoteMediaPlayerBridge::SetVideoSurface(gl::ScopedJavaSurface surface) {
   // The surface is reset whenever the fullscreen view is destroyed or created.
   // Since the remote player doesn't use it, we forward it to the local player
   // for the time when user disconnects and resumes local playback
   // (see crbug.com/420690).
   MediaPlayerAndroid* local_player = GetLocalPlayer();
@@ skipping 44 matching lines @@
 
 void RemoteMediaPlayerBridge::RequestRemotePlayback() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   MediaPlayerAndroid* local_player = GetLocalPlayer();
   if (!local_player)
     return;
   JNIEnv* env = AttachCurrentThread();
   CHECK(env);
 
   Java_RemoteMediaPlayerBridge_requestRemotePlayback(
-      env, java_bridge_.obj(), local_player->GetCurrentTime().InMilliseconds());
+      env, java_bridge_, local_player->GetCurrentTime().InMilliseconds());
 }
 
 void RemoteMediaPlayerBridge::RequestRemotePlaybackControl() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   JNIEnv* env = AttachCurrentThread();
   CHECK(env);
 
-  Java_RemoteMediaPlayerBridge_requestRemotePlaybackControl(
-      env, java_bridge_.obj());
+  Java_RemoteMediaPlayerBridge_requestRemotePlaybackControl(env, java_bridge_);
 }
 
 void RemoteMediaPlayerBridge::SetNativePlayer() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   JNIEnv* env = AttachCurrentThread();
   CHECK(env);
 
-  Java_RemoteMediaPlayerBridge_setNativePlayer(
-      env, java_bridge_.obj());
+  Java_RemoteMediaPlayerBridge_setNativePlayer(env, java_bridge_);
 }
 
 void RemoteMediaPlayerBridge::OnPlayerCreated() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   JNIEnv* env = AttachCurrentThread();
   CHECK(env);
 
-  Java_RemoteMediaPlayerBridge_onPlayerCreated(
-      env, java_bridge_.obj());
+  Java_RemoteMediaPlayerBridge_onPlayerCreated(env, java_bridge_);
 }
 
 void RemoteMediaPlayerBridge::OnPlayerDestroyed() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   JNIEnv* env = AttachCurrentThread();
   CHECK(env);
 
-  Java_RemoteMediaPlayerBridge_onPlayerDestroyed(
-      env, java_bridge_.obj());
+  Java_RemoteMediaPlayerBridge_onPlayerDestroyed(env, java_bridge_);
 }
 
 std::string RemoteMediaPlayerBridge::GetCastingMessage() {
   return casting_message_ ?
       *casting_message_ : std::string();
 }
 
 void RemoteMediaPlayerBridge::SetPosterBitmap(
     const std::vector<SkBitmap>& bitmaps) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   JNIEnv* env = AttachCurrentThread();
   CHECK(env);
 
   if (bitmaps.empty()) {
-    Java_RemoteMediaPlayerBridge_setPosterBitmap(env, java_bridge_.obj(),
-                                                 nullptr);
+    Java_RemoteMediaPlayerBridge_setPosterBitmap(env, java_bridge_, nullptr);
   } else {
     ScopedJavaLocalRef<jobject> j_poster_bitmap;
     j_poster_bitmap = gfx::ConvertToJavaBitmap(&(bitmaps[0]));
 
-    Java_RemoteMediaPlayerBridge_setPosterBitmap(env, java_bridge_.obj(),
-                                                 j_poster_bitmap.obj());
+    Java_RemoteMediaPlayerBridge_setPosterBitmap(env, java_bridge_,
+                                                 j_poster_bitmap);
   }
 }
 
 void RemoteMediaPlayerBridge::Start() {
   StartInternal();
 }
 
 void RemoteMediaPlayerBridge::SeekTo(base::TimeDelta time) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   // TODO(aberent) Move the checks to the Java side.
   base::TimeDelta duration = GetDuration();
 
   if (time > duration)
     time = duration;
 
   // 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;
   }
 
   JNIEnv* env = AttachCurrentThread();
   CHECK(env);
   int time_msec = static_cast<int>(time.InMilliseconds());
-  Java_RemoteMediaPlayerBridge_seekTo(env, java_bridge_.obj(), time_msec);
+  Java_RemoteMediaPlayerBridge_seekTo(env, java_bridge_, time_msec);
 }
 
 void RemoteMediaPlayerBridge::Release() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   time_update_timer_.Stop();
   JNIEnv* env = AttachCurrentThread();
-  Java_RemoteMediaPlayerBridge_release(env, java_bridge_.obj());
+  Java_RemoteMediaPlayerBridge_release(env, java_bridge_);
   DetachListener();
 }
 
 void RemoteMediaPlayerBridge::UpdateEffectiveVolumeInternal(
     double effective_volume) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   JNIEnv* env = AttachCurrentThread();
   CHECK(env);
-  Java_RemoteMediaPlayerBridge_setVolume(
-      env, java_bridge_.obj(), GetEffectiveVolume());
+  Java_RemoteMediaPlayerBridge_setVolume(env, java_bridge_,
+                                         GetEffectiveVolume());
 }
 
 base::TimeDelta RemoteMediaPlayerBridge::GetCurrentTime() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   JNIEnv* env = AttachCurrentThread();
   return base::TimeDelta::FromMilliseconds(
-      Java_RemoteMediaPlayerBridge_getCurrentPosition(
-          env, java_bridge_.obj()));
+      Java_RemoteMediaPlayerBridge_getCurrentPosition(env, java_bridge_));
 }
 
 base::TimeDelta RemoteMediaPlayerBridge::GetDuration() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   JNIEnv* env = AttachCurrentThread();
   const int duration_ms =
-      Java_RemoteMediaPlayerBridge_getDuration(env, java_bridge_.obj());
+      Java_RemoteMediaPlayerBridge_getDuration(env, java_bridge_);
   // Sometimes we can't get the duration remotely, but the local media player
   // knows it.
   // TODO (aberent) This is for YouTube. Remove it when the YouTube receiver is
   // fixed.
   if (duration_ms == 0) {
     MediaPlayerAndroid* local_player = GetLocalPlayer();
     if (!local_player)
       return media::kInfiniteDuration;
     return local_player->GetDuration();
   }
   return duration_ms < 0 ? media::kInfiniteDuration
                          : base::TimeDelta::FromMilliseconds(duration_ms);
 }
 
 bool RemoteMediaPlayerBridge::IsPlaying() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   JNIEnv* env = AttachCurrentThread();
   CHECK(env);
-  jboolean result = Java_RemoteMediaPlayerBridge_isPlaying(
-      env, java_bridge_.obj());
+  jboolean result = Java_RemoteMediaPlayerBridge_isPlaying(env, java_bridge_);
   return result;
 }
 
 bool RemoteMediaPlayerBridge::CanPause() {
   return true;
 }
 
 bool RemoteMediaPlayerBridge::CanSeekForward() {
   return true;
 }
@@ skipping 55 matching lines @@
 
 
 void RemoteMediaPlayerBridge::OnCookiesRetrieved(const std::string& cookies) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   // TODO(aberent) Do we need to retrieve auth credentials for basic
   // authentication? MediaPlayerBridge does.
   cookies_ = cookies;
   JNIEnv* env = AttachCurrentThread();
   CHECK(env);
   Java_RemoteMediaPlayerBridge_setCookies(
-      env, java_bridge_.obj(), ConvertUTF8ToJavaString(env, cookies).obj());
+      env, java_bridge_, ConvertUTF8ToJavaString(env, cookies));
 }
 
 MediaPlayerAndroid* RemoteMediaPlayerBridge::GetLocalPlayer() {
   return static_cast<RemoteMediaPlayerManager*>(manager())->GetLocalPlayer(
       player_id());
 }
 
 }  // namespace remote_media