Clean up MediaSessionImpl state interfaces

content/browser/media/session/media_session_impl_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_impl.h"
 
 #include <stddef.h>
 
 #include <list>
 #include <vector>
@@ skipping 97 matching lines @@
 
   void RemovePlayers(MockMediaSessionPlayerObserver* player_observer) {
     media_session_->RemovePlayers(player_observer);
   }
 
   void OnPlayerPaused(MockMediaSessionPlayerObserver* player_observer,
                       int player_id) {
     media_session_->OnPlayerPaused(player_observer, player_id);
   }
 
-  bool HasAudioFocus() { return media_session_->IsActiveForTest(); }
+  bool IsActive() { return media_session_->IsActive(); }
 
   content::AudioFocusManager::AudioFocusType GetSessionAudioFocusType() {
     return media_session_->audio_focus_type();
   }
 
   bool IsControllable() { return media_session_->IsControllable(); }
 
-  bool IsSuspended() { return media_session_->IsSuspended(); }
-
   void UIResume() { media_session_->Resume(MediaSession::SuspendType::UI); }
 
   void SystemResume() {
     media_session_->OnResumeInternal(MediaSession::SuspendType::SYSTEM);
   }
 
   void UISuspend() { media_session_->Suspend(MediaSession::SuspendType::UI); }
 
   void SystemSuspend(bool temporary) {
     media_session_->OnSuspendInternal(MediaSession::SuspendType::SYSTEM,
@@ skipping 161 matching lines @@
 
   EXPECT_EQ(kDefaultVolumeMultiplier, player_observer->GetVolumeMultiplier(0));
   EXPECT_EQ(kDefaultVolumeMultiplier, player_observer->GetVolumeMultiplier(1));
 
   StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent);
 
   EXPECT_EQ(kDefaultVolumeMultiplier, player_observer->GetVolumeMultiplier(2));
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest, AudioFocusInitialState) {
-  EXPECT_FALSE(HasAudioFocus());
+  EXPECT_FALSE(IsActive());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest, StartPlayerGivesFocus) {
   auto player_observer = base::MakeUnique<MockMediaSessionPlayerObserver>();
 
   StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent);
 
-  EXPECT_TRUE(HasAudioFocus());
+  EXPECT_TRUE(IsActive());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest,
                        SuspendGivesAwayAudioFocus) {
   auto player_observer = base::MakeUnique<MockMediaSessionPlayerObserver>();
 
   StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent);
 
   SystemSuspend(true);
 
-  EXPECT_FALSE(HasAudioFocus());
+  EXPECT_FALSE(IsActive());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest, StopGivesAwayAudioFocus) {
   auto player_observer = base::MakeUnique<MockMediaSessionPlayerObserver>();
 
   StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent);
 
   media_session_->Stop(MediaSession::SuspendType::UI);
 
-  EXPECT_FALSE(HasAudioFocus());
+  EXPECT_FALSE(IsActive());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest, ResumeGivesBackAudioFocus) {
   auto player_observer = base::MakeUnique<MockMediaSessionPlayerObserver>();
 
   StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent);
 
   SystemSuspend(true);
   SystemResume();
 
-  EXPECT_TRUE(HasAudioFocus());
+  EXPECT_TRUE(IsActive());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest,
                        RemovingLastPlayerDropsAudioFocus) {
   auto player_observer = base::MakeUnique<MockMediaSessionPlayerObserver>();
 
   StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent);
   StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent);
   StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent);
 
   RemovePlayer(player_observer.get(), 0);
-  EXPECT_TRUE(HasAudioFocus());
+  EXPECT_TRUE(IsActive());
   RemovePlayer(player_observer.get(), 1);
-  EXPECT_TRUE(HasAudioFocus());
+  EXPECT_TRUE(IsActive());
   RemovePlayer(player_observer.get(), 2);
