[Media Session] Trigger action on play / pause

At the moment on Android we trigger the kPlay or kPause
actions if they are registered. This moves that logic
a layer down to C++ so it will work for keyboard
controls too.

BUG=894255

Change-Id: I0eae3ac51b7d772643ab2a56091e3f0ddb6b2325
Reviewed-on: https://chromium-review.googlesource.com/c/1404178Reviewed-by: Mounir Lamouri <mlamouri@chromium.org>
Commit-Queue: Becca Hughes <beccahughes@chromium.org>
Cr-Commit-Position: refs/heads/master@{#622044}

chrome/android/java/src/org/chromium/chrome/browser/media/ui/MediaSessionTabHelper.java

@@ -94,15 +94,9 @@ public class MediaSessionTabHelper implements MediaImageCallback {
             MediaSessionUMA.recordPlay(
                     MediaSessionTabHelper.convertMediaActionSourceToUMA(actionSource));
 
-            if (mMediaSessionObserver.getMediaSession() != null) {
-                if (mMediaSessionActions != null
-                        && mMediaSessionActions.contains(MediaSessionAction.PLAY)) {
-                    mMediaSessionObserver.getMediaSession()
-                            .didReceiveAction(MediaSessionAction.PLAY);
-                } else {
-                    mMediaSessionObserver.getMediaSession().resume();
-                }
-            }
+            if (mMediaSessionObserver.getMediaSession() == null) return;
+
+            mMediaSessionObserver.getMediaSession().resume();
         }
 
         @Override
@@ -112,15 +106,9 @@ public class MediaSessionTabHelper implements MediaImageCallback {
             MediaSessionUMA.recordPause(
                     MediaSessionTabHelper.convertMediaActionSourceToUMA(actionSource));
 
-            if (mMediaSessionObserver.getMediaSession() != null) {
-                if (mMediaSessionActions != null
-                        && mMediaSessionActions.contains(MediaSessionAction.PAUSE)) {
-                    mMediaSessionObserver.getMediaSession()
-                            .didReceiveAction(MediaSessionAction.PAUSE);
-                } else {
-                    mMediaSessionObserver.getMediaSession().suspend();
-                }
-            }
+            if (mMediaSessionObserver.getMediaSession() == null) return;
+
+            mMediaSessionObserver.getMediaSession().suspend();
         }
 
         @Override

content/browser/media/session/media_session_impl.cc

@@ -402,6 +402,13 @@ void MediaSessionImpl::Resume(SuspendType suspend_type) {
     return;
 
   if (suspend_type == SuspendType::kUI) {
+    // If the site has registered an action handler for play then we should
+    // pass it to the site and let them handle it.
+    if (IsActionSupported(media_session::mojom::MediaSessionAction::kPlay)) {
+      DidReceiveAction(media_session::mojom::MediaSessionAction::kPlay);
+      return;
+    }
+
     MediaSessionUmaHelper::RecordMediaSessionUserAction(
         MediaSessionUmaHelper::MediaSessionUserAction::PlayDefault);
   }
@@ -431,6 +438,13 @@ void MediaSessionImpl::Suspend(SuspendType suspend_type) {
     return;
 
   if (suspend_type == SuspendType::kUI) {
+    // If the site has registered an action handler for pause then we should
+    // pass it to the site and let them handle it.
+    if (IsActionSupported(media_session::mojom::MediaSessionAction::kPause)) {
+      DidReceiveAction(media_session::mojom::MediaSessionAction::kPause);
+      return;
+    }
+
     MediaSessionUmaHelper::RecordMediaSessionUserAction(
         MediaSessionUserAction::PauseDefault);
   }

content/browser/media/session/media_session_impl_browsertest.cc

@@ -16,9 +16,9 @@
 #include "base/test/metrics/histogram_tester.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "content/browser/media/session/audio_focus_delegate.h"
-#include "content/browser/media/session/media_session_service_impl.h"
 #include "content/browser/media/session/mock_media_session_observer.h"
 #include "content/browser/media/session/mock_media_session_player_observer.h"
+#include "content/browser/media/session/mock_media_session_service_impl.h"
 #include "content/public/browser/media_session.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/content_browser_test.h"
@@ -96,13 +96,6 @@ class MockAudioFocusDelegate : public AudioFocusDelegate {
   base::Optional<AudioFocusType> audio_focus_type_;
 };
 
-class MockMediaSessionServiceImpl : public content::MediaSessionServiceImpl {
- public:
-  explicit MockMediaSessionServiceImpl(content::RenderFrameHost* rfh)
-      : MediaSessionServiceImpl(rfh) {}
-  ~MockMediaSessionServiceImpl() override = default;
-};
-
 }  // namespace
 
 class MediaSessionImplBrowserTest : public content::ContentBrowserTest {
@@ -197,8 +190,9 @@ class MediaSessionImplBrowserTest : public content::ContentBrowserTest {
   void SystemStopDucking() { media_session_->StopDucking(); }
 
   void EnsureMediaSessionService() {
-    mock_media_session_service_.reset(new NiceMock<MockMediaSessionServiceImpl>(
-        shell()->web_contents()->GetMainFrame()));
+    mock_media_session_service_.reset(
+        new NiceMock<content::MockMediaSessionServiceImpl>(
+            shell()->web_contents()->GetMainFrame()));
   }
 
   void SetPlaybackState(blink::mojom::MediaSessionPlaybackState state) {
@@ -246,7 +240,8 @@ class MediaSessionImplBrowserTest : public content::ContentBrowserTest {
   std::unique_ptr<content::MockMediaSessionObserver>
       mock_media_session_observer_;
   MockAudioFocusDelegate* mock_audio_focus_delegate_;
-  std::unique_ptr<MockMediaSessionServiceImpl> mock_media_session_service_;
+  std::unique_ptr<content::MockMediaSessionServiceImpl>
+      mock_media_session_service_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaSessionImplBrowserTest);
 };

content/browser/media/session/media_session_impl_service_routing_unittest.cc

@@ -11,8 +11,8 @@
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "content/browser/media/session/media_session_player_observer.h"
-#include "content/browser/media/session/media_session_service_impl.h"
 #include "content/browser/media/session/mock_media_session_observer.h"
+#include "content/browser/media/session/mock_media_session_service_impl.h"
 #include "content/public/test/test_service_manager_context.h"
 #include "content/test/test_render_view_host.h"
 #include "content/test/test_web_contents.h"
@@ -37,32 +37,6 @@ constexpr base::TimeDelta kDefaultSeekTime =
 
 static const int kPlayerId = 0;
 
-class MockMediaSessionServiceImpl : public MediaSessionServiceImpl {
- public:
-  explicit MockMediaSessionServiceImpl(RenderFrameHost* rfh)
-      : MediaSessionServiceImpl(rfh) {}
-  ~MockMediaSessionServiceImpl() override = default;
-};
-
-class MockMediaSessionClient : public blink::mojom::MediaSessionClient {
- public:
-  MockMediaSessionClient() : binding_(this) {}
-
-  blink::mojom::MediaSessionClientPtr CreateInterfacePtrAndBind() {
-    blink::mojom::MediaSessionClientPtr client;
-    binding_.Bind(mojo::MakeRequest(&client));
-    return client;
-  }
-
-  MOCK_METHOD1(DidReceiveAction,
-               void(media_session::mojom::MediaSessionAction action));
-
- private:
-  mojo::Binding<blink::mojom::MediaSessionClient> binding_;
-
-  DISALLOW_COPY_AND_ASSIGN(MockMediaSessionClient);
-};
-
 class MockMediaSessionPlayerObserver : public MediaSessionPlayerObserver {
  public:
   explicit MockMediaSessionPlayerObserver(RenderFrameHost* rfh)
@@ -109,7 +83,6 @@ class MediaSessionImplServiceRoutingTest
   void TearDown() override {
     mock_media_session_observer_.reset();
     services_.clear();
-    clients_.clear();
 
     test_service_manager_context_.reset();
     RenderViewHostImplTestHarness::TearDown();
@@ -123,18 +96,16 @@ class MediaSessionImplServiceRoutingTest
   void CreateServiceForFrame(TestRenderFrameHost* frame) {
     services_[frame] =
         std::make_unique<NiceMock<MockMediaSessionServiceImpl>>(frame);
-    clients_[frame] = std::make_unique<NiceMock<MockMediaSessionClient>>();
-    services_[frame]->SetClient(clients_[frame]->CreateInterfacePtrAndBind());
   }
 
   void DestroyServiceForFrame(TestRenderFrameHost* frame) {
     services_.erase(frame);
-    clients_.erase(frame);
   }
 
   MockMediaSessionClient* GetClientForFrame(TestRenderFrameHost* frame) {
-    auto iter = clients_.find(frame);
-    return (iter != clients_.end()) ? iter->second.get() : nullptr;
+    auto iter = services_.find(frame);
+    return (iter != services_.end()) ? &iter->second.get()->mock_client()
+                                     : nullptr;
   }
 
   void StartPlayerForFrame(TestRenderFrameHost* frame) {
@@ -176,10 +147,6 @@ class MediaSessionImplServiceRoutingTest
                               std::unique_ptr<MockMediaSessionServiceImpl>>;
   ServiceMap services_;
 
-  using ClientMap =
-      std::map<TestRenderFrameHost*, std::unique_ptr<MockMediaSessionClient>>;
-  ClientMap clients_;
-
   using PlayerMap = std::map<TestRenderFrameHost*,
                              std::unique_ptr<MockMediaSessionPlayerObserver>>;
   PlayerMap players_;

content/browser/media/session/media_session_impl_uma_unittest.cc

@@ -10,6 +10,7 @@
 #include "base/metrics/histogram_samples.h"
 #include "base/test/metrics/histogram_tester.h"
 #include "content/browser/media/session/media_session_player_observer.h"
+#include "content/browser/media/session/mock_media_session_service_impl.h"
 #include "content/public/test/test_service_manager_context.h"
 #include "content/test/test_render_view_host.h"
 #include "content/test/test_web_contents.h"
@@ -77,9 +78,14 @@ class MediaSessionImplUmaTest : public RenderViewHostImplTestHarness {
 
     contents()->GetMainFrame()->InitializeRenderFrameIfNeeded();
     StartPlayer();
+
+    mock_media_session_service_.reset(
+        new testing::NiceMock<MockMediaSessionServiceImpl>(
+            contents()->GetMainFrame()));
   }
 
   void TearDown() override {
+    mock_media_session_service_.reset();
     test_service_manager_context_.reset();
     RenderViewHostImplTestHarness::TearDown();
   }
@@ -99,6 +105,7 @@ class MediaSessionImplUmaTest : public RenderViewHostImplTestHarness {
     return histogram_tester_.GetHistogramSamplesSinceCreation(name);
   }
 
+  std::unique_ptr<MockMediaSessionServiceImpl> mock_media_session_service_;
   std::unique_ptr<MockMediaSessionPlayerObserver> player_;
   base::HistogramTester histogram_tester_;
 
@@ -116,6 +123,19 @@ TEST_F(MediaSessionImplUmaTest, RecordPauseDefaultOnUISuspend) {
                    MediaSessionUserAction::PauseDefault)));
 }
 
+TEST_F(MediaSessionImplUmaTest, RecordPauseDefaultOnUISuspendWithAction) {
+  mock_media_session_service_->EnableAction(
+      media_session::mojom::MediaSessionAction::kPause);
+
+  GetSession()->Suspend(SuspendType::kUI);
+
+  std::unique_ptr<base::HistogramSamples> samples(
+      GetHistogramSamplesSinceTestStart("Media.Session.UserAction"));
+  EXPECT_EQ(1, samples->TotalCount());
+  EXPECT_EQ(1, samples->GetCount(static_cast<base::HistogramBase::Sample>(
+                   MediaSessionUserAction::Pause)));
+}
+
 TEST_F(MediaSessionImplUmaTest, RecordPauseDefaultOnSystemSuspend) {
   GetSession()->Suspend(SuspendType::kSystem);
   std::unique_ptr<base::HistogramSamples> samples(
@@ -140,6 +160,20 @@ TEST_F(MediaSessionImplUmaTest, RecordPauseDefaultOnUIResume) {
                    MediaSessionUserAction::PlayDefault)));
 }
 
+TEST_F(MediaSessionImplUmaTest, RecordPauseDefaultOnUIResumeWithAction) {
+  mock_media_session_service_->EnableAction(
+      media_session::mojom::MediaSessionAction::kPlay);
+
+  GetSession()->Suspend(SuspendType::kSystem);
+  GetSession()->Resume(SuspendType::kUI);
+
+  std::unique_ptr<base::HistogramSamples> samples(
+      GetHistogramSamplesSinceTestStart("Media.Session.UserAction"));
+  EXPECT_EQ(1, samples->TotalCount());
+  EXPECT_EQ(1, samples->GetCount(static_cast<base::HistogramBase::Sample>(
+                   MediaSessionUserAction::Play)));
+}
+
 TEST_F(MediaSessionImplUmaTest, RecordPauseDefaultOnSystemResume) {
   GetSession()->Suspend(SuspendType::kSystem);
   GetSession()->Resume(SuspendType::kSystem);

content/browser/media/session/media_session_impl_unittest.cc

@@ -11,6 +11,7 @@
 #include "build/build_config.h"
 #include "content/browser/media/session/media_session_player_observer.h"
 #include "content/browser/media/session/mock_media_session_player_observer.h"
+#include "content/browser/media/session/mock_media_session_service_impl.h"
 #include "content/public/common/service_manager_connection.h"
 #include "content/public/test/test_renderer_host.h"
 #include "content/public/test/test_service_manager_context.h"
@@ -85,7 +86,9 @@ class MediaSessionImplTest : public RenderViewHostTestHarness {
 
     RenderViewHostTestHarness::SetUp();
 
-    player_observer_.reset(new MockMediaSessionPlayerObserver());
+    player_observer_.reset(new MockMediaSessionPlayerObserver(main_rfh()));
+    mock_media_session_service_.reset(
+        new testing::NiceMock<MockMediaSessionServiceImpl>(main_rfh()));
 
     // Connect to the Media Session service and bind |audio_focus_ptr_| to it.
     service_manager_context_ = std::make_unique<TestServiceManagerContext>();
@@ -96,6 +99,7 @@ class MediaSessionImplTest : public RenderViewHostTestHarness {
   }
 
   void TearDown() override {
+    mock_media_session_service_.reset();
     service_manager_context_.reset();
 
     RenderViewHostTestHarness::TearDown();
@@ -145,9 +149,25 @@ class MediaSessionImplTest : public RenderViewHostTestHarness {
     session->SetDelegateForTests(base::WrapUnique(delegate));
   }
 
+  MockMediaSessionServiceImpl& mock_media_session_service() const {
+    return *mock_media_session_service_.get();
+  }
+
+  MediaSessionImpl* GetMediaSession() {
+    return MediaSessionImpl::Get(web_contents());
+  }
+
+  void StartNewPlayer() {
+    GetMediaSession()->AddPlayer(player_observer_.get(),
+                                 player_observer_->StartNewPlayer(),
+                                 media::MediaContentType::Persistent);
+  }
+
  private:
   base::test::ScopedFeatureList scoped_feature_list_;
 
+  std::unique_ptr<MockMediaSessionServiceImpl> mock_media_session_service_;
+
   media_session::mojom::AudioFocusManagerPtr audio_focus_ptr_;
 
   std::unique_ptr<TestServiceManagerContext> service_manager_context_;
@@ -156,162 +176,257 @@ class MediaSessionImplTest : public RenderViewHostTestHarness {
 };
 
 TEST_F(MediaSessionImplTest, SessionInfoState) {
-  std::unique_ptr<WebContents> web_contents(CreateTestWebContents());
-  MediaSessionImpl* media_session = MediaSessionImpl::Get(web_contents.get());
-  EXPECT_EQ(MediaSessionInfo::SessionState::kInactive, GetState(media_session));
+  EXPECT_EQ(MediaSessionInfo::SessionState::kInactive,
+            GetState(GetMediaSession()));
 
   {
-    MockMediaSessionMojoObserver observer(*media_session);
-    RequestAudioFocus(media_session, AudioFocusType::kGain);
-    FlushForTesting(media_session);
+    MockMediaSessionMojoObserver observer(*GetMediaSession());
+    RequestAudioFocus(GetMediaSession(), AudioFocusType::kGain);
+    FlushForTesting(GetMediaSession());
     observer.WaitForState(MediaSessionInfo::SessionState::kActive);
 
     EXPECT_TRUE(observer.session_info().Equals(
-        media_session::test::GetMediaSessionInfoSync(media_session)));
+        media_session::test::GetMediaSessionInfoSync(GetMediaSession())));
   }
 
   {
-    MockMediaSessionMojoObserver observer(*media_session);
-    media_session->StartDucking();
-    FlushForTesting(media_session);
+    MockMediaSessionMojoObserver observer(*GetMediaSession());
+    GetMediaSession()->StartDucking();
+    FlushForTesting(GetMediaSession());
     observer.WaitForState(MediaSessionInfo::SessionState::kDucking);
 
     EXPECT_TRUE(observer.session_info().Equals(
-        media_session::test::GetMediaSessionInfoSync(media_session)));
+        media_session::test::GetMediaSessionInfoSync(GetMediaSession())));
   }
 
   {
-    MockMediaSessionMojoObserver observer(*media_session);
-    media_session->StopDucking();
-    FlushForTesting(media_session);
+    MockMediaSessionMojoObserver observer(*GetMediaSession());
+    GetMediaSession()->StopDucking();
+    FlushForTesting(GetMediaSession());
     observer.WaitForState(MediaSessionInfo::SessionState::kActive);
 
     EXPECT_TRUE(observer.session_info().Equals(
-        media_session::test::GetMediaSessionInfoSync(media_session)));
+        media_session::test::GetMediaSessionInfoSync(GetMediaSession())));
   }
 
   {
-    MockMediaSessionMojoObserver observer(*media_session);
-    media_session->Suspend(MediaSession::SuspendType::kSystem);
-    FlushForTesting(media_session);
+    MockMediaSessionMojoObserver observer(*GetMediaSession());
+    GetMediaSession()->Suspend(MediaSession::SuspendType::kSystem);
+    FlushForTesting(GetMediaSession());
     observer.WaitForState(MediaSessionInfo::SessionState::kSuspended);
 
     EXPECT_TRUE(observer.session_info().Equals(
-        media_session::test::GetMediaSessionInfoSync(media_session)));
+        media_session::test::GetMediaSessionInfoSync(GetMediaSession())));
   }
 
   {
-    MockMediaSessionMojoObserver observer(*media_session);
-    media_session->Resume(MediaSession::SuspendType::kSystem);
-    FlushForTesting(media_session);
+    MockMediaSessionMojoObserver observer(*GetMediaSession());
+    GetMediaSession()->Resume(MediaSession::SuspendType::kSystem);
+    FlushForTesting(GetMediaSession());
     observer.WaitForState(MediaSessionInfo::SessionState::kActive);
 
     EXPECT_TRUE(observer.session_info().Equals(
-        media_session::test::GetMediaSessionInfoSync(media_session)));
+        media_session::test::GetMediaSessionInfoSync(GetMediaSession())));
   }
 
   {
-    MockMediaSessionMojoObserver observer(*media_session);
-    AbandonAudioFocus(media_session);
-    FlushForTesting(media_session);
+    MockMediaSessionMojoObserver observer(*GetMediaSession());
+    AbandonAudioFocus(GetMediaSession());
+    FlushForTesting(GetMediaSession());
     observer.WaitForState(MediaSessionInfo::SessionState::kInactive);
 
     EXPECT_TRUE(observer.session_info().Equals(
-        media_session::test::GetMediaSessionInfoSync(media_session)));
+        media_session::test::GetMediaSessionInfoSync(GetMediaSession())));
   }
 }
 
 TEST_F(MediaSessionImplTest, NotifyDelegateOnStateChange) {
-  std::unique_ptr<WebContents> web_contents(CreateTestWebContents());
-  MediaSessionImpl* media_session = MediaSessionImpl::Get(web_contents.get());
   MockAudioFocusDelegate* delegate = new MockAudioFocusDelegate();
-  SetDelegateForTests(media_session, delegate);
+  SetDelegateForTests(GetMediaSession(), delegate);
 
-  RequestAudioFocus(media_session, AudioFocusType::kGain);
+  RequestAudioFocus(GetMediaSession(), AudioFocusType::kGain);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(MediaSessionInfo::SessionState::kActive, delegate->GetState());
 
-  media_session->StartDucking();
+  GetMediaSession()->StartDucking();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(MediaSessionInfo::SessionState::kDucking, delegate->GetState());
 
-  media_session->StopDucking();
+  GetMediaSession()->StopDucking();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(MediaSessionInfo::SessionState::kActive, delegate->GetState());
 
-  media_session->Suspend(MediaSession::SuspendType::kSystem);
+  GetMediaSession()->Suspend(MediaSession::SuspendType::kSystem);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(MediaSessionInfo::SessionState::kSuspended, delegate->GetState());
 
-  media_session->Resume(MediaSession::SuspendType::kSystem);
+  GetMediaSession()->Resume(MediaSession::SuspendType::kSystem);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(MediaSessionInfo::SessionState::kActive, delegate->GetState());
 
-  AbandonAudioFocus(media_session);
+  AbandonAudioFocus(GetMediaSession());
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(MediaSessionInfo::SessionState::kInactive, delegate->GetState());
 }
 
 TEST_F(MediaSessionImplTest, PepperForcesDuckAndRequestsFocus) {
-  std::unique_ptr<WebContents> web_contents(CreateTestWebContents());
-  MediaSessionImpl* media_session = MediaSessionImpl::Get(web_contents.get());
-
   int player_id = player_observer_->StartNewPlayer();
 
   {
-    MockMediaSessionMojoObserver observer(*media_session);
-    media_session->AddPlayer(player_observer_.get(), player_id,
-                             media::MediaContentType::Pepper);
+    MockMediaSessionMojoObserver observer(*GetMediaSession());
+    GetMediaSession()->AddPlayer(player_observer_.get(), player_id,
+                                 media::MediaContentType::Pepper);
     observer.WaitForState(MediaSessionInfo::SessionState::kActive);
   }
 
-  EXPECT_TRUE(GetForceDuck(media_session));
+  EXPECT_TRUE(GetForceDuck(GetMediaSession()));
 
   {
-    MockMediaSessionMojoObserver observer(*media_session);
-    media_session->RemovePlayer(player_observer_.get(), player_id);
+    MockMediaSessionMojoObserver observer(*GetMediaSession());
+    GetMediaSession()->RemovePlayer(player_observer_.get(), player_id);
     observer.WaitForState(MediaSessionInfo::SessionState::kInactive);
   }
 
-  EXPECT_FALSE(GetForceDuck(media_session));
+  EXPECT_FALSE(GetForceDuck(GetMediaSession()));
 }
 
 TEST_F(MediaSessionImplTest, RegisterMojoObserver) {
-  std::unique_ptr<WebContents> web_contents(CreateTestWebContents());
-  MediaSessionImpl* media_session = MediaSessionImpl::Get(web_contents.get());
-
-  EXPECT_FALSE(HasMojoObservers(media_session));
+  EXPECT_FALSE(HasMojoObservers(GetMediaSession()));
 
-  MockMediaSessionMojoObserver observer(*media_session);
-  FlushForTesting(media_session);
+  MockMediaSessionMojoObserver observer(*GetMediaSession());
+  FlushForTesting(GetMediaSession());
 
-  EXPECT_TRUE(HasMojoObservers(media_session));
+  EXPECT_TRUE(HasMojoObservers(GetMediaSession()));
 }
 
 TEST_F(MediaSessionImplTest, SessionInfo_PlaybackState) {
-  std::unique_ptr<WebContents> web_contents(CreateTestWebContents());
-  MediaSessionImpl* media_session = MediaSessionImpl::Get(web_contents.get());
-
   EXPECT_EQ(MediaPlaybackState::kPaused,
-            media_session::test::GetMediaSessionInfoSync(media_session)
+            media_session::test::GetMediaSessionInfoSync(GetMediaSession())
                 ->playback_state);
 
   int player_id = player_observer_->StartNewPlayer();
 
   {
-    MockMediaSessionMojoObserver observer(*media_session);
-    media_session->AddPlayer(player_observer_.get(), player_id,
-                             media::MediaContentType::Persistent);
+    MockMediaSessionMojoObserver observer(*GetMediaSession());
+    GetMediaSession()->AddPlayer(player_observer_.get(), player_id,
+                                 media::MediaContentType::Persistent);
     observer.WaitForPlaybackState(MediaPlaybackState::kPlaying);
   }
 
   {
-    MockMediaSessionMojoObserver observer(*media_session);
-    media_session->OnPlayerPaused(player_observer_.get(), player_id);
+    MockMediaSessionMojoObserver observer(*GetMediaSession());
+    GetMediaSession()->OnPlayerPaused(player_observer_.get(), player_id);
     observer.WaitForPlaybackState(MediaPlaybackState::kPaused);
   }
 }
 
