1 files changed, 54 insertions, 86 deletions

diff --git a/chromium/content/browser/media/android/browser_media_player_manager.cc b/chromium/content/browser/media/android/browser_media_player_manager.cc
index 0622043448b..96f6fcde97c 100644
--- a/chromium/content/browser/media/android/browser_media_player_manager.cc
+++ b/chromium/content/browser/media/android/browser_media_player_manager.cc
@@ -10,7 +10,6 @@
 #include "content/browser/frame_host/render_frame_host_impl.h"
 #include "content/browser/media/android/browser_demuxer_android.h"
 #include "content/browser/media/android/media_resource_getter_impl.h"
-#include "content/browser/media/android/media_session.h"
 #include "content/browser/media/android/media_throttler.h"
 #include "content/browser/media/android/media_web_contents_observer_android.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
@@ -52,9 +51,6 @@ namespace content {
 const int kMediaPlayerThreshold = 1;
 const int kInvalidMediaPlayerId = -1;
 
-// Minimal duration of a media player in order to be considered as Content type.
-const int kMinimumDurationForContentInSeconds = 5;
-
 static BrowserMediaPlayerManager::Factory g_factory = NULL;
 static media::MediaUrlInterceptor* media_url_interceptor_ = NULL;
 
@@ -147,16 +143,13 @@ MediaPlayerAndroid* BrowserMediaPlayerManager::CreateMediaPlayer(
     case MEDIA_PLAYER_TYPE_URL: {
       const std::string user_agent = GetContentClient()->GetUserAgent();
       MediaPlayerBridge* media_player_bridge = new MediaPlayerBridge(
-          media_player_params.player_id,
-          media_player_params.url,
-          media_player_params.first_party_for_cookies,
-          user_agent,
-          hide_url_log,
+          media_player_params.player_id, media_player_params.url,
+          media_player_params.first_party_for_cookies, user_agent, hide_url_log,
           this,
           base::Bind(&BrowserMediaPlayerManager::OnDecoderResourcesReleased,
                      weak_ptr_factory_.GetWeakPtr()),
-          media_player_params.frame_url,
-          media_player_params.allow_credentials);
+          media_player_params.frame_url, media_player_params.allow_credentials,
+          media_player_params.media_session_id);
 
       if (media_player_params.type == MEDIA_PLAYER_TYPE_REMOTE_ONLY)
         return media_player_bridge;
@@ -193,20 +186,20 @@ MediaPlayerAndroid* BrowserMediaPlayerManager::CreateMediaPlayer(
     case MEDIA_PLAYER_TYPE_MEDIA_SOURCE: {
       if (media::UseMediaThreadForMediaPlayback()) {
         return new MediaCodecPlayer(
-            media_player_params.player_id,
-            weak_ptr_factory_.GetWeakPtr(),
+            media_player_params.player_id, weak_ptr_factory_.GetWeakPtr(),
             base::Bind(&BrowserMediaPlayerManager::OnDecoderResourcesReleased,
                        weak_ptr_factory_.GetWeakPtr()),
             demuxer->CreateDemuxer(media_player_params.demuxer_client_id),
-            media_player_params.frame_url);
+            media_player_params.frame_url,
+            media_player_params.media_session_id);
       } else {
         return new MediaSourcePlayer(
-            media_player_params.player_id,
-            this,
+            media_player_params.player_id, this,
             base::Bind(&BrowserMediaPlayerManager::OnDecoderResourcesReleased,
                        weak_ptr_factory_.GetWeakPtr()),
             demuxer->CreateDemuxer(media_player_params.demuxer_client_id),
-            media_player_params.frame_url);
+            media_player_params.frame_url,
+            media_player_params.media_session_id);
       }
     }
   }
@@ -233,11 +226,10 @@ BrowserMediaPlayerManager::~BrowserMediaPlayerManager() {
   for (MediaPlayerAndroid* player : players_)
     player->DeleteOnCorrectThread();
 
-  MediaSession::Get(web_contents())->RemovePlayers(this);
   players_.weak_clear();
 }
 