-  EXPECT_FALSE(HasAudioFocus());
+  EXPECT_FALSE(IsActive());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest,
                        RemovingLastPlayerFromManyObserversDropsAudioFocus) {
   auto player_observer_1 = base::MakeUnique<MockMediaSessionPlayerObserver>();
   auto player_observer_2 = base::MakeUnique<MockMediaSessionPlayerObserver>();
   auto player_observer_3 = base::MakeUnique<MockMediaSessionPlayerObserver>();
 
   StartNewPlayer(player_observer_1.get(), media::MediaContentType::Persistent);
   StartNewPlayer(player_observer_2.get(), media::MediaContentType::Persistent);
   StartNewPlayer(player_observer_3.get(), media::MediaContentType::Persistent);
 
   RemovePlayer(player_observer_1.get(), 0);
-  EXPECT_TRUE(HasAudioFocus());
+  EXPECT_TRUE(IsActive());
   RemovePlayer(player_observer_2.get(), 0);
-  EXPECT_TRUE(HasAudioFocus());
+  EXPECT_TRUE(IsActive());
   RemovePlayer(player_observer_3.get(), 0);
-  EXPECT_FALSE(HasAudioFocus());
+  EXPECT_FALSE(IsActive());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest,
                        RemovingAllPlayersFromObserversDropsAudioFocus) {
   auto player_observer_1 = base::MakeUnique<MockMediaSessionPlayerObserver>();
   auto player_observer_2 = base::MakeUnique<MockMediaSessionPlayerObserver>();
 
   StartNewPlayer(player_observer_1.get(), media::MediaContentType::Persistent);
   StartNewPlayer(player_observer_1.get(), media::MediaContentType::Persistent);
   StartNewPlayer(player_observer_2.get(), media::MediaContentType::Persistent);
   StartNewPlayer(player_observer_2.get(), media::MediaContentType::Persistent);
 
   RemovePlayers(player_observer_1.get());
-  EXPECT_TRUE(HasAudioFocus());
+  EXPECT_TRUE(IsActive());
   RemovePlayers(player_observer_2.get());
-  EXPECT_FALSE(HasAudioFocus());
+  EXPECT_FALSE(IsActive());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest, ResumePlayGivesAudioFocus) {
   auto player_observer = base::MakeUnique<MockMediaSessionPlayerObserver>();
 
   StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent);
 
   RemovePlayer(player_observer.get(), 0);
-  EXPECT_FALSE(HasAudioFocus());
+  EXPECT_FALSE(IsActive());
 
   EXPECT_TRUE(
       AddPlayer(player_observer.get(), 0, media::MediaContentType::Persistent));
-  EXPECT_TRUE(HasAudioFocus());
+  EXPECT_TRUE(IsActive());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest,
                        ResumeSuspendAreSentOnlyOncePerPlayers) {
   auto player_observer = base::MakeUnique<MockMediaSessionPlayerObserver>();
 
   StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent);
   StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent);
   StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent);
 
@@ skipping 95 matching lines @@
 IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest, ControlsShowForContent) {
   EXPECT_CALL(*mock_media_session_observer(),
               MediaSessionStateChanged(true, false));
 
   auto player_observer = base::MakeUnique<MockMediaSessionPlayerObserver>();
 
   // Starting a player with a content type should show the media controls.
   StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent);
 
   EXPECT_TRUE(IsControllable());
-  EXPECT_FALSE(IsSuspended());
+  EXPECT_TRUE(IsActive());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest,
                        ControlsNoShowForTransient) {
   EXPECT_CALL(*mock_media_session_observer(),
               MediaSessionStateChanged(false, false));
 
   auto player_observer = base::MakeUnique<MockMediaSessionPlayerObserver>();
 
   // Starting a player with a transient type should not show the media controls.
   StartNewPlayer(player_observer.get(), media::MediaContentType::Transient);
 
   EXPECT_FALSE(IsControllable());
-  EXPECT_FALSE(IsSuspended());
+  EXPECT_TRUE(IsActive());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest, ControlsHideWhenStopped) {
   Expectation showControls = EXPECT_CALL(*mock_media_session_observer(),
                                          MediaSessionStateChanged(true, false));
   EXPECT_CALL(*mock_media_session_observer(),
               MediaSessionStateChanged(false, true))
       .After(showControls);
 
   auto player_observer = base::MakeUnique<MockMediaSessionPlayerObserver>();
 
   StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent);
 
   RemovePlayers(player_observer.get());
 
   EXPECT_FALSE(IsControllable());
