Let MediaSession store duck state instead of volume multiplier

content/browser/media/session/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/session/media_session.h"
 
 #include <stddef.h>
 
 #include <list>
 #include <vector>
@@ skipping 16 matching lines @@
 using content::MediaSession;
 using content::MediaSessionDelegate;
 using content::MediaSessionObserver;
 using content::MediaSessionUmaHelper;
 using content::MockMediaSessionObserver;
 
 using ::testing::Expectation;
 
 namespace {
 
+const double kDefaultVolumeMultiplier = 1.0;
+const double kDuckingVolumeMultiplier = 0.2;
+
 class MockMediaSessionDelegate : public MediaSessionDelegate {
  public:
   bool RequestAudioFocus(content::AudioFocusManager::AudioFocusType) override {
     return true;
   }
 
   void AbandonAudioFocus() override {
   }
 };
 
@@ skipping 83 matching lines @@
     media_session_->Suspend(MediaSession::SuspendType::UI);
   }
 
   void SystemSuspend(bool temporary) {
     media_session_->OnSuspendInternal(
         MediaSession::SuspendType::SYSTEM,
         temporary ? MediaSession::State::SUSPENDED
                   : MediaSession::State::INACTIVE);
   }
 
-  void SystemSetVolumeMultiplier(double volume_multiplier) {
-    media_session_->SetVolumeMultiplier(volume_multiplier);
+  void SystemStartDucking() {
+    media_session_->StartDucking();
+  }
+
+  void SystemStopDucking() {
+    media_session_->StopDucking();
   }
 
   MockWebContentsObserver* mock_web_contents_observer() {
     return mock_web_contents_observer_.get();
   }
 
   std::unique_ptr<MediaSession> CreateDummyMediaSession() {
     return std::unique_ptr<MediaSession>(new MediaSession(nullptr));
   }
 
@@ skipping 107 matching lines @@
 
   StartNewPlayer(media_session_observer.get(),
                  media::MediaContentType::Persistent);
 
   EXPECT_FALSE(media_session_observer->IsPlaying(0));
   EXPECT_TRUE(media_session_observer->IsPlaying(1));
   EXPECT_TRUE(media_session_observer->IsPlaying(2));
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest,
-                       MediaSessionSetVolumeMultiplier) {
+                       InitialVolumeMultiplier) {
   std::unique_ptr<MockMediaSessionObserver> media_session_observer(
       new MockMediaSessionObserver);
 
+  StartNewPlayer(media_session_observer.get(),
+                 media::MediaContentType::Persistent);
+  StartNewPlayer(media_session_observer.get(),
+                 media::MediaContentType::Persistent);
+
+  EXPECT_EQ(kDefaultVolumeMultiplier,
+            media_session_observer->GetVolumeMultiplier(0));
+  EXPECT_EQ(kDefaultVolumeMultiplier,
+            media_session_observer->GetVolumeMultiplier(1));
+
+}
+
+IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest,
+                       StartDuckingReducesVolumeMultiplier) {
+  std::unique_ptr<MockMediaSessionObserver> media_session_observer(
+      new MockMediaSessionObserver);
+
   StartNewPlayer(media_session_observer.get(),
                  media::MediaContentType::Persistent);
   StartNewPlayer(media_session_observer.get(),
                  media::MediaContentType::Persistent);
+  SystemStartDucking();
 
-  double volume_multiplier = 0.2f;
-  SystemSetVolumeMultiplier(volume_multiplier);
-
-  EXPECT_EQ(volume_multiplier, media_session_observer->GetVolumeMultiplier(0));
-  EXPECT_EQ(volume_multiplier, media_session_observer->GetVolumeMultiplier(1));
+  EXPECT_EQ(kDuckingVolumeMultiplier,
+            media_session_observer->GetVolumeMultiplier(0));
+  EXPECT_EQ(kDuckingVolumeMultiplier,
+            media_session_observer->GetVolumeMultiplier(1));
 
   StartNewPlayer(media_session_observer.get(),
                  media::MediaContentType::Persistent);
 
-  EXPECT_EQ(volume_multiplier, media_session_observer->GetVolumeMultiplier(2));
+  EXPECT_EQ(kDuckingVolumeMultiplier,
+            media_session_observer->GetVolumeMultiplier(2));
+}
+
+IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest,
+                       StopDuckingRecoversVolumeMultiplier) {
+  std::unique_ptr<MockMediaSessionObserver> media_session_observer(
+      new MockMediaSessionObserver);
+
+  StartNewPlayer(media_session_observer.get(),
+                 media::MediaContentType::Persistent);
+  StartNewPlayer(media_session_observer.get(),
+                 media::MediaContentType::Persistent);
+  SystemStartDucking();
+  SystemStopDucking();
+
+  EXPECT_EQ(kDefaultVolumeMultiplier,
+            media_session_observer->GetVolumeMultiplier(0));
+  EXPECT_EQ(kDefaultVolumeMultiplier,
+            media_session_observer->GetVolumeMultiplier(1));
+
+  StartNewPlayer(media_session_observer.get(),
+                 media::MediaContentType::Persistent);
+
+  EXPECT_EQ(kDefaultVolumeMultiplier,
+            media_session_observer->GetVolumeMultiplier(2));
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, AudioFocusInitialState) {
   EXPECT_FALSE(HasAudioFocus());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, StartPlayerGivesFocus) {
   std::unique_ptr<MockMediaSessionObserver> media_session_observer(
       new MockMediaSessionObserver);
 
@@ skipping 991 matching lines @@
                  media::MediaContentType::Persistent);
   clock->Advance(base::TimeDelta::FromMilliseconds(1000));
   media_session_->Stop(MediaSession::SuspendType::UI);
 
   std::unique_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));
 }