remove call to get android MediaPlayer class

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 "base/android/jni_android.h"
 #include "base/android/jni_string.h"
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/stringprintf.h"
 #include "base/message_loop_proxy.h"
 #include "jni/MediaPlayerBridge_jni.h"
 #include "jni/MediaPlayer_jni.h"
 #include "media/base/android/cookie_getter.h"
 #include "media/base/android/media_player_bridge_manager.h"
 
-using base::android::AttachCurrentThread;
-using base::android::CheckException;
 using base::android::ConvertUTF8ToJavaString;
-using base::android::GetClass;
-using base::android::JavaRef;
-using base::android::MethodID;
 using base::android::ScopedJavaLocalRef;
 
-// These constants are from the android source tree and need to be kept in
-// sync with android/media/MediaMetadata.java.
-static const jint kPauseAvailable = 1;
-static const jint kSeekBackwardAvailable = 2;
-static const jint kSeekForwardAvailable = 3;
-
 // Time update happens every 250ms.
 static const int kTimeUpdateInterval = 250;
 
 // Because we create the media player lazily on android, the duration of the
 // media is initially unknown to us. This makes the user unable to perform
 // seek. To solve this problem, we use a temporary duration of 100 seconds when
 // the duration is unknown. And we scale the seek position later when duration
 // is available.
 // TODO(qinmin): create a thread and use android MediaMetadataRetriever
 // class to extract the duration.
@@ skipping 41 matching lines @@
       cookie_getter_(cookie_getter),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_this_(this)),
       listener_(base::MessageLoopProxy::current(),
                 weak_this_.GetWeakPtr()) {}
 
 MediaPlayerBridge::~MediaPlayerBridge() {
   Release();
 }
 
 void MediaPlayerBridge::InitializePlayer() {
-  JNIEnv* env = AttachCurrentThread();
+  JNIEnv* env = base::android::AttachCurrentThread();
   CHECK(env);
 
   j_media_player_.Reset(JNI_MediaPlayer::Java_MediaPlayer_Constructor(env));
 
   jobject j_context = base::android::GetApplicationContext();
   DCHECK(j_context);
 
   listener_.CreateMediaPlayerListener(j_context, j_media_player_.obj());
 }
 
 void MediaPlayerBridge::SetVideoSurface(jobject surface) {
   if (j_media_player_.is_null() && surface != NULL)
     Prepare();
 
-  JNIEnv* env = AttachCurrentThread();
+  JNIEnv* env = base::android::AttachCurrentThread();
   CHECK(env);
 
   JNI_MediaPlayer::Java_MediaPlayer_setSurface(
       env, j_media_player_.obj(), surface);
 }
 
 void MediaPlayerBridge::Prepare() {
   if (j_media_player_.is_null())
     InitializePlayer();
 
   if (has_cookies_) {
     GetCookiesCallback(cookies_);
   } else {
     cookie_getter_->GetCookies(url_, first_party_for_cookies_, base::Bind(
         &MediaPlayerBridge::GetCookiesCallback, weak_this_.GetWeakPtr()));
   }
 }
 
 void MediaPlayerBridge::GetCookiesCallback(const std::string& cookies) {
   cookies_ = cookies;
   has_cookies_ = true;
   if (j_media_player_.is_null())
     return;
 
-  JNIEnv* env = AttachCurrentThread();
+  JNIEnv* env = base::android::AttachCurrentThread();
   CHECK(env);
 
   // Create a Java String for the URL.
   ScopedJavaLocalRef<jstring> j_url_string = ConvertUTF8ToJavaString(env, url_);
   ScopedJavaLocalRef<jstring> j_cookies = ConvertUTF8ToJavaString(
       env, cookies_);
 
   jobject j_context = base::android::GetApplicationContext();
   DCHECK(j_context);
 
@@ skipping 29 matching lines @@
       PauseInternal();
     else
       pending_play_ = false;
   }
 }
 
 bool MediaPlayerBridge::IsPlaying() {
   if (!prepared_)
     return pending_play_;
 
-  JNIEnv* env = AttachCurrentThread();
+  JNIEnv* env = base::android::AttachCurrentThread();
   CHECK(env);
   jboolean result = JNI_MediaPlayer::Java_MediaPlayer_isPlaying(
       env, j_media_player_.obj());
   return result;
 }
 
 int MediaPlayerBridge::GetVideoWidth() {
   if (!prepared_)
     return width_;
-  JNIEnv* env = AttachCurrentThread();
+  JNIEnv* env = base::android::AttachCurrentThread();
   return JNI_MediaPlayer::Java_MediaPlayer_getVideoWidth(
       env, j_media_player_.obj());
 }
 
 int MediaPlayerBridge::GetVideoHeight() {
   if (!prepared_)
     return height_;
-  JNIEnv* env = AttachCurrentThread();
+  JNIEnv* env = base::android::AttachCurrentThread();
   return JNI_MediaPlayer::Java_MediaPlayer_getVideoHeight(
       env, j_media_player_.obj());
 }
 
 void MediaPlayerBridge::SeekTo(base::TimeDelta time) {
   // Record the time to seek when OnMediaPrepared() is called.
   pending_seek_ = time;
 
   if (j_media_player_.is_null())
     Prepare();
   else if (prepared_)
     SeekInternal(time);
 }
 
 base::TimeDelta MediaPlayerBridge::GetCurrentTime() {
   if (!prepared_)
     return pending_seek_;
-  JNIEnv* env = AttachCurrentThread();
+  JNIEnv* env = base::android::AttachCurrentThread();
   return base::TimeDelta::FromMilliseconds(
       JNI_MediaPlayer::Java_MediaPlayer_getCurrentPosition(
           env, j_media_player_.obj()));
 }
 
 base::TimeDelta MediaPlayerBridge::GetDuration() {
   if (!prepared_)
     return duration_;
-  JNIEnv* env = AttachCurrentThread();
+  JNIEnv* env = base::android::AttachCurrentThread();
   return base::TimeDelta::FromMilliseconds(
       JNI_MediaPlayer::Java_MediaPlayer_getDuration(
           env, j_media_player_.obj()));
 }
 
 void MediaPlayerBridge::Release() {
   if (j_media_player_.is_null())
     return;
 
   time_update_timer_.Stop();
   if (prepared_)
     pending_seek_ = GetCurrentTime();
   if (manager_)
     manager_->ReleaseMediaResources(this);
   prepared_ = false;
   pending_play_ = false;
   SetVideoSurface(NULL);
 
-  JNIEnv* env = AttachCurrentThread();
+  JNIEnv* env = base::android::AttachCurrentThread();
   JNI_MediaPlayer::Java_MediaPlayer_release(env, j_media_player_.obj());
   j_media_player_.Reset();
 
   listener_.ReleaseMediaPlayerListenerResources();
 }
 
 void MediaPlayerBridge::SetVolume(float left_volume, float right_volume) {
   if (j_media_player_.is_null())
     return;
 
-  JNIEnv* env = AttachCurrentThread();
+  JNIEnv* env = base::android::AttachCurrentThread();
   CHECK(env);
   JNI_MediaPlayer::Java_MediaPlayer_setVolume(
       env, j_media_player_.obj(), left_volume, right_volume);
 }
 
 void MediaPlayerBridge::DoTimeUpdate() {
   base::TimeDelta current = GetCurrentTime();
   time_update_cb_.Run(player_id_, current);
 }
 