-  EXPECT_TRUE(IsSuspended());
+  EXPECT_FALSE(IsActive());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest,
                        ControlsShownAcceptTransient) {
   EXPECT_CALL(*mock_media_session_observer(),
               MediaSessionStateChanged(true, false));
 
   auto player_observer = base::MakeUnique<MockMediaSessionPlayerObserver>();
 
   StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent);
 
   // Transient player join the session without affecting the controls.
   StartNewPlayer(player_observer.get(), media::MediaContentType::Transient);
 
   EXPECT_TRUE(IsControllable());
-  EXPECT_FALSE(IsSuspended());
+  EXPECT_TRUE(IsActive());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest,
                        ControlsShownAfterContentAdded) {
   Expectation dontShowControls = EXPECT_CALL(
       *mock_media_session_observer(), MediaSessionStateChanged(false, false));
   EXPECT_CALL(*mock_media_session_observer(),
               MediaSessionStateChanged(true, false))
       .After(dontShowControls);
 
   auto player_observer = base::MakeUnique<MockMediaSessionPlayerObserver>();
 
   StartNewPlayer(player_observer.get(), media::MediaContentType::Transient);
 
   // The controls are shown when the content player is added.
   StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent);
 
   EXPECT_TRUE(IsControllable());
-  EXPECT_FALSE(IsSuspended());
+  EXPECT_TRUE(IsActive());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest,
                        ControlsStayIfOnlyOnePlayerHasBeenPaused) {
   EXPECT_CALL(*mock_media_session_observer(),
               MediaSessionStateChanged(true, false));
 
   auto player_observer = base::MakeUnique<MockMediaSessionPlayerObserver>();
 
   StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent);
   StartNewPlayer(player_observer.get(), media::MediaContentType::Transient);
 
   // Removing only content player doesn't hide the controls since the session
   // is still active.
   RemovePlayer(player_observer.get(), 0);
 
   EXPECT_TRUE(IsControllable());
-  EXPECT_FALSE(IsSuspended());
+  EXPECT_TRUE(IsActive());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest,
                        ControlsHideWhenTheLastPlayerIsRemoved) {
   Expectation showControls = EXPECT_CALL(*mock_media_session_observer(),
                                          MediaSessionStateChanged(true, false));
   EXPECT_CALL(*mock_media_session_observer(),
               MediaSessionStateChanged(false, true))
       .After(showControls);
 
   auto player_observer = base::MakeUnique<MockMediaSessionPlayerObserver>();
 
   StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent);
   StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent);
 
   RemovePlayer(player_observer.get(), 0);
 
   EXPECT_TRUE(IsControllable());
-  EXPECT_FALSE(IsSuspended());
+  EXPECT_TRUE(IsActive());
 
   RemovePlayer(player_observer.get(), 1);
 
   EXPECT_FALSE(IsControllable());
-  EXPECT_TRUE(IsSuspended());
+  EXPECT_FALSE(IsActive());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest,
                        ControlsHideWhenAllThePlayersAreRemoved) {
   Expectation showControls = EXPECT_CALL(*mock_media_session_observer(),
                                          MediaSessionStateChanged(true, false));
   EXPECT_CALL(*mock_media_session_observer(),
               MediaSessionStateChanged(false, true))
       .After(showControls);
 
   auto player_observer = base::MakeUnique<MockMediaSessionPlayerObserver>();
 
   StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent);
   StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent);
 
   RemovePlayers(player_observer.get());
 
   EXPECT_FALSE(IsControllable());
-  EXPECT_TRUE(IsSuspended());
+  EXPECT_FALSE(IsActive());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest,
                        ControlsNotHideWhenTheLastPlayerIsPaused) {
   Expectation showControls = EXPECT_CALL(*mock_media_session_observer(),
                                          MediaSessionStateChanged(true, false));
   EXPECT_CALL(*mock_media_session_observer(),
               MediaSessionStateChanged(true, true))
       .After(showControls);
 
   auto player_observer = base::MakeUnique<MockMediaSessionPlayerObserver>();
 
   StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent);
   StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent);
 
   OnPlayerPaused(player_observer.get(), 0);
 
   EXPECT_TRUE(IsControllable());
