NOT FOR LANDING Implement WebMediaSession

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"
 #include "content/browser/media/android/browser_demuxer_android.h"
+#include "content/browser/media/android/browser_media_session_manager.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"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/common/media/media_player_messages_android.h"
 #include "content/public/browser/android/external_video_surface_container.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 117 matching lines @@
 #endif
 
 MediaPlayerAndroid* BrowserMediaPlayerManager::CreateMediaPlayer(
     const MediaPlayerHostMsg_Initialize_Params& media_player_params,
     bool hide_url_log,
     BrowserDemuxerAndroid* demuxer) {
   switch (media_player_params.type) {
     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.session_id);
       bool should_block = false;
       bool extract_metadata =
           // Initialize the player will cause MediaMetadataExtractor to decode
           // small chunks of data.
           RequestDecoderResources(media_player_params.player_id, true);
 #if !defined(USE_AURA)
       ContentViewCoreImpl* content_view_core_impl =
           static_cast<ContentViewCoreImpl*>(
               ContentViewCore::FromWebContents(web_contents_));
       if (!content_view_core_impl) {
@@ skipping 12 matching lines @@
                                0, 0, false);
       } else if (!should_block) {
         media_player_bridge->Initialize();
       }
       return media_player_bridge;
     }
 
     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.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.session_id);
       }
     }
   }
 
   NOTREACHED();
   return NULL;
 }
 
 BrowserMediaPlayerManager::BrowserMediaPlayerManager(
     RenderFrameHost* render_frame_host)
     : render_frame_host_(render_frame_host),
       fullscreen_player_id_(kInvalidMediaPlayerId),
       fullscreen_player_is_released_(false),
       web_contents_(WebContents::FromRenderFrameHost(render_frame_host)),
       weak_ptr_factory_(this) {
 }
 
 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);
+  GetMediaSessionManager()->RemovePlayers(this);
   players_.weak_clear();
 }
 
 void BrowserMediaPlayerManager::ExitFullscreen(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_->UpdateMediaMetadata();
 }
 
 void BrowserMediaPlayerManager::OnPlaybackComplete(int player_id) {
   Send(new MediaPlayerMsg_MediaPlaybackCompleted(RoutingID(), player_id));
-  MediaSession::Get(web_contents())->RemovePlayer(this, player_id);
+  GetMediaSessionManager()->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);
@@ skipping 88 matching lines @@
                                             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);
+  MediaPlayerAndroid* player = GetPlayer(player_id);
+  DCHECK(player);
+
+  MediaSession* media_session =
+      GetMediaSessionManager()->GetSession(player->session_id());
+  // Implicit activation of media session unless already activated
+  bool succeeded =
+      media_session->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);
@@ skipping 168 matching lines @@
 }
 
 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)
-    MediaSession::Get(web_contents())->OnPlayerPaused(this, player_id);
+    GetMediaSessionManager()->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);
+  GetMediaSessionManager()->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 12 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);
+      GetMediaSessionManager()->RemovePlayer(this, player_id);
       break;
     }
   }
   active_players_.erase(player_id);
 }
 
 void BrowserMediaPlayerManager::ReleaseResources(int player_id) {
   MediaPlayerAndroid* player = GetPlayer(player_id);
   if (player)
     ReleasePlayer(player);
@@ skipping 98 matching lines @@
   MediaPlayerAndroid* player = GetPlayer(player_id);
   if (!player)
     return;
   player->Start();
   if (fullscreen_player_id_ == player_id && fullscreen_player_is_released_) {
     video_view_->OpenVideo();
     fullscreen_player_is_released_ = false;
   }
 }
 
+BrowserMediaSessionManager*
+BrowserMediaPlayerManager::GetMediaSessionManager() {
+  return MediaWebContentsObserverAndroid::FromWebContents(web_contents())
+      ->GetMediaSessionManager(render_frame_host_);
+}
+
 }  // namespace content