Make MediaSession a runtime-enabled feature on Desktop.

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/android/media_session.h"
+#include "content/browser/media/session/media_session.h"
 
 #include <stddef.h>
 
 #include <list>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/metrics/histogram_samples.h"
 #include "base/test/histogram_tester.h"
 #include "base/test/simple_test_clock.h"
-#include "content/browser/media/android/media_session_observer.h"
+#include "content/browser/media/session/media_session_delegate.h"
+#include "content/browser/media/session/mock_media_session_observer.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/test/content_browser_test.h"
 #include "content/shell/browser/shell.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using content::WebContents;
 using content::WebContentsObserver;
 using content::MediaSession;
+using content::MediaSessionDelegate;
 using content::MediaSessionObserver;
 using content::MediaSessionUmaHelper;
+using content::MockMediaSessionObserver;
 
 using ::testing::Expectation;
 
 namespace {
 
-class MockMediaSessionObserver : public MediaSessionObserver {
+class MockMediaSessionDelegate : public MediaSessionDelegate {
  public:
-  MockMediaSessionObserver()
-      : received_resume_calls_(0),
-        received_suspend_calls_(0) {
+  bool RequestAudioFocus(MediaSession::Type) override {
+    return true;
   }
 
-  ~MockMediaSessionObserver() override = default;
-
-  // Implements MediaSessionObserver.
-  void OnSuspend(int player_id) override {
-    EXPECT_GE(player_id, 0);
-    EXPECT_GT(players_.size(), static_cast<size_t>(player_id));
-
-    ++received_suspend_calls_;
-    players_[player_id].is_playing_ = false;
+  void AbandonAudioFocus() override {
   }
-
-  void OnResume(int player_id) override {
-    EXPECT_GE(player_id, 0);
-    EXPECT_GT(players_.size(), static_cast<size_t>(player_id));
-
-    ++received_resume_calls_;
-    players_[player_id].is_playing_ = true;
-  }
-
-  void OnSetVolumeMultiplier(int player_id, double volume_multiplier) override {
-    EXPECT_GE(player_id, 0);
-    EXPECT_GT(players_.size(), static_cast<size_t>(player_id));
-
-    EXPECT_GE(volume_multiplier, 0.0f);
-    EXPECT_LE(volume_multiplier, 1.0f);
-
-    players_[player_id].volume_multiplier_ = volume_multiplier;
-  }
-
-  int StartNewPlayer() {
-    players_.push_back(MockPlayer(true, 1.0f));
-    return players_.size() - 1;
-  }
-
-  bool IsPlaying(size_t player_id) {
-    EXPECT_GT(players_.size(), player_id);
-    return players_[player_id].is_playing_;
-  }
-
-  double GetVolumeMultiplier(size_t player_id) {
-    EXPECT_GT(players_.size(), player_id);
-    return players_[player_id].volume_multiplier_;
-  }
-
-  void SetPlaying(size_t player_id, bool playing) {
-    EXPECT_GT(players_.size(), player_id);
-    players_[player_id].is_playing_ = playing;
-  }
-
-  int received_suspend_calls() const {
-    return received_suspend_calls_;
-  }
-
-  int received_resume_calls() const {
-    return received_resume_calls_;
-  }
-
- private:
-  struct MockPlayer {
-   public:
-    MockPlayer(bool is_playing = true, double volume_multiplier = 1.0f)
-        : is_playing_(is_playing),
-          volume_multiplier_(volume_multiplier) {}
-    bool is_playing_;
-    double volume_multiplier_;
-  };
-
-  // Basic representation of the players. The position in the vector is the
-  // player_id. The value of the vector is the playing status and volume.
-  std::vector<MockPlayer> players_;
-
-  int received_resume_calls_;
-  int received_suspend_calls_;
 };
 
 class MockWebContentsObserver : public WebContentsObserver {
  public:
   MockWebContentsObserver(WebContents* web_contents)
       : WebContentsObserver(web_contents) {}
 
   MOCK_METHOD2(MediaSessionStateChanged,
                void(bool is_controllable, bool is_suspended));
 };
 
 }  // namespace
 
 class MediaSessionBrowserTest : public content::ContentBrowserTest {
  protected:
   MediaSessionBrowserTest() = default;
 
   void SetUpOnMainThread() override {
     ContentBrowserTest::SetUpOnMainThread();
 
     mock_web_contents_observer_.reset(
         new MockWebContentsObserver(shell()->web_contents()));
     media_session_ = MediaSession::Get(shell()->web_contents());
-    media_session_->ResetJavaRefForTest();
+    media_session_->SetDelegateForTests(
+        scoped_ptr<MediaSessionDelegate>(new MockMediaSessionDelegate()));
     ASSERT_TRUE(media_session_);
   }
 
   void TearDownOnMainThread() override {
     mock_web_contents_observer_.reset();
 
     media_session_->RemoveAllPlayersForTest();
     media_session_ = nullptr;
 
     ContentBrowserTest::TearDownOnMainThread();
@@ skipping 32 matching lines @@
 
   MediaSession::Type GetSessionType() {
     return media_session_->audio_focus_type_for_test();
   }
 
   bool IsControllable() { return media_session_->IsControllable(); }
 
   bool IsSuspended() { return media_session_->IsSuspended(); }
 
   void UIResume() {
-    media_session_->Resume();
+    media_session_->Resume(MediaSession::SuspendType::UI);
   }
 
   void SystemResume() {
-    media_session_->OnResume(nullptr, nullptr);
+    media_session_->OnResumeInternal(MediaSession::SuspendType::SYSTEM);
   }
 
   void UISuspend() {
-    media_session_->Suspend();
+    media_session_->Suspend(MediaSession::SuspendType::UI);
   }
 
   void SystemSuspend(bool temporary) {
-    media_session_->OnSuspend(nullptr, nullptr, temporary);
+    media_session_->OnSuspendInternal(
+        MediaSession::SuspendType::SYSTEM,
+        temporary ? MediaSession::State::SUSPENDED
+                  : MediaSession::State::INACTIVE);
   }
 
   void SystemSetVolumeMultiplier(double volume_multiplier) {
-    media_session_->OnSetVolumeMultiplier(
-        nullptr, nullptr, volume_multiplier);
+    media_session_->SetVolumeMultiplier(volume_multiplier);
   }
 
   MockWebContentsObserver* mock_web_contents_observer() {
     return mock_web_contents_observer_.get();
   }
 
   scoped_ptr<MediaSession> CreateDummyMediaSession() {
       return scoped_ptr<MediaSession>(new MediaSession(nullptr));
   }
 
@@ skipping 140 matching lines @@
 
   EXPECT_FALSE(HasAudioFocus());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, StopGivesAwayAudioFocus) {
   scoped_ptr<MockMediaSessionObserver> media_session_observer(
       new MockMediaSessionObserver);
 
   StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
 
-  media_session_->Stop();
+  media_session_->Stop(MediaSession::SuspendType::UI);
 
   EXPECT_FALSE(HasAudioFocus());
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, ResumeGivesBackAudioFocus) {
   scoped_ptr<MockMediaSessionObserver> media_session_observer(
       new MockMediaSessionObserver);
 
   StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
 
@@ skipping 412 matching lines @@
                                   .After(showControls);
   EXPECT_CALL(*mock_web_contents_observer(),
               MediaSessionStateChanged(false, true))
       .After(pauseControls);
 
   scoped_ptr<MockMediaSessionObserver> media_session_observer(
       new MockMediaSessionObserver);
 
   StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
 
-  media_session_->Stop();
+  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));
   Expectation pauseControls = EXPECT_CALL(*mock_web_contents_observer(),
@@ skipping 262 matching lines @@
   EXPECT_EQ(0, samples->GetCount(1)); // System Permanent
   EXPECT_EQ(1, samples->GetCount(2)); // UI
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, UMA_Suspended_Stop) {
   scoped_ptr<MockMediaSessionObserver> media_session_observer(
       new MockMediaSessionObserver);
   base::HistogramTester tester;
 
   StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
-  media_session_->Stop();
+  media_session_->Stop(MediaSession::SuspendType::UI);
 
   scoped_ptr<base::HistogramSamples> samples(
       tester.GetHistogramSamplesSinceCreation("Media.Session.Suspended"));
   EXPECT_EQ(1, samples->TotalCount());
   EXPECT_EQ(0, samples->GetCount(0)); // System Transient
   EXPECT_EQ(0, samples->GetCount(1)); // System Permanent
   EXPECT_EQ(1, samples->GetCount(2)); // UI
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, UMA_ActiveTime_NoActivation) {
@@ skipping 16 matching lines @@
 
   MediaSessionUmaHelper* media_session_uma_helper = GetMediaSessionUMAHelper();
   base::SimpleTestClock* clock = new base::SimpleTestClock();
   clock->SetNow(base::Time::Now());
   media_session_uma_helper->SetClockForTest(
       scoped_ptr<base::SimpleTestClock>(clock));
 
   StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
 
   clock->Advance(base::TimeDelta::FromMilliseconds(1000));
-  media_session_->Stop();
+  media_session_->Stop(MediaSession::SuspendType::UI);
 
   scoped_ptr<base::HistogramSamples> samples(
       tester.GetHistogramSamplesSinceCreation("Media.Session.ActiveTime"));
   EXPECT_EQ(1, samples->TotalCount());
   EXPECT_EQ(1, samples->GetCount(1000));
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest,
                        UMA_ActiveTime_ActivationWithUISuspension) {
   scoped_ptr<MockMediaSessionObserver> media_session_observer(
     new MockMediaSessionObserver);
   base::HistogramTester tester;
 
   MediaSessionUmaHelper* media_session_uma_helper = GetMediaSessionUMAHelper();
   base::SimpleTestClock* clock = new base::SimpleTestClock();
   clock->SetNow(base::Time::Now());
   media_session_uma_helper->SetClockForTest(
       scoped_ptr<base::SimpleTestClock>(clock));
 
   StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
 
   clock->Advance(base::TimeDelta::FromMilliseconds(1000));
   UISuspend();
 
   clock->Advance(base::TimeDelta::FromMilliseconds(2000));
   UIResume();
 
   clock->Advance(base::TimeDelta::FromMilliseconds(1000));
-  media_session_->Stop();
+  media_session_->Stop(MediaSession::SuspendType::UI);
 
   scoped_ptr<base::HistogramSamples> samples(
       tester.GetHistogramSamplesSinceCreation("Media.Session.ActiveTime"));
   EXPECT_EQ(1, samples->TotalCount());
   EXPECT_EQ(1, samples->GetCount(2000));
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest,
                        UMA_ActiveTime_ActivationWithSystemSuspension) {
   scoped_ptr<MockMediaSessionObserver> media_session_observer(
     new MockMediaSessionObserver);
   base::HistogramTester tester;
 
   MediaSessionUmaHelper* media_session_uma_helper = GetMediaSessionUMAHelper();
   base::SimpleTestClock* clock = new base::SimpleTestClock();
   clock->SetNow(base::Time::Now());
   media_session_uma_helper->SetClockForTest(
       scoped_ptr<base::SimpleTestClock>(clock));
 
   StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
 
   clock->Advance(base::TimeDelta::FromMilliseconds(1000));
   SystemSuspend(true);
 
   clock->Advance(base::TimeDelta::FromMilliseconds(2000));
   SystemResume();
 
   clock->Advance(base::TimeDelta::FromMilliseconds(1000));
-  media_session_->Stop();
+  media_session_->Stop(MediaSession::SuspendType::UI);
 
   scoped_ptr<base::HistogramSamples> samples(
       tester.GetHistogramSamplesSinceCreation("Media.Session.ActiveTime"));
   EXPECT_EQ(1, samples->TotalCount());
   EXPECT_EQ(1, samples->GetCount(2000));
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest,
                        UMA_ActiveTime_ActivateSuspendedButNotStopped) {
   scoped_ptr<MockMediaSessionObserver> media_session_observer(
@@ skipping 35 matching lines @@
 
   MediaSessionUmaHelper* media_session_uma_helper = GetMediaSessionUMAHelper();
   base::SimpleTestClock* clock = new base::SimpleTestClock();
   clock->SetNow(base::Time::Now());
   media_session_uma_helper->SetClockForTest(
       scoped_ptr<base::SimpleTestClock>(clock));
 
   StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
   clock->Advance(base::TimeDelta::FromMilliseconds(500));
   SystemSuspend(true);
-  media_session_->Stop();
+  media_session_->Stop(MediaSession::SuspendType::UI);
 
   StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
   clock->Advance(base::TimeDelta::FromMilliseconds(5000));
   SystemResume();
-  media_session_->Stop();
+  media_session_->Stop(MediaSession::SuspendType::UI);
 
   scoped_ptr<base::HistogramSamples> samples(
       tester.GetHistogramSamplesSinceCreation("Media.Session.ActiveTime"));
   EXPECT_EQ(2, samples->TotalCount());
   EXPECT_EQ(1, samples->GetCount(500));
   EXPECT_EQ(1, samples->GetCount(5000));
 }
 
 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest,
                        UMA_ActiveTime_MultipleActivations) {
   scoped_ptr<MockMediaSessionObserver> media_session_observer(
     new MockMediaSessionObserver);
   base::HistogramTester tester;
 
   MediaSessionUmaHelper* media_session_uma_helper = GetMediaSessionUMAHelper();
   base::SimpleTestClock* clock = new base::SimpleTestClock();
   clock->SetNow(base::Time::Now());
   media_session_uma_helper->SetClockForTest(
       scoped_ptr<base::SimpleTestClock>(clock));
 
   StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
   clock->Advance(base::TimeDelta::FromMilliseconds(10000));
   RemovePlayer(media_session_observer.get(), 0);
 
   StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content);
   clock->Advance(base::TimeDelta::FromMilliseconds(1000));
-  media_session_->Stop();
+  media_session_->Stop(MediaSession::SuspendType::UI);
 
   scoped_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));
 }