Refactor Clank cast connect logic

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

Index: chrome/browser/media/android/remote/remote_media_player_bridge.cc
diff --git a/chrome/browser/media/android/remote/remote_media_player_bridge.cc b/chrome/browser/media/android/remote/remote_media_player_bridge.cc
index 3f9781e07f487d66c3e75975030d8b63c7544a00..4efd11b98f7a337b6af986e9894afcbef7690469 100644
--- a/chrome/browser/media/android/remote/remote_media_player_bridge.cc
+++ b/chrome/browser/media/android/remote/remote_media_player_bridge.cc
@@ -18,6 +18,7 @@
 #include "ui/gfx/android/java_bitmap.h"
 
 using base::android::ConvertUTF8ToJavaString;
+using base::android::ConvertJavaStringToUTF8;
 using base::android::ScopedJavaLocalRef;
 using base::android::AttachCurrentThread;
 
@@ -40,12 +41,8 @@ RemoteMediaPlayerBridge::RemoteMediaPlayerBridge(
                          local_player->frame_url()),
       start_position_millis_(0),
       local_player_(local_player),
-      in_use_(false),
-      prepared_(false),
-      pending_play_(false),
       width_(0),
       height_(0),
-      should_seek_on_prepare_(false),
       hide_url_log_(hide_url_log),
       volume_(-1.0),
       url_(local_player->GetUrl()),
@@ -67,11 +64,10 @@ RemoteMediaPlayerBridge::RemoteMediaPlayerBridge(
     j_frame_url_string = ConvertUTF8ToJavaString(
         env, local_player->frame_url().spec());
   }