-  EXPECT_FALSE(IsSuspended());
+  EXPECT_TRUE(IsActive());
 
   OnPlayerPaused(player_observer.get(), 1);
 
   EXPECT_TRUE(IsControllable());
-  EXPECT_TRUE(IsSuspended());
+  EXPECT_FALSE(IsActive());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest,
                        SuspendTemporaryUpdatesControls) {
   Expectation showControls = EXPECT_CALL(*mock_media_session_observer(),
                                          MediaSessionStateChanged(true, false));
   EXPECT_CALL(*mock_media_session_observer(),
               MediaSessionStateChanged(true, true))
       .After(showControls);
 
   auto player_observer = base::MakeUnique<MockMediaSessionPlayerObserver>();
 
   StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent);
 
   SystemSuspend(true);
 
   EXPECT_TRUE(IsControllable());
-  EXPECT_TRUE(IsSuspended());
+  EXPECT_FALSE(IsActive());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest,
                        ControlsUpdatedWhenResumed) {
   Expectation showControls = EXPECT_CALL(*mock_media_session_observer(),
                                          MediaSessionStateChanged(true, false));
   Expectation pauseControls = EXPECT_CALL(*mock_media_session_observer(),
                                           MediaSessionStateChanged(true, true))
                                   .After(showControls);
   EXPECT_CALL(*mock_media_session_observer(),
               MediaSessionStateChanged(true, false))
       .After(pauseControls);
 
   auto player_observer = base::MakeUnique<MockMediaSessionPlayerObserver>();
 
   StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent);
   SystemSuspend(true);
   SystemResume();
 
   EXPECT_TRUE(IsControllable());
-  EXPECT_FALSE(IsSuspended());
+  EXPECT_TRUE(IsActive());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest,
                        ControlsHideWhenSessionSuspendedPermanently) {
   Expectation showControls = EXPECT_CALL(*mock_media_session_observer(),
                                          MediaSessionStateChanged(true, false));
   EXPECT_CALL(*mock_media_session_observer(),
               MediaSessionStateChanged(false, true))
       .After(showControls);
 
   auto player_observer = base::MakeUnique<MockMediaSessionPlayerObserver>();
 
   StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent);
 
   SystemSuspend(false);
 
   EXPECT_FALSE(IsControllable());
-  EXPECT_TRUE(IsSuspended());
+  EXPECT_FALSE(IsActive());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest,
                        ConstrolsHideWhenSessionStops) {
   Expectation showControls = EXPECT_CALL(*mock_media_session_observer(),
                                          MediaSessionStateChanged(true, false));
   Expectation pauseControls = EXPECT_CALL(*mock_media_session_observer(),
                                           MediaSessionStateChanged(true, true))
                                   .After(showControls);
   EXPECT_CALL(*mock_media_session_observer(),
               MediaSessionStateChanged(false, true))
       .After(pauseControls);
 
   auto player_observer = base::MakeUnique<MockMediaSessionPlayerObserver>();
 
   StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent);
 
   media_session_->Stop(MediaSession::SuspendType::UI);
 
   EXPECT_FALSE(IsControllable());
-  EXPECT_TRUE(IsSuspended());
+  EXPECT_FALSE(IsActive());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest,
                        ControlsHideWhenSessionChangesFromContentToTransient) {
   Expectation showControls = EXPECT_CALL(*mock_media_session_observer(),
                                          MediaSessionStateChanged(true, false));
   Expectation pauseControls = EXPECT_CALL(*mock_media_session_observer(),
                                           MediaSessionStateChanged(true, true))
                                   .After(showControls);
   EXPECT_CALL(*mock_media_session_observer(),
               MediaSessionStateChanged(false, false))
       .After(pauseControls);
 
   auto player_observer = base::MakeUnique<MockMediaSessionPlayerObserver>();
 
   StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent);
   SystemSuspend(true);
 
   // This should reset the session and change it to a transient, so
   // hide the controls.
   StartNewPlayer(player_observer.get(), media::MediaContentType::Transient);
 
   EXPECT_FALSE(IsControllable());
