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

content/browser/media/android/media_session_browsertest.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 <stddef.h>
 
 #include <list>
 #include <vector>
@@ skipping 115 matching lines @@
 class MediaSessionBrowserTest : public content::ContentBrowserTest {
  protected:
   MediaSessionBrowserTest() = default;
 
   void SetUpOnMainThread() override {
     ContentBrowserTest::SetUpOnMainThread();
 
     mock_web_contents_observer_.reset(
         new MockWebContentsObserver(shell()->web_contents()));
     media_session_ = MediaSession::Get(shell()->web_contents());
-    media_session_->ResetJavaRefForTest();
+    // Reset |j_media_session_| ref to prevent calling the Java backend.
+    media_session_->j_media_session_.Reset();
+
     ASSERT_TRUE(media_session_);
   }
 
   void TearDownOnMainThread() override {
     mock_web_contents_observer_.reset();
 
-    media_session_->RemoveAllPlayersForTest();
+    media_session_->players_.clear();
+    media_session_->AbandonSystemAudioFocusIfNeeded();
     media_session_ = nullptr;
 
     ContentBrowserTest::TearDownOnMainThread();
   }
 
   void StartNewPlayer(MockMediaSessionObserver* media_session_observer,
                       MediaSession::Type type) {
     bool result = AddPlayer(
         media_session_observer,
         media_session_observer->StartNewPlayer(),
@@ skipping 14 matching lines @@
 
   void RemovePlayers(MockMediaSessionObserver* media_session_observer) {
     media_session_->RemovePlayers(media_session_observer);
   }
 
   void OnPlayerPaused(MockMediaSessionObserver* media_session_observer,
                       int player_id) {
     media_session_->OnPlayerPaused(media_session_observer, player_id);
   }
 
-  bool HasAudioFocus() { return media_session_->IsActiveForTest(); }
+  bool HasAudioFocus() const {
+    return media_session_->audio_focus_state_ == MediaSession::State::ACTIVE;
+  }
 
-  MediaSession::Type GetSessionType() {
-    return media_session_->audio_focus_type_for_test();
+  MediaSession::Type GetSessionType() const {
+    return media_session_->audio_focus_type_;
   }
 
   bool IsControllable() { return media_session_->IsControllable(); }
 
   bool IsSuspended() { return media_session_->IsSuspended(); }
 
   void UIResume() {
     media_session_->Resume();
   }
 
@@ skipping 16 matching lines @@
 
   MockWebContentsObserver* mock_web_contents_observer() {
     return mock_web_contents_observer_.get();
   }
 
   scoped_ptr<MediaSession> CreateDummyMediaSession() {
       return scoped_ptr<MediaSession>(new MediaSession(nullptr));
   }
 
   MediaSessionUmaHelper* GetMediaSessionUMAHelper() {
-    return media_session_->uma_helper_for_test();
+    return &media_session_->uma_helper_;
+  }
+
+  void SetSystemAudioFocusResponse(bool value) {
+    media_session_->default_system_audio_focus_response_ = value;
   }
 
  protected:
   MediaSession* media_session_;
   scoped_ptr<MockWebContentsObserver> mock_web_contents_observer_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaSessionBrowserTest);
 };
 
 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest,
@@ skipping 98 matching lines @@
   SystemSetVolumeMultiplier(volume_multiplier);
 
   EXPECT_EQ(volume_multiplier, media_session_observer->GetVolumeMultiplier(0));
   EXPECT_EQ(volume_multiplier, media_session_observer->GetVolumeMultiplier(1));
 
   StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
 
   EXPECT_EQ(volume_multiplier, media_session_observer->GetVolumeMultiplier(2));
 }
 
+IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest,
+                       VolumeMultiplierOnlySetOnSuccess) {
+  scoped_ptr<MockMediaSessionObserver> media_session_observer(
+      new MockMediaSessionObserver);
+
+  // Start a new player and initialize it's volume multiplier to zero.
+  const int player_id = media_session_observer->StartNewPlayer();
+  media_session_observer->OnSetVolumeMultiplier(player_id, 0);
+
+  // Force the MediaSession to deny the player request.
+  SetSystemAudioFocusResponse(false);
+
+  // Verify AddPlayer fails and that the volume multiplier is unchanged.
+  EXPECT_FALSE(AddPlayer(media_session_observer.get(), player_id,
+                         MediaSession::Type::Content));
+  EXPECT_DOUBLE_EQ(0, media_session_observer->GetVolumeMultiplier(player_id));
+
+  // Repeat the test with transient type session.
+  EXPECT_FALSE(AddPlayer(media_session_observer.get(), player_id,
+                         MediaSession::Type::Transient));
+  EXPECT_DOUBLE_EQ(0, media_session_observer->GetVolumeMultiplier(player_id));
+
+  // Reset the MediaSession to allow the player request.
+  SetSystemAudioFocusResponse(true);
+  EXPECT_TRUE(AddPlayer(media_session_observer.get(), player_id,
+                        MediaSession::Type::Content));
+  EXPECT_DOUBLE_EQ(1, media_session_observer->GetVolumeMultiplier(player_id));
+
+  // Start a second player with a volume multiplier of zero then verify that it
+  // receives a multiplier update even when there's an existing active focus.
+  ASSERT_TRUE(HasAudioFocus());
+  const int player_id2 = media_session_observer->StartNewPlayer();
+  media_session_observer->OnSetVolumeMultiplier(player_id2, 0);
+  EXPECT_TRUE(AddPlayer(media_session_observer.get(), player_id2,
+                        MediaSession::Type::Content));
+  EXPECT_DOUBLE_EQ(1, media_session_observer->GetVolumeMultiplier(player_id2));
+}
+
 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, AudioFocusInitialState) {
   EXPECT_FALSE(HasAudioFocus());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, StartPlayerGivesFocus) {
   scoped_ptr<MockMediaSessionObserver> media_session_observer(
       new MockMediaSessionObserver);
 
   StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
 
@@ skipping 917 matching lines @@
   StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
   clock->Advance(base::TimeDelta::FromMilliseconds(1000));
   media_session_->Stop();
 
   scoped_ptr<base::HistogramSamples> samples(
       tester.GetHistogramSamplesSinceCreation("Media.Session.ActiveTime"));
   EXPECT_EQ(2, samples->TotalCount());
   EXPECT_EQ(1, samples->GetCount(1000));
   EXPECT_EQ(1, samples->GetCount(10000));
 }