Implement MediaSession on top of the WebMediaPlayerDelegate.

content/browser/media/android/browser_media_player_manager.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 "content/browser/media/android/browser_media_player_manager.h"
 
 #include <utility>
 
 #include "base/android/scoped_java_ref.h"
 #include "content/browser/frame_host/render_frame_host_impl.h"
@@ skipping 34 matching lines @@
 using media::MediaPlayerManager;
 using media::MediaSourcePlayer;
 
 namespace content {
 
 // Threshold on the number of media players per renderer before we start
 // attempting to release inactive media players.
 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;
 
 // static
 void BrowserMediaPlayerManager::RegisterFactory(Factory factory) {
   // TODO(aberent) nullptr test is a temporary fix to simplify upstreaming Cast.
   // Until Cast is fully upstreamed we want the downstream factory to take
   // priority over the upstream factory. The downstream call happens first,
   // so this will ensure that it does.
   if (g_factory == nullptr)
@@ skipping 158 matching lines @@
 
 BrowserMediaPlayerManager::~BrowserMediaPlayerManager() {
   // During the tear down process, OnDestroyPlayer() may or may not be called
   // (e.g. the WebContents may be destroyed before the render process). So
   // we cannot DCHECK(players_.empty()) here. Instead, all media players in
   // |players_| will be destroyed here because |player_| is a ScopedVector.
 
   for (MediaPlayerAndroid* player : players_)
     player->DeleteOnCorrectThread();
 
-  MediaSession::Get(web_contents())->RemovePlayers(this);
   players_.weak_clear();
 }
 
 void BrowserMediaPlayerManager::DidExitFullscreen(bool release_media_player) {
 #if defined(USE_AURA)
   // TODO(crbug.com/548024)
   NOTIMPLEMENTED();
 #else
   if (WebContentsDelegate* delegate = web_contents_->GetDelegate())
     delegate->ExitFullscreenModeForTab(web_contents_);
@@ skipping 55 matching lines @@
     int player_id, base::TimeDelta duration, int width, int height,
     bool success) {
   Send(new MediaPlayerMsg_MediaMetadataChanged(
       RoutingID(), player_id, duration, width, height, success));
   if (fullscreen_player_id_ == player_id)
     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);
 }
 
 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);
 }
 
 void BrowserMediaPlayerManager::OnBufferingUpdate(int player_id,
                                                   int percentage) {
   Send(new MediaPlayerMsg_MediaBufferingUpdate(RoutingID(), player_id,
                                                percentage));
 }
 
 void BrowserMediaPlayerManager::OnSeekRequest(
@@ skipping 70 matching lines @@
       it != players_.end(); ++it) {
     if ((*it)->player_id() == player_id)
       return *it;
   }
   return NULL;
 }
 
 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));
-}
-
-void BrowserMediaPlayerManager::OnSetVolumeMultiplier(
-    int player_id, double volume_multiplier) {
-  MediaPlayerAndroid* player = GetPlayer(player_id);
-  if (!player)
-    return;
-
-  player->SetVolumeMultiplier(volume_multiplier);
+  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)
 void BrowserMediaPlayerManager::AttachExternalVideoSurface(int player_id,
                                                            jobject surface) {
   MediaPlayerAndroid* player = GetPlayer(player_id);
   if (player) {
     player->SetVideoSurface(
         gfx::ScopedJavaSurface::AcquireExternalSurface(surface));
   }
@@ skipping 124 matching lines @@
   RenderProcessHostImpl* host = static_cast<RenderProcessHostImpl*>(
       web_contents()->GetRenderProcessHost());
   MediaPlayerAndroid* player =
       CreateMediaPlayer(media_player_params,
                         host->GetBrowserContext()->IsOffTheRecord(),
                         host->browser_demuxer_android().get());
 
   if (!player)
     return;
 
+  player_id_to_delegate_id_map_[media_player_params.player_id] =
+      media_player_params.delegate_id;
   AddPlayer(player);

[Tima Vaisburd, 2016/01/26 07:10:14]

Do we need consistency between |players_| and |player_id_to_delegate_id_map_| ?
In this case should AddPlayer() be private?

[DaleCurtis, 2016/01/26 16:17:58]

Yes, that seems reasonable. I don't see anyone using it externally?

[Tima Vaisburd, 2016/01/26 18:44:20]

Neither do I.

[DaleCurtis, 2016/01/27 02:25:13]

Done.

 }
 
 void BrowserMediaPlayerManager::OnStart(int player_id) {
   MediaPlayerAndroid* player = GetPlayer(player_id);
   if (!player)
     return;
 
   if (RequestDecoderResources(player_id, false)) {
     StartInternal(player_id);
   } else if (WebContentsDelegate* delegate = web_contents_->GetDelegate()){
@@ skipping 11 matching lines @@
   if (player)
     player->SeekTo(time);
 }
 
 void BrowserMediaPlayerManager::OnPause(
     int player_id,
     bool is_media_related_action) {
   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) {
   MediaPlayerAndroid* player = GetPlayer(player_id);
   if (player)
     player->SetVolume(volume);
 }
 
 void BrowserMediaPlayerManager::OnSetPoster(int player_id, const GURL& url) {
   // To be overridden by subclasses.
 }
 
 void BrowserMediaPlayerManager::OnSuspendAndReleaseResources(int player_id) {
-  MediaSession::Get(web_contents())->RemovePlayer(this, player_id);
   ReleaseResources(player_id);
 }
 
 void BrowserMediaPlayerManager::OnDestroyPlayer(int player_id) {
   DestroyPlayer(player_id);
   if (fullscreen_player_id_ == player_id)
     fullscreen_player_id_ = kInvalidMediaPlayerId;
 }
 
 void BrowserMediaPlayerManager::OnRequestRemotePlayback(int /* player_id */) {
@@ skipping 16 matching lines @@
 
 void BrowserMediaPlayerManager::DestroyPlayer(int player_id) {
   for (ScopedVector<MediaPlayerAndroid>::iterator it = players_.begin();
       it != players_.end(); ++it) {
     if ((*it)->player_id() == player_id) {
 #if defined(VIDEO_HOLE)
       ReleaseExternalSurface(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) {
   MediaPlayerAndroid* player = GetPlayer(player_id);
   if (player)
     ReleasePlayer(player);
   if (player_id == fullscreen_player_id_)
     fullscreen_player_is_released_ = true;
 }
 
@@ skipping 95 matching lines @@
   if (!player)
     return;
   player->Start();
   if (fullscreen_player_id_ == player_id && fullscreen_player_is_released_) {
     video_view_->OpenVideo();
     fullscreen_player_is_released_ = false;
   }
 }
 
 }  // namespace content