@@ skipping 49 matching lines @@
     StartInternal();
     pending_play_ = false;
   }
 
   GetMetadata();
 
   media_prepared_cb_.Run(player_id_, duration_);
 }
 
 void MediaPlayerBridge::GetMetadata() {
-  JNIEnv* env = AttachCurrentThread();
+  JNIEnv* env = base::android::AttachCurrentThread();
   CHECK(env);
 
-  ScopedJavaLocalRef<jclass> media_player_class(
-      GetClass(env, "android/media/MediaPlayer"));
-  jmethodID method = MethodID::Get<MethodID::TYPE_INSTANCE>(
-      env, media_player_class.obj(), "getMetadata",
-      "(ZZ)Landroid/media/Metadata;");
-  ScopedJavaLocalRef<jobject> j_metadata(
-      env, env->CallObjectMethod(
-          j_media_player_.obj(), method, JNI_FALSE, JNI_FALSE));
-  CheckException(env);
-  if (j_metadata.is_null())
-    return;
+  ScopedJavaLocalRef<jobject> allowedOperations =
+      Java_MediaPlayerBridge_getAllowedOperations(env, j_media_player_.obj());
+  base::android::CheckException(env);

[bulach, 2013/03/14 09:59:07]

nit: the generated code already calls CheckException :) (same for 329)

[qinmin, 2013/03/14 18:53:03]

thanks, removed, also remove the checkException below
On 2013/03/14 09:59:07, bulach wrote:

 
-  ScopedJavaLocalRef<jclass> metadata_class(
-      GetClass(env, "android/media/Metadata"));
-  jmethodID get_boolean = MethodID::Get<MethodID::TYPE_INSTANCE>(
-      env, metadata_class.obj(), "getBoolean", "(I)Z");
-  can_pause_ = env->CallBooleanMethod(j_metadata.obj(),
-                                      get_boolean,
-                                      kPauseAvailable);
-  CheckException(env);
-  can_seek_forward_ = env->CallBooleanMethod(j_metadata.obj(),
-                                             get_boolean,
-                                             kSeekBackwardAvailable);
-  CheckException(env);
-  can_seek_backward_ = env->CallBooleanMethod(j_metadata.obj(),
-                                              get_boolean,
-                                              kSeekForwardAvailable);
-  CheckException(env);
+  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());
+  base::android::CheckException(env);
 }
 
 void MediaPlayerBridge::StartInternal() {
-  JNIEnv* env = AttachCurrentThread();
+  JNIEnv* env = base::android::AttachCurrentThread();
   JNI_MediaPlayer::Java_MediaPlayer_start(env, j_media_player_.obj());
   if (!time_update_timer_.IsRunning()) {
     time_update_timer_.Start(
         FROM_HERE,
         base::TimeDelta::FromMilliseconds(kTimeUpdateInterval),
         this, &MediaPlayerBridge::DoTimeUpdate);
   }
 }
 
 void MediaPlayerBridge::PauseInternal() {
-  JNIEnv* env = AttachCurrentThread();
+  JNIEnv* env = base::android::AttachCurrentThread();
   JNI_MediaPlayer::Java_MediaPlayer_pause(env, j_media_player_.obj());
   time_update_timer_.Stop();
 }
 
 void MediaPlayerBridge::SeekInternal(base::TimeDelta time) {
-  JNIEnv* env = AttachCurrentThread();
+  JNIEnv* env = base::android::AttachCurrentThread();
   CHECK(env);
 
   int time_msec = static_cast<int>(time.InMilliseconds());
   JNI_MediaPlayer::Java_MediaPlayer_seekTo(
       env, j_media_player_.obj(), time_msec);
 }
 
 bool MediaPlayerBridge::RegisterMediaPlayerBridge(JNIEnv* env) {
   bool ret = RegisterNativesImpl(env);
   DCHECK(g_MediaPlayerBridge_clazz);
   if (ret)
     ret = JNI_MediaPlayer::RegisterNativesImpl(env);
   return ret;
 }
 
 }  // namespace media