Mute audio for Spitzer playbacks that haven't received focus yet.

content/browser/media/android/media_session.cc

 // Copyright 2015 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/media_session.h"
 
 #include "base/android/context_utils.h"
 #include "base/android/jni_android.h"
 #include "content/browser/media/android/media_session_observer.h"
 #include "content/browser/web_contents/web_contents_impl.h"
@@ skipping 45 matching lines @@
 }
 
 MediaSession::~MediaSession() {
   DCHECK(players_.empty());
   DCHECK(audio_focus_state_ == State::INACTIVE);
 }
 
 bool MediaSession::AddPlayer(MediaSessionObserver* observer,
                              int player_id,
                              Type type) {
-  observer->OnSetVolumeMultiplier(player_id, volume_multiplier_);
-
   // If the audio focus is already granted and is of type Content, there is
   // nothing to do. If it is granted of type Transient the requested type is
   // also transient, there is also nothing to do. Otherwise, the session needs
   // to request audio focus again.
   if (audio_focus_state_ == State::ACTIVE &&
       (audio_focus_type_ == Type::Content || audio_focus_type_ == type)) {
     players_.insert(PlayerIdentifier(observer, player_id));
-    return true;
+  } else {
+    State old_audio_focus_state = audio_focus_state_;
+    State audio_focus_state = RequestSystemAudioFocus(type) ? State::ACTIVE
+                                                            : State::INACTIVE;
+    SetAudioFocusState(audio_focus_state);
+    audio_focus_type_ = type;
+
+    if (audio_focus_state_ != State::ACTIVE)
+      return false;
+
+    // The session should be reset if a player is starting while all players are
+    // suspended.
+    if (old_audio_focus_state != State::ACTIVE)
+      players_.clear();
+
+    players_.insert(PlayerIdentifier(observer, player_id));
+    UpdateWebContents();
   }
 
-  State old_audio_focus_state = audio_focus_state_;
-  State audio_focus_state = RequestSystemAudioFocus(type) ? State::ACTIVE
-                                                          : State::INACTIVE;
-  SetAudioFocusState(audio_focus_state);
-  audio_focus_type_ = type;
-
-  if (audio_focus_state_ != State::ACTIVE)
-    return false;
-
-  // The session should be reset if a player is starting while all players are
-  // suspended.
-  if (old_audio_focus_state != State::ACTIVE)
-    players_.clear();
-
-  players_.insert(PlayerIdentifier(observer, player_id));
-  UpdateWebContents();
-
+  // Unmute audio for observers which may have started playing asynchronously in
+  // a muted state while waiting for the focus approval.
+  observer->OnSetVolumeMultiplier(player_id, volume_multiplier_);
   return true;
 }
 
 void MediaSession::RemovePlayer(MediaSessionObserver* observer,
                                 int player_id) {
   auto it = players_.find(PlayerIdentifier(observer, player_id));
   if (it != players_.end())
     players_.erase(it);
 
   AbandonSystemAudioFocusIfNeeded();
@@ skipping 93 matching lines @@
   // TODO(mlamouri): should be == State::SUSPENDED.
   return audio_focus_state_ != State::ACTIVE;
 }
 
 bool MediaSession::IsControllable() const {
   // Only content type media session can be controllable unless it is inactive.
   return audio_focus_state_ != State::INACTIVE &&
          audio_focus_type_ == Type::Content;
 }
 
-void MediaSession::ResetJavaRefForTest() {
-  j_media_session_.Reset();
-}
-
-bool MediaSession::IsActiveForTest() const {
-  return audio_focus_state_ == State::ACTIVE;
-}
-
-MediaSession::Type MediaSession::audio_focus_type_for_test() const {
-  return audio_focus_type_;
-}
-
-MediaSessionUmaHelper* MediaSession::uma_helper_for_test() {
-  return &uma_helper_;
-}
-
-void MediaSession::RemoveAllPlayersForTest() {
-  players_.clear();
-  AbandonSystemAudioFocusIfNeeded();
-}
-
 void MediaSession::OnSuspendInternal(SuspendType type, State new_state) {
   DCHECK(new_state == State::SUSPENDED || new_state == State::INACTIVE);
   // UI suspend cannot use State::INACTIVE.
   DCHECK(type == SuspendType::SYSTEM || new_state == State::SUSPENDED);
 
   switch (type) {
     case SuspendType::UI:
       uma_helper_.RecordSessionSuspended(MediaSessionSuspendedSource::UI);
       break;
     case SuspendType::SYSTEM:
@@ skipping 43 matching lines @@
 }
 
 void MediaSession::OnSetVolumeMultiplierInternal(double volume_multiplier) {
   volume_multiplier_ = volume_multiplier;
   for (const auto& it : players_)
     it.observer->OnSetVolumeMultiplier(it.player_id, volume_multiplier_);
 }
 
 MediaSession::MediaSession(WebContents* web_contents)
     : WebContentsObserver(web_contents),
+      default_system_audio_focus_response_(true),
       audio_focus_state_(State::INACTIVE),
       audio_focus_type_(Type::Transient),
       volume_multiplier_(media::MediaPlayerAndroid::kDefaultVolumeMultiplier) {
 }
 
 void MediaSession::Initialize() {
   JNIEnv* env = base::android::AttachCurrentThread();
   DCHECK(env);
   j_media_session_.Reset(Java_MediaSession_createMediaSession(
       env,
       base::android::GetApplicationContext(),
       reinterpret_cast<intptr_t>(this)));
 }
 
 bool MediaSession::RequestSystemAudioFocus(Type type) {
   // During tests, j_media_session_ might be null.
   if (j_media_session_.is_null())
-    return true;
+    return default_system_audio_focus_response_;
 
   JNIEnv* env = base::android::AttachCurrentThread();
   DCHECK(env);
   bool result = Java_MediaSession_requestAudioFocus(env, j_media_session_.obj(),
                                                     type == Type::Transient);
   uma_helper_.RecordRequestAudioFocusResult(result);
   return result;
 }
 
 void MediaSession::AbandonSystemAudioFocusIfNeeded() {
@@ skipping 27 matching lines @@
     case State::SUSPENDED:
       uma_helper_.OnSessionSuspended();
       break;
     case State::INACTIVE:
       uma_helper_.OnSessionInactive();
       break;
   }
 }
 
 }  // namespace content