-  EXPECT_FALSE(IsSuspended());
+  EXPECT_TRUE(IsActive());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest,
                        ControlsUpdatedWhenNewPlayerResetsSession) {
   Expectation showControls = EXPECT_CALL(*mock_media_session_observer(),
                                          MediaSessionStateChanged(true, false));
   Expectation pauseControls = EXPECT_CALL(*mock_media_session_observer(),
                                           MediaSessionStateChanged(true, true))
                                   .After(showControls);
   EXPECT_CALL(*mock_media_session_observer(),
               MediaSessionStateChanged(true, false))
       .After(pauseControls);
 
   auto player_observer = base::MakeUnique<MockMediaSessionPlayerObserver>();
 
   StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent);
   SystemSuspend(true);
 
   // This should reset the session and update the controls.
   StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent);
 
   EXPECT_TRUE(IsControllable());
-  EXPECT_FALSE(IsSuspended());
+  EXPECT_TRUE(IsActive());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest,
                        ControlsResumedWhenPlayerIsResumed) {
   Expectation showControls = EXPECT_CALL(*mock_media_session_observer(),
                                          MediaSessionStateChanged(true, false));
   Expectation pauseControls = EXPECT_CALL(*mock_media_session_observer(),
                                           MediaSessionStateChanged(true, true))
                                   .After(showControls);
   EXPECT_CALL(*mock_media_session_observer(),
               MediaSessionStateChanged(true, false))
       .After(pauseControls);
 
   auto player_observer = base::MakeUnique<MockMediaSessionPlayerObserver>();
 
   StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent);
   SystemSuspend(true);
 
   // This should resume the session and update the controls.
   AddPlayer(player_observer.get(), 0, media::MediaContentType::Persistent);
 
   EXPECT_TRUE(IsControllable());
-  EXPECT_FALSE(IsSuspended());
+  EXPECT_TRUE(IsActive());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest,
                        ControlsUpdatedDueToResumeSessionAction) {
   Expectation showControls = EXPECT_CALL(*mock_media_session_observer(),
                                          MediaSessionStateChanged(true, false));
   EXPECT_CALL(*mock_media_session_observer(),
               MediaSessionStateChanged(true, true))
       .After(showControls);
 
   auto player_observer = base::MakeUnique<MockMediaSessionPlayerObserver>();
 
   StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent);
   UISuspend();
 
   EXPECT_TRUE(IsControllable());
-  EXPECT_TRUE(IsSuspended());
+  EXPECT_FALSE(IsActive());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest,
                        ControlsUpdatedDueToSuspendSessionAction) {
   Expectation showControls = EXPECT_CALL(*mock_media_session_observer(),
                                          MediaSessionStateChanged(true, false));
   Expectation pauseControls = EXPECT_CALL(*mock_media_session_observer(),
                                           MediaSessionStateChanged(true, true))
                                   .After(showControls);
   EXPECT_CALL(*mock_media_session_observer(),
               MediaSessionStateChanged(true, false))
       .After(pauseControls);
 
   auto player_observer = base::MakeUnique<MockMediaSessionPlayerObserver>();
 
   StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent);
   UISuspend();
   UIResume();
 
   EXPECT_TRUE(IsControllable());
-  EXPECT_FALSE(IsSuspended());
+  EXPECT_TRUE(IsActive());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest,
                        ControlsDontShowWhenOneShotIsPresent) {
   EXPECT_CALL(*mock_media_session_observer(),
               MediaSessionStateChanged(false, false));
 
   auto player_observer = base::MakeUnique<MockMediaSessionPlayerObserver>();
 
   StartNewPlayer(player_observer.get(), media::MediaContentType::OneShot);
 
   EXPECT_FALSE(IsControllable());
-  EXPECT_FALSE(IsSuspended());
+  EXPECT_TRUE(IsActive());
 
   StartNewPlayer(player_observer.get(), media::MediaContentType::Transient);
   EXPECT_FALSE(IsControllable());
-  EXPECT_FALSE(IsSuspended());
+  EXPECT_TRUE(IsActive());
 
   StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent);
   EXPECT_FALSE(IsControllable());
