Migrate AudioFocusChangeListener to browser and always send GAIN

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"
@@ skipping 118 matching lines @@
 
 BrowserMediaPlayerManager::BrowserMediaPlayerManager(
     RenderFrameHost* render_frame_host,
     MediaPlayersObserver* audio_monitor)
     : render_frame_host_(render_frame_host),
       audio_monitor_(audio_monitor),
       fullscreen_player_id_(kInvalidMediaPlayerId),
       fullscreen_player_is_released_(false),
       web_contents_(WebContents::FromRenderFrameHost(render_frame_host)),
       weak_ptr_factory_(this) {
+  audio_focus_manager_.reset(new AudioFocusManager(
+      base::MessageLoopProxy::current(), weak_ptr_factory_.GetWeakPtr()));
 }
 
 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.
 }
 
 void BrowserMediaPlayerManager::ExitFullscreen(bool release_media_player) {
@@ skipping 83 matching lines @@
     int player_id,
     const base::TimeDelta& time_to_seek) {
   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;
+    audio_focus_manager_->AbandonAudioFocus((*it)->player_id());
     (*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) {
   Send(new MediaPlayerMsg_MediaError(RoutingID(), player_id, error));
   if (fullscreen_player_id_ == player_id)
     video_view_->OnMediaPlayerError(error);
+  audio_focus_manager_->AbandonAudioFocus(player_id);
 }
 
 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)
     video_view_->OnVideoSizeChanged(width, height);
 }
 
@@ skipping 192 matching lines @@
     return;
 
   AddPlayer(player);
 }
 
 void BrowserMediaPlayerManager::OnStart(int player_id) {
   MediaPlayerAndroid* player = GetPlayer(player_id);
   if (!player)
     return;
   player->Start();
+  audio_focus_manager_->RequestAudioFocus(player_id);
   if (fullscreen_player_id_ == player_id && fullscreen_player_is_released_) {
     video_view_->OpenVideo();
     fullscreen_player_is_released_ = false;
   }
 }
 
 void BrowserMediaPlayerManager::OnSeek(
     int player_id,
     const base::TimeDelta& time) {
   MediaPlayerAndroid* player = GetPlayer(player_id);
@@ skipping 114 matching lines @@
                                                   (*it)->player_id()));
     }
   }
 }
 
 void BrowserMediaPlayerManager::ReleaseMediaResources(int player_id) {
 #if defined(VIDEO_HOLE)
   if (external_video_surface_container_)
     external_video_surface_container_->ReleaseExternalVideoSurface(player_id);
 #endif  // defined(VIDEO_HOLE)
+  audio_focus_manager_->AbandonAudioFocus(player_id);
 }
 
 void BrowserMediaPlayerManager::ReleasePlayer(MediaPlayerAndroid* player) {
   player->Release();
   ReleaseMediaResources(player->player_id());
 }
 
 }  // namespace content