[RemotePlayback] Stop remote playback when disableRemotePlayback is set

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 40 matching lines @@
           manager->GetLocalPlayer(player_id)->frame_url()),
       width_(0),
       height_(0),
       url_(manager->GetLocalPlayer(player_id)->GetUrl()),
       first_party_for_cookies_(
           manager->GetLocalPlayer(player_id)->GetFirstPartyForCookies()),
       user_agent_(user_agent),
       weak_factory_(this) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   JNIEnv* env = base::android::AttachCurrentThread();
-  CHECK(env);
+  DCHECK(env);
   ScopedJavaLocalRef<jstring> j_url_string;
   if (url_.is_valid()) {
     // Escape the URL to make it safe to use. Don't escape existing escape
     // sequences though.
     std::string escaped_url = net::EscapeExternalHandlerValue(url_.spec());
     // 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, j_frame_url_string,
       ConvertUTF8ToJavaString(env, user_agent)));
 }
 
 RemoteMediaPlayerBridge::~RemoteMediaPlayerBridge() {
   JNIEnv* env = base::android::AttachCurrentThread();
-  CHECK(env);
+  DCHECK(env);
   Java_RemoteMediaPlayerBridge_destroy(env, java_bridge_);
   Release();
 }
 
 bool RemoteMediaPlayerBridge::HasVideo() const {
   NOTIMPLEMENTED();
   return true;
 }
 
 bool RemoteMediaPlayerBridge::HasAudio() const {
@@ skipping 161 matching lines @@
   DCHECK(g_RemoteMediaPlayerBridge_clazz);
   return ret;
 }
 
 void RemoteMediaPlayerBridge::RequestRemotePlayback() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   MediaPlayerAndroid* local_player = GetLocalPlayer();
   if (!local_player)
     return;
   JNIEnv* env = AttachCurrentThread();
-  CHECK(env);
+  DCHECK(env);
 
   Java_RemoteMediaPlayerBridge_requestRemotePlayback(
       env, java_bridge_, local_player->GetCurrentTime().InMilliseconds());
 }
 
 void RemoteMediaPlayerBridge::RequestRemotePlaybackControl() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   JNIEnv* env = AttachCurrentThread();
-  CHECK(env);
+  DCHECK(env);
 
   Java_RemoteMediaPlayerBridge_requestRemotePlaybackControl(env, java_bridge_);
 }
 
+void RemoteMediaPlayerBridge::RequestRemotePlaybackStop() {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  JNIEnv* env = AttachCurrentThread();
+  DCHECK(env);
+
+  Java_RemoteMediaPlayerBridge_requestRemotePlaybackStop(env, java_bridge_);
+}
+
 void RemoteMediaPlayerBridge::SetNativePlayer() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   JNIEnv* env = AttachCurrentThread();
-  CHECK(env);
+  DCHECK(env);
 
   Java_RemoteMediaPlayerBridge_setNativePlayer(env, java_bridge_);
 }
 
 void RemoteMediaPlayerBridge::OnPlayerCreated() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   JNIEnv* env = AttachCurrentThread();
-  CHECK(env);
+  DCHECK(env);
 
   Java_RemoteMediaPlayerBridge_onPlayerCreated(env, java_bridge_);
 }
 
 void RemoteMediaPlayerBridge::OnPlayerDestroyed() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   JNIEnv* env = AttachCurrentThread();
-  CHECK(env);
+  DCHECK(env);
 
   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);
+  DCHECK(env);
 
   if (bitmaps.empty()) {
     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_,
                                                  j_poster_bitmap);
   }
@@ skipping 12 matching lines @@
     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);
+  DCHECK(env);
   int time_msec = static_cast<int>(time.InMilliseconds());
   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_);
   DetachListener();
 }
 
 void RemoteMediaPlayerBridge::UpdateEffectiveVolumeInternal(
     double effective_volume) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   JNIEnv* env = AttachCurrentThread();
-  CHECK(env);
+  DCHECK(env);
   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_));
 }
@@ skipping 13 matching lines @@
       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);
+  DCHECK(env);
   jboolean result = Java_RemoteMediaPlayerBridge_isPlaying(env, java_bridge_);
   return result;
 }
 
 bool RemoteMediaPlayerBridge::CanPause() {
   return true;
 }
 
 bool RemoteMediaPlayerBridge::CanSeekForward() {
   return true;
@@ skipping 54 matching lines @@
       ->OnCancelledRemotePlaybackRequest(player_id());
 }
 
 
 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);
+  DCHECK(env);
   Java_RemoteMediaPlayerBridge_setCookies(
       env, java_bridge_, ConvertUTF8ToJavaString(env, cookies));
 }
 
 MediaPlayerAndroid* RemoteMediaPlayerBridge::GetLocalPlayer() {
   return static_cast<RemoteMediaPlayerManager*>(manager())->GetLocalPlayer(
       player_id());
 }
 
 }  // namespace remote_media