[MediaSession] Add playbackState attribute to Blink MediaSession and use it to determine playback s…

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>
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_samples.h"
 #include "base/test/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_player_observer.h"
 #include "content/public/browser/media_session.h"
 #include "content/public/browser/media_session_observer.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/content_browser_test.h"
 #include "content/shell/browser/shell.h"
 #include "media/base/media_content_type.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using content::WebContents;
@@ skipping 27 matching lines @@
 class MockMediaSessionObserver : public MediaSessionObserver {
  public:
   MockMediaSessionObserver(MediaSession* media_session)
       : MediaSessionObserver(media_session) {}
 
   MOCK_METHOD2(MediaSessionStateChanged,
                void(bool is_controllable, bool is_suspended));
   MOCK_METHOD0(MediaSessionDestroyed, void());
 };
 
+class MockMediaSessionServiceImpl : public content::MediaSessionServiceImpl {
+ public:
+  explicit MockMediaSessionServiceImpl(content::RenderFrameHost* rfh)
+      : MediaSessionServiceImpl(rfh) {}
+  ~MockMediaSessionServiceImpl() override = default;
+};
+
 }  // namespace
 
 class MediaSessionImplBrowserTest : public content::ContentBrowserTest {
  protected:
   MediaSessionImplBrowserTest() = default;
 
   void SetUpOnMainThread() override {
     ContentBrowserTest::SetUpOnMainThread();
 
     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(
         base::WrapUnique(mock_audio_focus_delegate_));
     ASSERT_TRUE(media_session_);
   }
 
   void TearDownOnMainThread() override {
     mock_media_session_observer_.reset();
+    media_session_->RemoveAllPlayersForTest();
+    mock_media_session_service_.reset();
 
-    media_session_->RemoveAllPlayersForTest();
     media_session_ = nullptr;
 
     ContentBrowserTest::TearDownOnMainThread();
   }
 
   void StartNewPlayer(MockMediaSessionPlayerObserver* player_observer,
                       media::MediaContentType media_content_type) {
     bool result = AddPlayer(player_observer, player_observer->StartNewPlayer(),
                             media_content_type);
     EXPECT_TRUE(result);
@@ skipping 41 matching lines @@
     media_session_->OnSuspendInternal(MediaSession::SuspendType::SYSTEM,
                                       temporary
                                           ? MediaSessionImpl::State::SUSPENDED
                                           : MediaSessionImpl::State::INACTIVE);
   }
 
   void SystemStartDucking() { media_session_->StartDucking(); }
 
   void SystemStopDucking() { media_session_->StopDucking(); }
 
+  void EnsureMediaSessionService() {
+    mock_media_session_service_.reset(new MockMediaSessionServiceImpl(
+        shell()->web_contents()->GetMainFrame()));
+    mock_media_session_service_->SetMetadata(content::MediaMetadata());
+  }
+
+  void SetPlaybackState(blink::mojom::MediaSessionPlaybackState state) {
+    mock_media_session_service_->SetPlaybackState(state);
+  }
+
   MockMediaSessionObserver* mock_media_session_observer() {
     return mock_media_session_observer_.get();
   }
 
   MockAudioFocusDelegate* mock_audio_focus_delegate() {
     return mock_audio_focus_delegate_;
   }
 
   std::unique_ptr<MediaSessionImpl> CreateDummyMediaSession() {
     return base::WrapUnique<MediaSessionImpl>(new MediaSessionImpl(nullptr));
   }
 
   MediaSessionUmaHelper* GetMediaSessionUMAHelper() {
     return media_session_->uma_helper_for_test();
   }
 
  protected:
   MediaSessionImpl* media_session_;
   std::unique_ptr<MockMediaSessionObserver> mock_media_session_observer_;
   MockAudioFocusDelegate* mock_audio_focus_delegate_;
+  std::unique_ptr<MockMediaSessionServiceImpl> mock_media_session_service_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaSessionImplBrowserTest);
 };
 
 IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest,
                        PlayersFromSameObserverDoNotStopEachOtherInSameSession) {
   auto player_observer = base::MakeUnique<MockMediaSessionPlayerObserver>();
 
   StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent);
   StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent);
@@ skipping 842 matching lines @@
   auto player_observer = base::MakeUnique<MockMediaSessionPlayerObserver>();
 
   EXPECT_CALL(*mock_audio_focus_delegate(), AbandonAudioFocus())
       .Times(1);  // Called in TearDown
   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,