+TEST_F(MediaSessionImplTest, SuspendUI) {
+  EXPECT_CALL(
+      mock_media_session_service().mock_client(),
+      DidReceiveAction(media_session::mojom::MediaSessionAction::kPause))
+      .Times(0);
+
+  StartNewPlayer();
+
+  GetMediaSession()->Suspend(MediaSession::SuspendType::kUI);
+  mock_media_session_service().FlushForTesting();
+}
+
+TEST_F(MediaSessionImplTest, SuspendContent_WithAction) {
+  EXPECT_CALL(
+      mock_media_session_service().mock_client(),
+      DidReceiveAction(media_session::mojom::MediaSessionAction::kPause))
+      .Times(0);
+
+  StartNewPlayer();
+  mock_media_session_service().EnableAction(
+      media_session::mojom::MediaSessionAction::kPause);
+
+  GetMediaSession()->Suspend(MediaSession::SuspendType::kContent);
+  mock_media_session_service().FlushForTesting();
+}
+
+TEST_F(MediaSessionImplTest, SuspendSystem_WithAction) {
+  EXPECT_CALL(
+      mock_media_session_service().mock_client(),
+      DidReceiveAction(media_session::mojom::MediaSessionAction::kPause))
+      .Times(0);
+
+  StartNewPlayer();
+  mock_media_session_service().EnableAction(
+      media_session::mojom::MediaSessionAction::kPause);
+
+  GetMediaSession()->Suspend(MediaSession::SuspendType::kSystem);
+  mock_media_session_service().FlushForTesting();
+}
+
+TEST_F(MediaSessionImplTest, SuspendUI_WithAction) {
+  EXPECT_CALL(
+      mock_media_session_service().mock_client(),
+      DidReceiveAction(media_session::mojom::MediaSessionAction::kPause));
+
+  StartNewPlayer();
+  mock_media_session_service().EnableAction(
+      media_session::mojom::MediaSessionAction::kPause);
+
+  GetMediaSession()->Suspend(MediaSession::SuspendType::kUI);
+  mock_media_session_service().FlushForTesting();
+}
+
+TEST_F(MediaSessionImplTest, ResumeUI) {
+  EXPECT_CALL(mock_media_session_service().mock_client(),
+              DidReceiveAction(media_session::mojom::MediaSessionAction::kPlay))
+      .Times(0);
+
+  StartNewPlayer();
+
+  GetMediaSession()->Suspend(MediaSession::SuspendType::kSystem);
+  GetMediaSession()->Resume(MediaSession::SuspendType::kUI);
+  mock_media_session_service().FlushForTesting();
+}
+
+TEST_F(MediaSessionImplTest, ResumeContent_WithAction) {
+  EXPECT_CALL(mock_media_session_service().mock_client(),
+              DidReceiveAction(media_session::mojom::MediaSessionAction::kPlay))
+      .Times(0);
+
+  StartNewPlayer();
+  mock_media_session_service().EnableAction(
+      media_session::mojom::MediaSessionAction::kPlay);
+
+  GetMediaSession()->Suspend(MediaSession::SuspendType::kSystem);
+  GetMediaSession()->Resume(MediaSession::SuspendType::kContent);
+  mock_media_session_service().FlushForTesting();
+}
+
+TEST_F(MediaSessionImplTest, ResumeSystem_WithAction) {
+  EXPECT_CALL(mock_media_session_service().mock_client(),
+              DidReceiveAction(media_session::mojom::MediaSessionAction::kPlay))
+      .Times(0);
+
+  StartNewPlayer();
+  mock_media_session_service().EnableAction(
+      media_session::mojom::MediaSessionAction::kPlay);
+
+  GetMediaSession()->Suspend(MediaSession::SuspendType::kSystem);
+  GetMediaSession()->Resume(MediaSession::SuspendType::kSystem);
+  mock_media_session_service().FlushForTesting();
+}
+
+TEST_F(MediaSessionImplTest, ResumeUI_WithAction) {
+  EXPECT_CALL(
+      mock_media_session_service().mock_client(),
+      DidReceiveAction(media_session::mojom::MediaSessionAction::kPlay));
+
+  StartNewPlayer();
+  mock_media_session_service().EnableAction(
+      media_session::mojom::MediaSessionAction::kPlay);
+
+  GetMediaSession()->Suspend(MediaSession::SuspendType::kSystem);
+  GetMediaSession()->Resume(MediaSession::SuspendType::kUI);
+  mock_media_session_service().FlushForTesting();
+}
+
 #if !defined(OS_ANDROID)
 
 TEST_F(MediaSessionImplTest, WebContentsDestroyed_ReleasesFocus) {
@@ -410,56 +525,51 @@ TEST_F(MediaSessionImplTest, WebContentsDestroyed_StopsDucking) {
 }
 
 TEST_F(MediaSessionImplTest, RequestAudioFocus_OnFocus_Active) {
-  std::unique_ptr<WebContents> web_contents(CreateTestWebContents());
-  MediaSessionImpl* media_session = MediaSessionImpl::Get(web_contents.get());
   MockAudioFocusDelegate* delegate = new MockAudioFocusDelegate();
-  SetDelegateForTests(media_session, delegate);
+  SetDelegateForTests(GetMediaSession(), delegate);
 
   {
-    MockMediaSessionMojoObserver observer(*media_session);
-    RequestAudioFocus(media_session, AudioFocusType::kGain);
-    FlushForTesting(media_session);
+    MockMediaSessionMojoObserver observer(*GetMediaSession());
+    RequestAudioFocus(GetMediaSession(), AudioFocusType::kGain);
+    FlushForTesting(GetMediaSession());
     observer.WaitForState(MediaSessionInfo::SessionState::kActive);
   }
 
   EXPECT_EQ(1, delegate->request_audio_focus_count());
-  media_session->OnWebContentsFocused(nullptr);
+  GetMediaSession()->OnWebContentsFocused(nullptr);
   EXPECT_EQ(2, delegate->request_audio_focus_count());
 }
 
 TEST_F(MediaSessionImplTest, RequestAudioFocus_OnFocus_Inactive) {
-  std::unique_ptr<WebContents> web_contents(CreateTestWebContents());
-  MediaSessionImpl* media_session = MediaSessionImpl::Get(web_contents.get());
   MockAudioFocusDelegate* delegate = new MockAudioFocusDelegate();
-  SetDelegateForTests(media_session, delegate);
-  EXPECT_EQ(MediaSessionInfo::SessionState::kInactive, GetState(media_session));
+  SetDelegateForTests(GetMediaSession(), delegate);
+  EXPECT_EQ(MediaSessionInfo::SessionState::kInactive,
+            GetState(GetMediaSession()));
 
   EXPECT_EQ(0, delegate->request_audio_focus_count());
-  media_session->OnWebContentsFocused(nullptr);
+  GetMediaSession()->OnWebContentsFocused(nullptr);
   EXPECT_EQ(0, delegate->request_audio_focus_count());
 }
 
 TEST_F(MediaSessionImplTest, RequestAudioFocus_OnFocus_Suspended) {
-  std::unique_ptr<WebContents> web_contents(CreateTestWebContents());
-  MediaSessionImpl* media_session = MediaSessionImpl::Get(web_contents.get());
   MockAudioFocusDelegate* delegate = new MockAudioFocusDelegate();
-  SetDelegateForTests(media_session, delegate);
+  SetDelegateForTests(GetMediaSession(), delegate);
 
   {
-    MockMediaSessionMojoObserver observer(*media_session);
-    RequestAudioFocus(media_session, AudioFocusType::kGain);
-    FlushForTesting(media_session);
+    MockMediaSessionMojoObserver observer(*GetMediaSession());
+    RequestAudioFocus(GetMediaSession(), AudioFocusType::kGain);
+    FlushForTesting(GetMediaSession());
     observer.WaitForState(MediaSessionInfo::SessionState::kActive);
   }
 
   {
-    MockMediaSessionMojoObserver observer(*media_session);
-    media_session->Suspend(MediaSession::SuspendType::kSystem);
+    MockMediaSessionMojoObserver observer(*GetMediaSession());
+    GetMediaSession()->Suspend(MediaSession::SuspendType::kSystem);
     observer.WaitForState(MediaSessionInfo::SessionState::kSuspended);
   }
 
   EXPECT_EQ(1, delegate->request_audio_focus_count());
-  media_session->OnWebContentsFocused(nullptr);
+  GetMediaSession()->OnWebContentsFocused(nullptr);
   EXPECT_EQ(1, delegate->request_audio_focus_count());
 }
 

content/browser/media/session/media_session_service_impl.cc

@@ -51,6 +51,10 @@ void MediaSessionServiceImpl::DidFinishNavigation() {
   ClearActions();
 }
 
+void MediaSessionServiceImpl::FlushForTesting() {
+  client_.FlushForTesting();
+}
+
 void MediaSessionServiceImpl::SetClient(
     blink::mojom::MediaSessionClientPtr client) {
   client_ = std::move(client);

content/browser/media/session/media_session_service_impl.h

@@ -42,6 +42,7 @@ class CONTENT_EXPORT MediaSessionServiceImpl
   }
 
   void DidFinishNavigation();
+  void FlushForTesting();
 
   // blink::mojom::MediaSessionService implementation.
   void SetClient(blink::mojom::MediaSessionClientPtr client) override;

content/browser/media/session/mock_media_session_service_impl.cc

+// Copyright 2019 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/mock_media_session_service_impl.h"
+
+namespace content {
+
+MockMediaSessionClient::MockMediaSessionClient() = default;
+
+MockMediaSessionClient::~MockMediaSessionClient() = default;
+
+blink::mojom::MediaSessionClientPtr
+MockMediaSessionClient::CreateInterfacePtrAndBind() {
+  blink::mojom::MediaSessionClientPtr client;
+  binding_.Bind(mojo::MakeRequest(&client));
+  return client;
+}
+
+MockMediaSessionServiceImpl::MockMediaSessionServiceImpl(
+    content::RenderFrameHost* rfh)
+    : MediaSessionServiceImpl(rfh) {
+  SetClient(mock_client_.CreateInterfacePtrAndBind());
+}
+
+MockMediaSessionServiceImpl::~MockMediaSessionServiceImpl() = default;
+
+}  // namespace content

content/browser/media/session/mock_media_session_service_impl.h

+// Copyright 2019 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.
+
+#ifndef CONTENT_BROWSER_MEDIA_SESSION_MOCK_MEDIA_SESSION_SERVICE_IMPL_H_
+#define CONTENT_BROWSER_MEDIA_SESSION_MOCK_MEDIA_SESSION_SERVICE_IMPL_H_
+
+#include "content/browser/media/session/media_session_service_impl.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "third_party/blink/public/platform/modules/mediasession/media_session.mojom.h"
+
+namespace content {
+
+class MockMediaSessionClient : public blink::mojom::MediaSessionClient {
+ public:
+  MockMediaSessionClient();
+  ~MockMediaSessionClient() override;
+
+  blink::mojom::MediaSessionClientPtr CreateInterfacePtrAndBind();
+
+  MOCK_METHOD1(DidReceiveAction,
+               void(media_session::mojom::MediaSessionAction action));
+
+ private:
+  mojo::Binding<blink::mojom::MediaSessionClient> binding_{this};
+
+  DISALLOW_COPY_AND_ASSIGN(MockMediaSessionClient);
+};
+
+class MockMediaSessionServiceImpl : public content::MediaSessionServiceImpl {
+ public:
+  explicit MockMediaSessionServiceImpl(content::RenderFrameHost* rfh);
+  ~MockMediaSessionServiceImpl() override;
+
+  MockMediaSessionClient& mock_client() { return mock_client_; }
+
+ private:
+  MockMediaSessionClient mock_client_;
+};
+
+}  // namespace content
+
+#endif  // CONTENT_BROWSER_MEDIA_SESSION_MOCK_MEDIA_SESSION_SERVICE_IMPL_H_

content/test/BUILD.gn

@@ -53,6 +53,8 @@ jumbo_static_library("test_support") {
     "../browser/media/session/mock_media_session_observer.h",
     "../browser/media/session/mock_media_session_player_observer.cc",
     "../browser/media/session/mock_media_session_player_observer.h",
+    "../browser/media/session/mock_media_session_service_impl.cc",
+    "../browser/media/session/mock_media_session_service_impl.h",
     "../browser/service_worker/embedded_worker_test_helper.cc",
     "../browser/service_worker/embedded_worker_test_helper.h",
     "../browser/service_worker/service_worker_test_utils.cc",