-  EXPECT_FALSE(IsSuspended());
+  EXPECT_TRUE(IsActive());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest,
                        ControlsHiddenAfterRemoveOneShotWithoutOtherPlayers) {
   Expectation expect_1 = EXPECT_CALL(*mock_media_session_observer(),
                                      MediaSessionStateChanged(false, false));
   Expectation expect_2 = EXPECT_CALL(*mock_media_session_observer(),
                                      MediaSessionStateChanged(false, true))
                              .After(expect_1);
   EXPECT_CALL(*mock_media_session_observer(), MediaSessionStateChanged(true, _))
       .Times(0)
       .After(expect_2);
 
   auto player_observer = base::MakeUnique<MockMediaSessionPlayerObserver>();
 
   StartNewPlayer(player_observer.get(), media::MediaContentType::OneShot);
   RemovePlayer(player_observer.get(), 0);
 
   EXPECT_FALSE(IsControllable());
-  EXPECT_TRUE(IsSuspended());
+  EXPECT_FALSE(IsActive());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest,
                        ControlsShowAfterRemoveOneShotWithPersistentPresent) {
   Expectation uncontrollable = EXPECT_CALL(
       *mock_media_session_observer(), MediaSessionStateChanged(false, false));
 
   EXPECT_CALL(*mock_media_session_observer(),
               MediaSessionStateChanged(true, false))
       .After(uncontrollable);
 
   auto player_observer = base::MakeUnique<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());
+  EXPECT_TRUE(IsActive());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest,
                        DontSuspendWhenOneShotIsPresent) {
   auto player_observer = base::MakeUnique<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_TRUE(IsActive());
 
   EXPECT_EQ(0, player_observer->received_suspend_calls());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest,
                        DontResumeBySystemUISuspendedSessions) {
   auto player_observer = base::MakeUnique<MockMediaSessionPlayerObserver>();
 
   StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent);
 
   UISuspend();
   EXPECT_TRUE(IsControllable());
-  EXPECT_TRUE(IsSuspended());
+  EXPECT_FALSE(IsActive());
 
   SystemResume();
   EXPECT_TRUE(IsControllable());
-  EXPECT_TRUE(IsSuspended());
+  EXPECT_FALSE(IsActive());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest,
                        AllowUIResumeForSystemSuspend) {
   auto player_observer = base::MakeUnique<MockMediaSessionPlayerObserver>();
 
   StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent);
 
   SystemSuspend(true);
   EXPECT_TRUE(IsControllable());
-  EXPECT_TRUE(IsSuspended());
+  EXPECT_FALSE(IsActive());
 
   UIResume();
   EXPECT_TRUE(IsControllable());
-  EXPECT_FALSE(IsSuspended());
+  EXPECT_TRUE(IsActive());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest, ResumeSuspendFromUI) {
   auto player_observer = base::MakeUnique<MockMediaSessionPlayerObserver>();
 
   StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent);
 
   UISuspend();
   EXPECT_TRUE(IsControllable());
-  EXPECT_TRUE(IsSuspended());
+  EXPECT_FALSE(IsActive());
 
   UIResume();
   EXPECT_TRUE(IsControllable());
-  EXPECT_FALSE(IsSuspended());
+  EXPECT_TRUE(IsActive());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest, ResumeSuspendFromSystem) {
   auto player_observer = base::MakeUnique<MockMediaSessionPlayerObserver>();
 
   StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent);
 
   SystemSuspend(true);
   EXPECT_TRUE(IsControllable());
-  EXPECT_TRUE(IsSuspended());
+  EXPECT_FALSE(IsActive());
 
   SystemResume();
   EXPECT_TRUE(IsControllable());
-  EXPECT_FALSE(IsSuspended());
+  EXPECT_TRUE(IsActive());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest, OneShotTakesGainFocus) {
   auto player_observer = base::MakeUnique<MockMediaSessionPlayerObserver>();
 
   EXPECT_CALL(
       *mock_audio_focus_delegate(),
       RequestAudioFocus(content::AudioFocusManager::AudioFocusType::Gain))
       .Times(1);
   EXPECT_CALL(*mock_audio_focus_delegate(),
@@ skipping 394 matching lines @@
   StartNewPlayer(player_observer.get(), 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));
 }