+                       ActualPlaybackStateWhilePlayerPaused) {
+  EnsureMediaSessionService();
+  auto player_observer = base::MakeUnique<MockMediaSessionPlayerObserver>(
+      shell()->web_contents()->GetMainFrame());
+
+  ::testing::Sequence s;
+  EXPECT_CALL(*mock_media_session_observer(),
+              MediaSessionStateChanged(true, false))
+      .InSequence(s);
+  EXPECT_CALL(*mock_media_session_observer(),
+              MediaSessionStateChanged(true, true))
+      .InSequence(s);
+  EXPECT_CALL(*mock_media_session_observer(),
+              MediaSessionStateChanged(true, false))
+      .InSequence(s);
+  EXPECT_CALL(*mock_media_session_observer(),
+              MediaSessionStateChanged(true, true))
+      .InSequence(s);
+  EXPECT_CALL(*mock_media_session_observer(),
+              MediaSessionStateChanged(true, true))
+      .InSequence(s);
+
+  StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent);
+  OnPlayerPaused(player_observer.get(), 0);
+  SetPlaybackState(blink::mojom::MediaSessionPlaybackState::PLAYING);
+  SetPlaybackState(blink::mojom::MediaSessionPlaybackState::PAUSED);
+  SetPlaybackState(blink::mojom::MediaSessionPlaybackState::NONE);
+
+  // Verify before test exists. Otherwise the sequence will expire and cause
+  // weird problems.
+  ::testing::Mock::VerifyAndClear(mock_media_session_observer());
+}
+
+IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest,
+                       ActualPlaybackStateWhilePlayerPlaying) {
+  EnsureMediaSessionService();
+  auto player_observer = base::MakeUnique<MockMediaSessionPlayerObserver>(
+      shell()->web_contents()->GetMainFrame());
+  ::testing::Sequence s;
+  EXPECT_CALL(*mock_media_session_observer(),
+              MediaSessionStateChanged(true, false))
+      .InSequence(s);
+  EXPECT_CALL(*mock_media_session_observer(),
+              MediaSessionStateChanged(true, false))
+      .InSequence(s);
+  EXPECT_CALL(*mock_media_session_observer(),
+              MediaSessionStateChanged(true, false))
+      .InSequence(s);
+  EXPECT_CALL(*mock_media_session_observer(),
+              MediaSessionStateChanged(true, false))
+      .InSequence(s);
+
+  StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent);
+  SetPlaybackState(blink::mojom::MediaSessionPlaybackState::PLAYING);
+  SetPlaybackState(blink::mojom::MediaSessionPlaybackState::PAUSED);
+  SetPlaybackState(blink::mojom::MediaSessionPlaybackState::NONE);
+
+  // Verify before test exists. Otherwise the sequence will expire and cause
+  // weird problems.
+  ::testing::Mock::VerifyAndClear(mock_media_session_observer());
+}
+
+IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest,
+                       ActualPlaybackStateWhilePlayerRemoved) {
+  EnsureMediaSessionService();
+  auto player_observer = base::MakeUnique<MockMediaSessionPlayerObserver>(
+      shell()->web_contents()->GetMainFrame());
+
+  ::testing::Sequence s;
+  EXPECT_CALL(*mock_media_session_observer(),
+              MediaSessionStateChanged(true, false))
+      .InSequence(s);
+  EXPECT_CALL(*mock_media_session_observer(),
+              MediaSessionStateChanged(false, _))
+      .InSequence(s);
+
+  StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent);
+  RemovePlayer(player_observer.get(), 0);
+
+  SetPlaybackState(blink::mojom::MediaSessionPlaybackState::PLAYING);
+  SetPlaybackState(blink::mojom::MediaSessionPlaybackState::PAUSED);
+  SetPlaybackState(blink::mojom::MediaSessionPlaybackState::NONE);
+
+  // Verify before test exists. Otherwise the sequence will expire and cause
+  // weird problems.
+  ::testing::Mock::VerifyAndClear(mock_media_session_observer());
+}
+
+IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest,
                        UMA_Suspended_SystemTransient) {
   auto player_observer = base::MakeUnique<MockMediaSessionPlayerObserver>();
   base::HistogramTester tester;
 
   StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent);
   SystemSuspend(true);
 
   std::unique_ptr<base::HistogramSamples> samples(
       tester.GetHistogramSamplesSinceCreation("Media.Session.Suspended"));
   EXPECT_EQ(1, samples->TotalCount());
@@ skipping 267 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));
 }