Implement one-shot audio focus inside MediaSession

content/browser/media/session/media_session_impl_browsertest.cc

Index: content/browser/media/session/media_session_impl_browsertest.cc
diff --git a/content/browser/media/session/media_session_impl_browsertest.cc b/content/browser/media/session/media_session_impl_browsertest.cc
index 755bfac19cb2df12615a5523067e96346a2b8495..b02e0903f26b0f753597888a2b0997abe9f7a02d 100644
--- a/content/browser/media/session/media_session_impl_browsertest.cc
+++ b/content/browser/media/session/media_session_impl_browsertest.cc
@@ -33,6 +33,7 @@ using content::MediaSessionUmaHelper;
 using content::MockMediaSessionPlayerObserver;
 
 using ::testing::Expectation;
+using ::testing::_;
 
 namespace {
 
@@ -41,11 +42,13 @@ const double kDuckingVolumeMultiplier = 0.2;
 
 class MockAudioFocusDelegate : public AudioFocusDelegate {
  public:
-  bool RequestAudioFocus(content::AudioFocusManager::AudioFocusType) override {
-    return true;
+  MockAudioFocusDelegate() {
+    ON_CALL(*this, RequestAudioFocus(_)).WillByDefault(::testing::Return(true));
   }
 
-  void AbandonAudioFocus() override {}
+  MOCK_METHOD1(RequestAudioFocus,
+               bool(content::AudioFocusManager::AudioFocusType));
+  MOCK_METHOD0(AbandonAudioFocus, void());
 };
 
 class MockMediaSessionObserver : public MediaSessionObserver {
@@ -70,8 +73,9 @@ class MediaSessionImplBrowserTest : public content::ContentBrowserTest {
     media_session_ = MediaSessionImpl::Get(shell()->web_contents());
     mock_media_session_observer_.reset(
         new MockMediaSessionObserver(media_session_));
+    mock_audio_focus_delegate_ = new MockAudioFocusDelegate();
     media_session_->SetDelegateForTests(
-        std::unique_ptr<AudioFocusDelegate>(new MockAudioFocusDelegate()));
+        std::unique_ptr<AudioFocusDelegate>(mock_audio_focus_delegate_));
     ASSERT_TRUE(media_session_);
   }
 
@@ -144,6 +148,10 @@ class MediaSessionImplBrowserTest : public content::ContentBrowserTest {
     return mock_media_session_observer_.get();
   }
 
+  MockAudioFocusDelegate* mock_audio_focus_delegate() {
+    return mock_audio_focus_delegate_;
+  }
+
   std::unique_ptr<MediaSessionImpl> CreateDummyMediaSession() {
     return std::unique_ptr<MediaSessionImpl>(new MediaSessionImpl(nullptr));
   }
@@ -155,6 +163,7 @@ class MediaSessionImplBrowserTest : public content::ContentBrowserTest {
  protected:
   MediaSessionImpl* media_session_;
   std::unique_ptr<MockMediaSessionObserver> mock_media_session_observer_;
+  MockAudioFocusDelegate* mock_audio_focus_delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaSessionImplBrowserTest);
 };
@@ -888,6 +897,67 @@ IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest,
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest,
+                       ControlsDontShowWhenOneShotIsPresent) {
+  EXPECT_CALL(*mock_media_session_observer(),
+              MediaSessionStateChanged(false, false));
+
+  std::unique_ptr<MockMediaSessionPlayerObserver> player_observer(
+      new MockMediaSessionPlayerObserver);
+
+  StartNewPlayer(player_observer.get(), media::MediaContentType::OneShot);
+
+  EXPECT_FALSE(IsControllable());
+  EXPECT_FALSE(IsSuspended());
+
+  StartNewPlayer(player_observer.get(), media::MediaContentType::Transient);
+  EXPECT_FALSE(IsControllable());
+  EXPECT_FALSE(IsSuspended());
+
+  StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent);
+  EXPECT_FALSE(IsControllable());
+  EXPECT_FALSE(IsSuspended());
+}
+
+IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest,
+                       ControlsShowAfterRemoveOneShot) {
+  Expectation uncontrollable = EXPECT_CALL(
+      *mock_media_session_observer(), MediaSessionStateChanged(false, false));
+
+  EXPECT_CALL(*mock_media_session_observer(),
+              MediaSessionStateChanged(true, false))
+      .After(uncontrollable);
+
+  std::unique_ptr<MockMediaSessionPlayerObserver> player_observer(
+      new MockMediaSessionPlayerObserver);
+
+  StartNewPlayer(player_observer.get(), media::MediaContentType::OneShot);
+  StartNewPlayer(player_observer.get(), media::MediaContentType::Transient);
+  StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent);
+
+  RemovePlayer(player_observer.get(), 0);
+
+  EXPECT_TRUE(IsControllable());
+  EXPECT_FALSE(IsSuspended());
+}
+
+IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest,
+                       DontSuspendWhenOneShotIsPresent) {
+  std::unique_ptr<MockMediaSessionPlayerObserver> player_observer(
+      new MockMediaSessionPlayerObserver);
+
+  StartNewPlayer(player_observer.get(), media::MediaContentType::OneShot);
+  StartNewPlayer(player_observer.get(), media::MediaContentType::Transient);
+  StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent);
+
+  SystemSuspend(false);
+
+  EXPECT_FALSE(IsControllable());
+  EXPECT_FALSE(IsSuspended());
+
+  EXPECT_EQ(0, player_observer->received_suspend_calls());
+}
+
+IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest,
                        DontResumeBySystemUISuspendedSessions) {
   std::unique_ptr<MockMediaSessionPlayerObserver> player_observer(
       new MockMediaSessionPlayerObserver);
@@ -945,6 +1015,40 @@ IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest, ResumeSuspendFromSystem) {
   EXPECT_FALSE(IsSuspended());
 }
 
+IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest, OneShotTakesGainFocus) {
+  std::unique_ptr<MockMediaSessionPlayerObserver> player_observer(
+      new MockMediaSessionPlayerObserver);
+  EXPECT_CALL(
+      *mock_audio_focus_delegate(),
+      RequestAudioFocus(content::AudioFocusManager::AudioFocusType::Gain))
+      .Times(1);
+  EXPECT_CALL(*mock_audio_focus_delegate(),
+              RequestAudioFocus(::testing::Ne(
+                  content::AudioFocusManager::AudioFocusType::Gain)))
+      .Times(0);
+  StartNewPlayer(player_observer.get(), media::MediaContentType::OneShot);
+  StartNewPlayer(player_observer.get(), media::MediaContentType::Transient);
+  StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent);
+}
+
+IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest, RemovingOneShotDropsFocus) {
+  std::unique_ptr<MockMediaSessionPlayerObserver> player_observer(
+      new MockMediaSessionPlayerObserver);
+  EXPECT_CALL(*mock_audio_focus_delegate(), AbandonAudioFocus());
+  StartNewPlayer(player_observer.get(), media::MediaContentType::OneShot);
+  RemovePlayer(player_observer.get(), 0);
+}
+
+IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest,
+                       RemovingOneWhileStillHavingOtherPlayersKeepsFocus) {
+  std::unique_ptr<MockMediaSessionPlayerObserver> player_observer(
+      new MockMediaSessionPlayerObserver);
+  EXPECT_CALL(*mock_audio_focus_delegate(), AbandonAudioFocus()).Times(0);
+  StartNewPlayer(player_observer.get(), media::MediaContentType::OneShot);
+  StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent);
+  RemovePlayer(player_observer.get(), 0);
+}
+
 IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest,
                        UMA_Suspended_SystemTransient) {
   std::unique_ptr<MockMediaSessionPlayerObserver> player_observer(