Move audio focus control from media/ to content/ and make it per WebContents.

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 "base/android/scoped_java_ref.h"
 #include "base/command_line.h"
 #include "content/browser/android/content_view_core_impl.h"
 #include "content/browser/android/media_players_observer.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/renderer_host/render_view_host_impl.h"
 #include "content/browser/web_contents/web_contents_view_android.h"
 #include "content/common/media/media_player_messages_android.h"
 #include "content/public/browser/android/content_view_core.h"
 #include "content/public/browser/android/external_video_surface_container.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
@@ skipping 130 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())->AbandonAudioFocus(this);

[whywhat, 2015/05/12 12:50:44]

nit: s/Get/From?

[mlamouri (slow - plz ping), 2015/05/19 21:56:15]

I used ::Get() instead of ::From() because ::FromWebContents() is used to return
a WebContentsUserData but wouldn't create it by default. ::Get() will create the
instance if needed, like a singleton pattern.

   players_.weak_clear();
 }
 
 void BrowserMediaPlayerManager::ExitFullscreen(bool release_media_player) {
   if (WebContentsDelegate* delegate = web_contents_->GetDelegate())
     delegate->ExitFullscreenModeForTab(web_contents_);
   if (RenderWidgetHostViewAndroid* view_android =
       static_cast<RenderWidgetHostViewAndroid*>(
           web_contents_->GetRenderWidgetHostView())) {
     view_android->SetOverlayVideoMode(false);
@@ skipping 48 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())->AbandonAudioFocus(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));
   OnReleaseResources(player_id);
 }
 
@@ skipping 19 matching lines @@
     (*it)->Release();
   }
 }
 
 void BrowserMediaPlayerManager::OnSeekComplete(
     int player_id,
     const base::TimeDelta& current_time) {
   Send(new MediaPlayerMsg_SeekCompleted(RoutingID(), player_id, current_time));
 }
 
 void BrowserMediaPlayerManager::OnError(int player_id, int error) {

[qinmin, 2015/05/15 18:06:19]

what should happen to the onError case? We still hold the audio focus?

   Send(new MediaPlayerMsg_MediaError(RoutingID(), player_id, error));
   if (fullscreen_player_id_ == player_id)
     video_view_->OnMediaPlayerError(error);
 }
 
 void BrowserMediaPlayerManager::OnVideoSizeChanged(
     int player_id, int width, int height) {
   Send(new MediaPlayerMsg_MediaVideoSizeChanged(RoutingID(), player_id,
       width, height));
   if (fullscreen_player_id_ == player_id)
@@ skipping 53 matching lines @@
 
   if (fullscreen_player_id_ != kInvalidMediaPlayerId) {
     // TODO(qinmin): Determine the correct error code we should report to WMPA.
     OnError(player_id, MediaPlayerAndroid::MEDIA_ERROR_DECODE);
     return;
   }
 
   Send(new MediaPlayerMsg_RequestFullscreen(RoutingID(), player_id));
 }
 
+bool BrowserMediaPlayerManager::RequestPlay(int player_id) {
+  MediaPlayerAndroid* player = GetPlayer(player_id);

[whywhat, 2015/05/12 12:50:45]

I believe this should return true for remote players or remote players shouldn't
call this method.

[mlamouri (slow - plz ping), 2015/05/19 21:56:15]

Remote players do not call this method AFAICT. However, they grab audiofocus in
their own way from the lockscreen code.

+  DCHECK(player);
+  MediaSession::Type media_session_type =
+      player->GetDuration().InSeconds() > 5 ? MediaSession::Type::Content

[whywhat, 2015/05/12 12:50:45]

5 is a magic constant! make it a named one, please.

[qinmin, 2015/05/15 18:06:19]

You need to special treat duration==0 case. Duration is not available for HLS or
if wifi is not available. 

[mlamouri (slow - plz ping), 2015/05/19 21:56:15]

Oups again.
It seems that we don't get duration==0 for HLS. Also, ::RequestPlay() is called
when the data is loaded and ready to be played so if the wifi isn't available,
this will not be called. Could that be the reason why duration!=0 for HLS?

[qinmin, 2015/05/20 21:35:24]

HLS duration is never trustworthy on android. If wifi isn't available, this will
also be called if the device is on mobile networks. But since startInternal is
always called after prepare(), so the player should have the duration here.

[mlamouri (slow - plz ping), 2015/05/22 15:58:52]

Yeah, we made the call in StartInternal() on purpose so we don't cut other audio
if the player ends up not playable.

My understanding is that there is nothing to change here, let me know if I'm
misunderstanding.

+                                            : MediaSession::Type::Transient;
+
+  bool succeeded = MediaSession::Get(web_contents())->RequestAudioFocus(
+      this, player_id, media_session_type);
+  if (!succeeded)
+    OnSuspend(player_id);
+  return succeeded;
+}
+
 #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));
   }
 }
 
 void BrowserMediaPlayerManager::DetachExternalVideoSurface(int player_id) {
   MediaPlayerAndroid* player = GetPlayer(player_id);
   if (player)
     player->SetVideoSurface(gfx::ScopedJavaSurface());
 }
 
 void BrowserMediaPlayerManager::OnFrameInfoUpdated() {
   if (fullscreen_player_id_ != kInvalidMediaPlayerId)
     return;
 
   if (external_video_surface_container_)
     external_video_surface_container_->OnFrameInfoUpdated();
 }
 
+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::OnNotifyExternalSurface(
     int player_id, bool is_request, const gfx::RectF& rect) {
   if (!web_contents_)
     return;
 
   if (is_request) {
     OnRequestExternalSurface(player_id, rect);
   }
   if (external_video_surface_container_) {
     external_video_surface_container_->OnExternalVideoSurfacePositionChanged(
@@ skipping 118 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);
+
+  MediaSession::Get(web_contents())->AbandonAudioFocus(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.
@@ skipping 103 matching lines @@
     external_video_surface_container_->ReleaseExternalVideoSurface(player_id);
 #endif  // defined(VIDEO_HOLE)
 }
 
 void BrowserMediaPlayerManager::ReleasePlayer(MediaPlayerAndroid* player) {
   player->Release();
   ReleaseMediaResources(player->player_id());
 }
 
 }  // namespace content