-  java_bridge_.Reset(
-      Java_RemoteMediaPlayerBridge_create(env, reinterpret_cast<intptr_t>(this),
-                                          start_position_millis_,
-                                          j_url_string.obj(),
-                                          j_frame_url_string.obj()));
+  java_bridge_.Reset(Java_RemoteMediaPlayerBridge_create(
+      env, reinterpret_cast<intptr_t>(this), start_position_millis_,
+      j_url_string.obj(), j_frame_url_string.obj(),
+      ConvertUTF8ToJavaString(env, user_agent).obj()));
 }
 
 RemoteMediaPlayerBridge::~RemoteMediaPlayerBridge() {
@@ -102,30 +98,6 @@ void RemoteMediaPlayerBridge::OnPlaybackComplete() {
 
 void RemoteMediaPlayerBridge::OnMediaInterrupted() {}
 
-void RemoteMediaPlayerBridge::OnMediaPrepared() {
-  if (!in_use_)
-    return;
-
-  prepared_ = true;
-  duration_ = GetDuration();
-
-  // If media player was recovered from a saved state, consume all the pending
-  // events.
-  if (should_seek_on_prepare_) {
-    PendingSeekInternal(pending_seek_);
-    pending_seek_ = base::TimeDelta::FromMilliseconds(0);
-    should_seek_on_prepare_ = false;
-  }
-
-  if (pending_play_) {
-    StartInternal();
-    pending_play_ = false;
-  }
-
-  manager()->OnMediaMetadataChanged(
-      player_id(), duration_, width_, height_, true);
-}
-
 void RemoteMediaPlayerBridge::StartInternal() {
   JNIEnv* env = AttachCurrentThread();
   Java_RemoteMediaPlayerBridge_start(env, java_bridge_.obj());
@@ -143,64 +115,37 @@ void RemoteMediaPlayerBridge::PauseInternal() {
   time_update_timer_.Stop();
 }
 
-void RemoteMediaPlayerBridge::SeekInternal(base::TimeDelta time) {
-  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);
-}
-
 void RemoteMediaPlayerBridge::OnTimeUpdateTimerFired() {
   manager()->OnTimeUpdate(
       player_id(), GetCurrentTime(), base::TimeTicks::Now());
 }
 
-void RemoteMediaPlayerBridge::PendingSeekInternal(const base::TimeDelta& time) {
-  SeekInternal(time);
+void RemoteMediaPlayerBridge::PauseLocal(JNIEnv* env, jobject obj) {
+  local_player_->Pause(true);
+  static_cast<RemoteMediaPlayerManager*>(manager())->OnPaused(player_id());
 }
 
-void RemoteMediaPlayerBridge::Prepare() {
-  DCHECK(!in_use_);
-  DCHECK(IsMediaPlayableRemotely());
-  in_use_ = true;
-  AttachListener(java_bridge_.obj());
-  JNIEnv* env = AttachCurrentThread();
-  CHECK(env);
+jint RemoteMediaPlayerBridge::GetLocalPosition(JNIEnv* env, jobject obj) {
+  base::TimeDelta time = local_player_->GetCurrentTime();
+  return static_cast<jint>(time.InMilliseconds());
+}
 
-  if (url_.is_valid()) {
-    // Create a Java String for the URL.
-    ScopedJavaLocalRef<jstring> j_url_string =
-        ConvertUTF8ToJavaString(env, url_.spec());
-
-    jobject j_context = base::android::GetApplicationContext();
-    DCHECK(j_context);
-
-    ScopedJavaLocalRef<jstring> j_cookies = ConvertUTF8ToJavaString(
-        env, cookies_);
-    ScopedJavaLocalRef<jstring> j_user_agent = ConvertUTF8ToJavaString(
-        env, user_agent_);
-
-    if (!Java_RemoteMediaPlayerBridge_setDataSource(
-        env, java_bridge_.obj(), j_context, j_url_string.obj(),
-        j_cookies.obj(), j_user_agent.obj(), hide_url_log_)) {
-      OnMediaError(MEDIA_ERROR_FORMAT);
-      return;
-    }
+void RemoteMediaPlayerBridge::OnCastStarting(JNIEnv* env,
+                                             jobject obj,
+                                             jstring casting_message) {
+  static_cast<RemoteMediaPlayerManager*>(manager())->SwitchToRemotePlayer(
+      player_id(), ConvertJavaStringToUTF8(env, casting_message));
+  if (!time_update_timer_.IsRunning()) {
+    time_update_timer_.Start(
+        FROM_HERE,
+        base::TimeDelta::FromMilliseconds(media::kTimeUpdateInterval), this,
+        &RemoteMediaPlayerBridge::OnTimeUpdateTimerFired);
   }
+}
 
-  if (!Java_RemoteMediaPlayerBridge_prepareAsync(env, java_bridge_.obj()))
-    OnMediaError(MEDIA_ERROR_FORMAT);
+void RemoteMediaPlayerBridge::OnCastStopping(JNIEnv* env, jobject obj) {
+  static_cast<RemoteMediaPlayerManager*>(manager())
+      ->SwitchToLocalPlayer(player_id());
 }
 
 void RemoteMediaPlayerBridge::Pause(bool is_media_related_action) {
@@ -209,14 +154,9 @@ void RemoteMediaPlayerBridge::Pause(bool is_media_related_action) {
   // reasons, such as freeing resources, etc. and during those times, the
   // remote video playback should not be paused.
   if (is_media_related_action) {
-    if (!in_use_) {
-      pending_play_ = false;
-    } else {
-      if (prepared_ && IsPlaying())
-        PauseInternal();
-      else
-        pending_play_ = false;
-    }
+    JNIEnv* env = AttachCurrentThread();
+    Java_RemoteMediaPlayerBridge_pause(env, java_bridge_.obj());
+    time_update_timer_.Stop();
   }
 }
 
@@ -241,15 +181,6 @@ void RemoteMediaPlayerBridge::OnPaused(JNIEnv* env, jobject obj) {
   static_cast<RemoteMediaPlayerManager *>(manager())->OnPaused(player_id());
 }
 
-void RemoteMediaPlayerBridge::OnRouteSelected(JNIEnv* env, jobject obj,
-                                              jstring castingMessage) {
-  casting_message_.reset(
-      new std::string(
-          base::android::ConvertJavaStringToUTF8(env, castingMessage)));
-  static_cast<RemoteMediaPlayerManager *>(manager())->OnRemoteDeviceSelected(
-      player_id());
-}
-
 void RemoteMediaPlayerBridge::OnRouteUnselected(JNIEnv* env, jobject obj) {
   casting_message_.reset();
   static_cast<RemoteMediaPlayerManager *>(manager())->OnRemoteDeviceUnselected(
@@ -315,30 +246,6 @@ void RemoteMediaPlayerBridge::OnPlayerDestroyed() {
       env, java_bridge_.obj());
 }
 
-bool RemoteMediaPlayerBridge::IsRemotePlaybackAvailable() const {
-  JNIEnv* env = AttachCurrentThread();
-  CHECK(env);
-
-  jboolean result = Java_RemoteMediaPlayerBridge_isRemotePlaybackAvailable(
-      env, java_bridge_.obj());
-
-  return result;
-}
-
-bool RemoteMediaPlayerBridge::IsRemotePlaybackPreferredForFrame() const {
-  if (in_use_) {
-    // We have already decided to use remote playback
-    return true;
-  }
-  JNIEnv* env = AttachCurrentThread();
-  CHECK(env);
-
-  jboolean result =
-      Java_RemoteMediaPlayerBridge_isRemotePlaybackPreferredForFrame(
-          env, java_bridge_.obj());
-  return result;
-}
-
 std::string RemoteMediaPlayerBridge::GetCastingMessage() {
   return casting_message_ ?
       *casting_message_ : std::string();
@@ -361,51 +268,37 @@ void RemoteMediaPlayerBridge::SetPosterBitmap(
 }
 
 void RemoteMediaPlayerBridge::Start() {
-  if (!in_use_) {
-    pending_play_ = true;
-    Prepare();
-  } else {
-    if (prepared_)
-      StartInternal();
-    else
-      pending_play_ = true;
-  }
+  StartInternal();
 }
 
-void RemoteMediaPlayerBridge::SeekTo(base::TimeDelta timestamp) {
-  // Record the time to seek when OnMediaPrepared() is called.
-  pending_seek_ = timestamp;
-  should_seek_on_prepare_ = true;
+void RemoteMediaPlayerBridge::SeekTo(base::TimeDelta time) {
+  // TODO(aberent) Move the checks to the Java side.
+  base::TimeDelta duration = GetDuration();
 
-  if (!in_use_)
-    Prepare();
-  else if (prepared_)
-    SeekInternal(timestamp);
-}
+  if (time > duration)
+    time = duration;
 
-void RemoteMediaPlayerBridge::Release() {
-  if (!in_use_)
+  // 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;
-  time_update_timer_.Stop();
-  if (prepared_) {
-    pending_seek_ = GetCurrentTime();
-    should_seek_on_prepare_ = true;
   }
 
-  prepared_ = false;
-  pending_play_ = false;
+  JNIEnv* env = AttachCurrentThread();
+  CHECK(env);
+  int time_msec = static_cast<int>(time.InMilliseconds());
+  Java_RemoteMediaPlayerBridge_seekTo(env, java_bridge_.obj(), time_msec);
+}
+
+void RemoteMediaPlayerBridge::Release() {
+  time_update_timer_.Stop();
   JNIEnv* env = AttachCurrentThread();
   Java_RemoteMediaPlayerBridge_release(env, java_bridge_.obj());
   DetachListener();
-  in_use_ = false;
 }
 
 void RemoteMediaPlayerBridge::SetVolume(double volume) {
-  if (!in_use_) {
-    volume_ = volume;
-    return;
-  }
-
   JNIEnv* env = AttachCurrentThread();
   CHECK(env);
   Java_RemoteMediaPlayerBridge_setVolume(
@@ -413,8 +306,6 @@ void RemoteMediaPlayerBridge::SetVolume(double volume) {
 }
 
 base::TimeDelta RemoteMediaPlayerBridge::GetCurrentTime() {
-  if (!prepared_)
-    return pending_seek_;
   JNIEnv* env = AttachCurrentThread();
   return base::TimeDelta::FromMilliseconds(
       Java_RemoteMediaPlayerBridge_getCurrentPosition(
@@ -422,8 +313,6 @@ base::TimeDelta RemoteMediaPlayerBridge::GetCurrentTime() {
 }
 
 base::TimeDelta RemoteMediaPlayerBridge::GetDuration() {
-  if (!prepared_)
-    return duration_;
   JNIEnv* env = AttachCurrentThread();
   const int duration_ms =
       Java_RemoteMediaPlayerBridge_getDuration(env, java_bridge_.obj());
@@ -439,9 +328,6 @@ base::TimeDelta RemoteMediaPlayerBridge::GetDuration() {
 }
 
 bool RemoteMediaPlayerBridge::IsPlaying() {
-  if (!prepared_)
-    return pending_play_;
-
   JNIEnv* env = AttachCurrentThread();
   CHECK(env);
   jboolean result = Java_RemoteMediaPlayerBridge_isPlaying(
@@ -462,7 +348,7 @@ bool RemoteMediaPlayerBridge::CanSeekBackward() {
 }
 
 bool RemoteMediaPlayerBridge::IsPlayerReady() {
-  return prepared_;
+  return true;
 }
 
 GURL RemoteMediaPlayerBridge::GetUrl() {
@@ -483,14 +369,6 @@ void RemoteMediaPlayerBridge::Initialize() {
                  weak_factory_.GetWeakPtr()));
 }
 
-bool RemoteMediaPlayerBridge::IsMediaPlayableRemotely() const {
-  JNIEnv* env = AttachCurrentThread();
-  CHECK(env);
-
-  return Java_RemoteMediaPlayerBridge_isMediaPlayableRemotely(
-      env, java_bridge_.obj());
-}
-
 base::android::ScopedJavaLocalRef<jstring> RemoteMediaPlayerBridge::GetTitle(
     JNIEnv* env, jobject obj) {
   base::string16 title;
@@ -509,6 +387,18 @@ void RemoteMediaPlayerBridge::OnCookiesRetrieved(const std::string& cookies) {
   // 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());
+}
+
+bool RemoteMediaPlayerBridge::TakesOverCastDevice() {
+  JNIEnv* env = AttachCurrentThread();
+  CHECK(env);
+  jboolean result =
+      Java_RemoteMediaPlayerBridge_takesOverCastDevice(env, java_bridge_.obj());
+  return result;
 }
 
-} // namespace remote_media
+}  // namespace remote_media