Split MediaSessionStateChanged() and MediaSessionMetadataChanged()

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 34 matching lines @@
 
   void AbandonAudioFocus() override {
   }
 };
 
 class MockWebContentsObserver : public WebContentsObserver {
  public:
   MockWebContentsObserver(WebContents* web_contents)
       : WebContentsObserver(web_contents) {}
 
-  MOCK_METHOD3(MediaSessionStateChanged,
-               void(bool is_controllable, bool is_suspended,
-                    const base::Optional<content::MediaMetadata>& metadata));
+  MOCK_METHOD2(MediaSessionStateChanged,
+               void(bool is_controllable, bool is_suspended));
 };
 
 }  // namespace
 
 class MediaSessionBrowserTest : public content::ContentBrowserTest {
  protected:
   MediaSessionBrowserTest() = default;
 
   void SetUpOnMainThread() override {
     ContentBrowserTest::SetUpOnMainThread();
@@ skipping 513 matching lines @@
   EXPECT_TRUE(media_session_observer->IsPlaying(1));
   EXPECT_TRUE(media_session_observer->IsPlaying(2));
   EXPECT_TRUE(media_session_observer->IsPlaying(3));
 
   EXPECT_EQ(content::AudioFocusManager::AudioFocusType::Gain,
             GetSessionAudioFocusType());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, ControlsShowForContent) {
   EXPECT_CALL(*mock_web_contents_observer(),
-              MediaSessionStateChanged(true, false, testing::_));
+              MediaSessionStateChanged(true, false));
 
   std::unique_ptr<MockMediaSessionObserver> media_session_observer(
       new MockMediaSessionObserver);
 
   // Starting a player with a content type should show the media controls.
   StartNewPlayer(media_session_observer.get(),
                  media::MediaContentType::Persistent);
 
   EXPECT_TRUE(IsControllable());
   EXPECT_FALSE(IsSuspended());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, ControlsNoShowForTransient) {
   EXPECT_CALL(*mock_web_contents_observer(),
-              MediaSessionStateChanged(false, false, testing::_));
+              MediaSessionStateChanged(false, false));
 
   std::unique_ptr<MockMediaSessionObserver> media_session_observer(
       new MockMediaSessionObserver);
 
   // Starting a player with a transient type should not show the media controls.
   StartNewPlayer(media_session_observer.get(),
                  media::MediaContentType::Transient);
 
   EXPECT_FALSE(IsControllable());
   EXPECT_FALSE(IsSuspended());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, ControlsHideWhenStopped) {
   Expectation showControls = EXPECT_CALL(*mock_web_contents_observer(),
-      MediaSessionStateChanged(true, false, testing::_));
+                                         MediaSessionStateChanged(true, false));
   EXPECT_CALL(*mock_web_contents_observer(),
-              MediaSessionStateChanged(false, true, testing::_))
+              MediaSessionStateChanged(false, true))
       .After(showControls);
 
   std::unique_ptr<MockMediaSessionObserver> media_session_observer(
       new MockMediaSessionObserver);
 
   StartNewPlayer(media_session_observer.get(),
                  media::MediaContentType::Persistent);
 
   RemovePlayers(media_session_observer.get());
 
   EXPECT_FALSE(IsControllable());
   EXPECT_TRUE(IsSuspended());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, ControlsShownAcceptTransient) {
   EXPECT_CALL(*mock_web_contents_observer(),
-              MediaSessionStateChanged(true, false, testing::_));
+              MediaSessionStateChanged(true, false));
 
   std::unique_ptr<MockMediaSessionObserver> media_session_observer(
       new MockMediaSessionObserver);
 
   StartNewPlayer(media_session_observer.get(),
                  media::MediaContentType::Persistent);
 
   // Transient player join the session without affecting the controls.
   StartNewPlayer(media_session_observer.get(),
                  media::MediaContentType::Transient);
 
   EXPECT_TRUE(IsControllable());
   EXPECT_FALSE(IsSuspended());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest,
                        ControlsShownAfterContentAdded) {
-  Expectation dontShowControls = EXPECT_CALL(*mock_web_contents_observer(),
-      MediaSessionStateChanged(false, false, testing::_));
+  Expectation dontShowControls = EXPECT_CALL(
+      *mock_web_contents_observer(), MediaSessionStateChanged(false, false));
   EXPECT_CALL(*mock_web_contents_observer(),
-              MediaSessionStateChanged(true, false, testing::_))
+              MediaSessionStateChanged(true, false))
       .After(dontShowControls);
 
   std::unique_ptr<MockMediaSessionObserver> media_session_observer(
       new MockMediaSessionObserver);
 
   StartNewPlayer(media_session_observer.get(),
                  media::MediaContentType::Transient);
 
   // The controls are shown when the content player is added.
   StartNewPlayer(media_session_observer.get(),
                  media::MediaContentType::Persistent);
 
   EXPECT_TRUE(IsControllable());
   EXPECT_FALSE(IsSuspended());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest,
                        ControlsStayIfOnlyOnePlayerHasBeenPaused) {
   EXPECT_CALL(*mock_web_contents_observer(),
-              MediaSessionStateChanged(true, false, testing::_));
+              MediaSessionStateChanged(true, false));
 
   std::unique_ptr<MockMediaSessionObserver> media_session_observer(
       new MockMediaSessionObserver);
 
   StartNewPlayer(media_session_observer.get(),
                  media::MediaContentType::Persistent);
   StartNewPlayer(media_session_observer.get(),
                  media::MediaContentType::Transient);
 
   // Removing only content player doesn't hide the controls since the session
   // is still active.
   RemovePlayer(media_session_observer.get(), 0);
 
   EXPECT_TRUE(IsControllable());
   EXPECT_FALSE(IsSuspended());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest,
                        ControlsHideWhenTheLastPlayerIsRemoved) {
   Expectation showControls = EXPECT_CALL(*mock_web_contents_observer(),
-      MediaSessionStateChanged(true, false, testing::_));
+                                         MediaSessionStateChanged(true, false));
   EXPECT_CALL(*mock_web_contents_observer(),
-              MediaSessionStateChanged(false, true, testing::_))
+              MediaSessionStateChanged(false, true))
       .After(showControls);
   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);
 
   RemovePlayer(media_session_observer.get(), 0);
 
   EXPECT_TRUE(IsControllable());
   EXPECT_FALSE(IsSuspended());
 
   RemovePlayer(media_session_observer.get(), 1);
 
   EXPECT_FALSE(IsControllable());
   EXPECT_TRUE(IsSuspended());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest,
                        ControlsHideWhenAllThePlayersAreRemoved) {
   Expectation showControls = EXPECT_CALL(*mock_web_contents_observer(),
-      MediaSessionStateChanged(true, false, testing::_));
+                                         MediaSessionStateChanged(true, false));
   EXPECT_CALL(*mock_web_contents_observer(),
-              MediaSessionStateChanged(false, true, testing::_))
+              MediaSessionStateChanged(false, true))
       .After(showControls);
 
   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);
 
   RemovePlayers(media_session_observer.get());
 
   EXPECT_FALSE(IsControllable());
   EXPECT_TRUE(IsSuspended());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest,
                        ControlsNotHideWhenTheLastPlayerIsPaused) {
   Expectation showControls = EXPECT_CALL(*mock_web_contents_observer(),
-      MediaSessionStateChanged(true, false, testing::_));
+                                         MediaSessionStateChanged(true, false));
   EXPECT_CALL(*mock_web_contents_observer(),
-              MediaSessionStateChanged(true, true, testing::_))
+              MediaSessionStateChanged(true, true))
       .After(showControls);
 
   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);
 
   OnPlayerPaused(media_session_observer.get(), 0);
 
   EXPECT_TRUE(IsControllable());
   EXPECT_FALSE(IsSuspended());
 
   OnPlayerPaused(media_session_observer.get(), 1);
 
   EXPECT_TRUE(IsControllable());
   EXPECT_TRUE(IsSuspended());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest,
                        SuspendTemporaryUpdatesControls) {
   Expectation showControls = EXPECT_CALL(*mock_web_contents_observer(),
-      MediaSessionStateChanged(true, false, testing::_));
+                                         MediaSessionStateChanged(true, false));
   EXPECT_CALL(*mock_web_contents_observer(),
-              MediaSessionStateChanged(true, true, testing::_))
+              MediaSessionStateChanged(true, true))
       .After(showControls);
 
   std::unique_ptr<MockMediaSessionObserver> media_session_observer(
       new MockMediaSessionObserver);
 
   StartNewPlayer(media_session_observer.get(),
                  media::MediaContentType::Persistent);
 
   SystemSuspend(true);
 
   EXPECT_TRUE(IsControllable());
   EXPECT_TRUE(IsSuspended());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, ControlsUpdatedWhenResumed) {
   Expectation showControls = EXPECT_CALL(*mock_web_contents_observer(),
-      MediaSessionStateChanged(true, false, testing::_));
+                                         MediaSessionStateChanged(true, false));
   Expectation pauseControls = EXPECT_CALL(*mock_web_contents_observer(),
-      MediaSessionStateChanged(true, true, testing::_)).After(showControls);
+                                          MediaSessionStateChanged(true, true))
+                                  .After(showControls);
   EXPECT_CALL(*mock_web_contents_observer(),
-              MediaSessionStateChanged(true, false, testing::_))
+              MediaSessionStateChanged(true, false))
       .After(pauseControls);
 
   std::unique_ptr<MockMediaSessionObserver> media_session_observer(
       new MockMediaSessionObserver);
 
   StartNewPlayer(media_session_observer.get(),
                  media::MediaContentType::Persistent);
   SystemSuspend(true);
   SystemResume();
 
   EXPECT_TRUE(IsControllable());
   EXPECT_FALSE(IsSuspended());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest,
                        ControlsHideWhenSessionSuspendedPermanently) {
   Expectation showControls = EXPECT_CALL(*mock_web_contents_observer(),
-      MediaSessionStateChanged(true, false, testing::_));
+                                         MediaSessionStateChanged(true, false));
   EXPECT_CALL(*mock_web_contents_observer(),
-              MediaSessionStateChanged(false, true, testing::_))
+              MediaSessionStateChanged(false, true))
       .After(showControls);
 
   std::unique_ptr<MockMediaSessionObserver> media_session_observer(
       new MockMediaSessionObserver);
 
   StartNewPlayer(media_session_observer.get(),
                  media::MediaContentType::Persistent);
 
   SystemSuspend(false);
 
   EXPECT_FALSE(IsControllable());
   EXPECT_TRUE(IsSuspended());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest,
                        ConstrolsHideWhenSessionStops) {
   Expectation showControls = EXPECT_CALL(*mock_web_contents_observer(),
-      MediaSessionStateChanged(true, false, testing::_));
+                                         MediaSessionStateChanged(true, false));
   Expectation pauseControls = EXPECT_CALL(*mock_web_contents_observer(),
-      MediaSessionStateChanged(true, true, testing::_)).After(showControls);
+                                          MediaSessionStateChanged(true, true))
+                                  .After(showControls);
   EXPECT_CALL(*mock_web_contents_observer(),
-              MediaSessionStateChanged(false, true, testing::_))
+              MediaSessionStateChanged(false, true))
       .After(pauseControls);
 
   std::unique_ptr<MockMediaSessionObserver> media_session_observer(
       new MockMediaSessionObserver);
 
   StartNewPlayer(media_session_observer.get(),
                  media::MediaContentType::Persistent);
 
   media_session_->Stop(MediaSession::SuspendType::UI);
 
   EXPECT_FALSE(IsControllable());
   EXPECT_TRUE(IsSuspended());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest,
                        ControlsHideWhenSessionChangesFromContentToTransient) {
   Expectation showControls = EXPECT_CALL(*mock_web_contents_observer(),
-      MediaSessionStateChanged(true, false, testing::_));
+                                         MediaSessionStateChanged(true, false));
   Expectation pauseControls = EXPECT_CALL(*mock_web_contents_observer(),
-      MediaSessionStateChanged(true, true, testing::_)).After(showControls);
+                                          MediaSessionStateChanged(true, true))
+                                  .After(showControls);
   EXPECT_CALL(*mock_web_contents_observer(),
-              MediaSessionStateChanged(false, false, testing::_))
+              MediaSessionStateChanged(false, false))
       .After(pauseControls);
 
   std::unique_ptr<MockMediaSessionObserver> media_session_observer(
       new MockMediaSessionObserver);
 
   StartNewPlayer(media_session_observer.get(),
                  media::MediaContentType::Persistent);
   SystemSuspend(true);
 
   // This should reset the session and change it to a transient, so
   // hide the controls.
   StartNewPlayer(media_session_observer.get(),
                  media::MediaContentType::Transient);
 
   EXPECT_FALSE(IsControllable());
   EXPECT_FALSE(IsSuspended());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest,
                        ControlsUpdatedWhenNewPlayerResetsSession) {
   Expectation showControls = EXPECT_CALL(*mock_web_contents_observer(),
-      MediaSessionStateChanged(true, false, testing::_));
+                                         MediaSessionStateChanged(true, false));
   Expectation pauseControls = EXPECT_CALL(*mock_web_contents_observer(),
-      MediaSessionStateChanged(true, true, testing::_)).After(showControls);
+                                          MediaSessionStateChanged(true, true))
+                                  .After(showControls);
   EXPECT_CALL(*mock_web_contents_observer(),
-              MediaSessionStateChanged(true, false, testing::_))
+              MediaSessionStateChanged(true, false))
       .After(pauseControls);
 
   std::unique_ptr<MockMediaSessionObserver> media_session_observer(
       new MockMediaSessionObserver);
 
   StartNewPlayer(media_session_observer.get(),
                  media::MediaContentType::Persistent);
   SystemSuspend(true);
 
   // This should reset the session and update the controls.
   StartNewPlayer(media_session_observer.get(),
                  media::MediaContentType::Persistent);
 
   EXPECT_TRUE(IsControllable());
   EXPECT_FALSE(IsSuspended());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest,
                        ControlsResumedWhenPlayerIsResumed) {
   Expectation showControls = EXPECT_CALL(*mock_web_contents_observer(),
-      MediaSessionStateChanged(true, false, testing::_));
+                                         MediaSessionStateChanged(true, false));
   Expectation pauseControls = EXPECT_CALL(*mock_web_contents_observer(),
-      MediaSessionStateChanged(true, true, testing::_)).After(showControls);
+                                          MediaSessionStateChanged(true, true))
+                                  .After(showControls);
   EXPECT_CALL(*mock_web_contents_observer(),
-              MediaSessionStateChanged(true, false, testing::_))
+              MediaSessionStateChanged(true, false))
       .After(pauseControls);
 
   std::unique_ptr<MockMediaSessionObserver> media_session_observer(
       new MockMediaSessionObserver);
 
   StartNewPlayer(media_session_observer.get(),
                  media::MediaContentType::Persistent);
   SystemSuspend(true);
 
   // This should resume the session and update the controls.
   AddPlayer(media_session_observer.get(), 0,
             media::MediaContentType::Persistent);
 
   EXPECT_TRUE(IsControllable());
   EXPECT_FALSE(IsSuspended());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest,
                        ControlsUpdatedDueToResumeSessionAction) {
   Expectation showControls = EXPECT_CALL(*mock_web_contents_observer(),
-      MediaSessionStateChanged(true, false, testing::_));
+                                         MediaSessionStateChanged(true, false));
   EXPECT_CALL(*mock_web_contents_observer(),
-              MediaSessionStateChanged(true, true, testing::_))
+              MediaSessionStateChanged(true, true))
       .After(showControls);
 
   std::unique_ptr<MockMediaSessionObserver> media_session_observer(
       new MockMediaSessionObserver);
 
   StartNewPlayer(media_session_observer.get(),
                  media::MediaContentType::Persistent);
   UISuspend();
 
   EXPECT_TRUE(IsControllable());
   EXPECT_TRUE(IsSuspended());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest,
                        ControlsUpdatedDueToSuspendSessionAction) {
   Expectation showControls = EXPECT_CALL(*mock_web_contents_observer(),
-      MediaSessionStateChanged(true, false, testing::_));
+                                         MediaSessionStateChanged(true, false));
   Expectation pauseControls = EXPECT_CALL(*mock_web_contents_observer(),
-      MediaSessionStateChanged(true, true, testing::_)).After(showControls);
+                                          MediaSessionStateChanged(true, true))
+                                  .After(showControls);
   EXPECT_CALL(*mock_web_contents_observer(),
-              MediaSessionStateChanged(true, false, testing::_))
+              MediaSessionStateChanged(true, false))
       .After(pauseControls);
 
   std::unique_ptr<MockMediaSessionObserver> media_session_observer(
       new MockMediaSessionObserver);
 
   StartNewPlayer(media_session_observer.get(),
                  media::MediaContentType::Persistent);
   UISuspend();
   UIResume();
 
@@ skipping 368 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));
 }