-void BrowserMediaPlayerManager::ExitFullscreen(bool release_media_player) {
+void BrowserMediaPlayerManager::DidExitFullscreen(bool release_media_player) {
 #if defined(USE_AURA)
   // TODO(crbug.com/548024)
   NOTIMPLEMENTED();
@@ -289,6 +281,13 @@ void BrowserMediaPlayerManager::SetVideoSurface(
   if (empty_surface)
     return;
 
+  // If we already know the size, set it now. Otherwise it will be set when the
+  // player gets it.
+  if (player->IsPlayerReady()) {
+    video_view_->OnVideoSizeChanged(player->GetVideoWidth(),
+                                    player->GetVideoHeight());
+  }
+
 #if !defined(USE_AURA)
   if (RenderWidgetHostViewAndroid* view_android =
       static_cast<RenderWidgetHostViewAndroid*>(
@@ -304,21 +303,16 @@ void BrowserMediaPlayerManager::OnMediaMetadataChanged(
   Send(new MediaPlayerMsg_MediaMetadataChanged(
       RoutingID(), player_id, duration, width, height, success));
   if (fullscreen_player_id_ == player_id)
-    video_view_->UpdateMediaMetadata();
+    video_view_->OnVideoSizeChanged(width, height);
 }
 
 void BrowserMediaPlayerManager::OnPlaybackComplete(int player_id) {
   Send(new MediaPlayerMsg_MediaPlaybackCompleted(RoutingID(), player_id));
-  MediaSession::Get(web_contents())->RemovePlayer(this, player_id);
-
-  if (fullscreen_player_id_ == player_id)
-    video_view_->OnPlaybackComplete();
 }
 
 void BrowserMediaPlayerManager::OnMediaInterrupted(int player_id) {
   // Tell WebKit that the audio should be paused, then release all resources
   Send(new MediaPlayerMsg_MediaPlayerReleased(RoutingID(), player_id));
-  MediaSession::Get(web_contents())->RemovePlayer(this, player_id);
   ReleaseResources(player_id);
 }
 
@@ -334,15 +328,6 @@ void BrowserMediaPlayerManager::OnSeekRequest(
   Send(new MediaPlayerMsg_SeekRequest(RoutingID(), player_id, time_to_seek));
 }
 
-void BrowserMediaPlayerManager::ReleaseAllMediaPlayers() {
-  for (ScopedVector<MediaPlayerAndroid>::iterator it = players_.begin();
-      it != players_.end(); ++it) {
-    if ((*it)->player_id() == fullscreen_player_id_)
-      fullscreen_player_is_released_ = true;
-    (*it)->Release();
-  }
-}
-
 void BrowserMediaPlayerManager::OnSeekComplete(
     int player_id,
     const base::TimeDelta& current_time) {
@@ -409,36 +394,12 @@ MediaPlayerAndroid* BrowserMediaPlayerManager::GetPlayer(int player_id) {
 bool BrowserMediaPlayerManager::RequestPlay(int player_id,
                                             base::TimeDelta duration,
                                             bool has_audio) {
-  if (!has_audio)
-    return true;
-
-  MediaSession::Type media_session_type =
-      duration == base::TimeDelta() ||
-              duration.InSeconds() > kMinimumDurationForContentInSeconds
-          ? MediaSession::Type::Content
-          : MediaSession::Type::Transient;
-
-  bool succeeded = MediaSession::Get(web_contents())->AddPlayer(
-      this, player_id, media_session_type);
-  if (!succeeded)
-    Send(new MediaPlayerMsg_DidMediaPlayerPause(RoutingID(), player_id));
-  return succeeded;
-}
-
-void BrowserMediaPlayerManager::OnSuspend(int player_id) {
-  MediaPlayerAndroid* player = GetPlayer(player_id);
-  DCHECK(player);
-
-  player->Pause(true);
-  Send(new MediaPlayerMsg_DidMediaPlayerPause(RoutingID(), player_id));
-}
-
-void BrowserMediaPlayerManager::OnResume(int player_id) {
-  MediaPlayerAndroid* player = GetPlayer(player_id);
-  DCHECK(player);
-
-  player->Start();
-  Send(new MediaPlayerMsg_DidMediaPlayerPlay(RoutingID(), player_id));
+  DCHECK(player_id_to_delegate_id_map_.find(player_id) !=
+         player_id_to_delegate_id_map_.end());
+  return MediaWebContentsObserverAndroid::FromWebContents(web_contents_)
+      ->RequestPlay(render_frame_host_,
+                    player_id_to_delegate_id_map_[player_id], has_audio,
+                    IsPlayingRemotely(player_id), duration);
 }
 
 #if defined(VIDEO_HOLE)
@@ -533,25 +494,29 @@ void BrowserMediaPlayerManager::OnEnterFullscreen(int player_id) {
   if (external_video_surface_container_)
     external_video_surface_container_->ReleaseExternalVideoSurface(player_id);
 #endif  // defined(VIDEO_HOLE)
-  if (video_view_.get()) {
+  if (video_view_) {
     fullscreen_player_id_ = player_id;
     video_view_->OpenVideo();
     return;
-  } else if (!ContentVideoView::GetInstance()) {
+  }
+
+  if (ContentVideoView::GetInstance()) {
     // In Android WebView, two ContentViewCores could both try to enter
     // fullscreen video, we just ignore the second one.
-    video_view_.reset(new ContentVideoView(this));
-    base::android::ScopedJavaLocalRef<jobject> j_content_video_view =
-        video_view_->GetJavaObject(base::android::AttachCurrentThread());
-    if (!j_content_video_view.is_null()) {
-      fullscreen_player_id_ = player_id;
-      return;
-    }
+    Send(new MediaPlayerMsg_DidExitFullscreen(RoutingID(), player_id));
+    return;
   }
 
-  // Force the second video to exit fullscreen.
-  Send(new MediaPlayerMsg_DidExitFullscreen(RoutingID(), player_id));
-  video_view_.reset();
+  // There's no ContentVideoView instance so create one.
+  video_view_.reset(new ContentVideoView(this, GetContentViewCore()));
+  base::android::ScopedJavaLocalRef<jobject> j_content_video_view =
+      video_view_->GetJavaObject(base::android::AttachCurrentThread());
+  if (!j_content_video_view.is_null()) {
+    fullscreen_player_id_ = player_id;
+  } else {
+    Send(new MediaPlayerMsg_DidExitFullscreen(RoutingID(), player_id));
+    video_view_.reset();
+  }
 #endif  // defined(USE_AURA)
 }
 
@@ -574,7 +539,7 @@ void BrowserMediaPlayerManager::OnInitialize(
   if (!player)
     return;
 
-  AddPlayer(player);
+  AddPlayer(player, media_player_params.delegate_id);
 }
 
 void BrowserMediaPlayerManager::OnStart(int player_id) {
@@ -606,9 +571,6 @@ void BrowserMediaPlayerManager::OnPause(
   MediaPlayerAndroid* player = GetPlayer(player_id);
   if (player)
     player->Pause(is_media_related_action);
-
-  if (is_media_related_action && !IsPlayingRemotely(player_id))
-    MediaSession::Get(web_contents())->OnPlayerPaused(this, player_id);
 }
 
 void BrowserMediaPlayerManager::OnSetVolume(int player_id, double volume) {
@@ -622,7 +584,6 @@ void BrowserMediaPlayerManager::OnSetPoster(int player_id, const GURL& url) {
 }
 
 void BrowserMediaPlayerManager::OnSuspendAndReleaseResources(int player_id) {
-  MediaSession::Get(web_contents())->RemovePlayer(this, player_id);
   ReleaseResources(player_id);
 }
 
@@ -645,9 +606,12 @@ bool BrowserMediaPlayerManager::IsPlayingRemotely(int player_id) {
   return false;
 }
 
-void BrowserMediaPlayerManager::AddPlayer(MediaPlayerAndroid* player) {
+void BrowserMediaPlayerManager::AddPlayer(
+    MediaPlayerAndroid* player, int delegate_id) {
   DCHECK(!GetPlayer(player->player_id()));
   players_.push_back(player);
+  player_id_to_delegate_id_map_[player->player_id()] =
+      delegate_id;
 }
 
 void BrowserMediaPlayerManager::DestroyPlayer(int player_id) {
@@ -659,11 +623,11 @@ void BrowserMediaPlayerManager::DestroyPlayer(int player_id) {
 #endif
       (*it)->DeleteOnCorrectThread();
       players_.weak_erase(it);
-      MediaSession::Get(web_contents())->RemovePlayer(this, player_id);
       break;
     }
   }
   active_players_.erase(player_id);
+  player_id_to_delegate_id_map_.erase(player_id);
 }
 
 void BrowserMediaPlayerManager::ReleaseResources(int player_id) {
@@ -674,8 +638,9 @@ void BrowserMediaPlayerManager::ReleaseResources(int player_id) {
     fullscreen_player_is_released_ = true;
 }
 
-scoped_ptr<media::MediaPlayerAndroid> BrowserMediaPlayerManager::SwapPlayer(
-      int player_id, media::MediaPlayerAndroid* player) {
+std::unique_ptr<media::MediaPlayerAndroid>
+BrowserMediaPlayerManager::SwapPlayer(int player_id,
+                                      media::MediaPlayerAndroid* player) {
   media::MediaPlayerAndroid* previous_player = NULL;
   for (ScopedVector<MediaPlayerAndroid>::iterator it = players_.begin();
       it != players_.end(); ++it) {
@@ -684,12 +649,15 @@ scoped_ptr<media::MediaPlayerAndroid> BrowserMediaPlayerManager::SwapPlayer(
 #if defined(VIDEO_HOLE)
       ReleaseExternalSurface(player_id);
 #endif
+      MediaWebContentsObserverAndroid::FromWebContents(web_contents_)
+          ->DisconnectMediaSession(render_frame_host_,
+                                   player_id_to_delegate_id_map_[player_id]);
       players_.weak_erase(it);
       players_.push_back(player);
       break;
     }
   }
-  return scoped_ptr<media::MediaPlayerAndroid>(previous_player);
+  return std::unique_ptr<media::MediaPlayerAndroid>(previous_player);
 }
 
 bool BrowserMediaPlayerManager::RequestDecoderResources(