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/command_line.h"
 #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/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 "media/base/media_switches.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 ::testing::Expectation;
 
 namespace {
 
+class MockMediaSessionDelegate : public MediaSessionDelegate {
+ public:
+  bool RequestAudioFocus(MediaSession::Type) override {
+    return true;
+  }
+
+  void AbandonAudioFocus() override {
+  }
+};
+
 class MockMediaSessionObserver : public MediaSessionObserver {
  public:
   MockMediaSessionObserver()
       : received_resume_calls_(0),
         received_suspend_calls_(0) {
   }
 
   ~MockMediaSessionObserver() override = default;
 
   // Implements MediaSessionObserver.
@@ skipping 83 matching lines @@
 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_->SetDelegateForTest(
+        scoped_ptr<MediaSessionDelegate>(new MockMediaSessionDelegate()));
     ASSERT_TRUE(media_session_);
   }
 
+  void SetUpCommandLine(base::CommandLine* command_line) override {
+    command_line->AppendSwitch(switches::kEnableDefaultMediaSession);
+  }
+
   void TearDownOnMainThread() override {
     mock_web_contents_observer_.reset();
 
     media_session_->RemoveAllPlayersForTest();
     media_session_ = nullptr;
 
     ContentBrowserTest::TearDownOnMainThread();
   }
 
   void StartNewPlayer(MockMediaSessionObserver* media_session_observer,
@@ skipping 29 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));
 }
+
+#if !defined(OS_ANDROID)
+class DefaultMediaSessionBrowserTest : public content::ContentBrowserTest {

[mlamouri (slow - plz ping), 2016/02/17 19:30:12]

I'm going to move this test to media_session_delegate_default_browsertest.cc but
I do not have the time today and the CL is otherwise ready to be looked at.

[mlamouri (slow - plz ping), 2016/02/23 20:27:55]

Done.

+ protected:
+  void SetUpCommandLine(base::CommandLine* command_line) override {
+    command_line->AppendSwitch(switches::kEnableDefaultMediaSession);
+  }
+};
+
+IN_PROC_BROWSER_TEST_F(DefaultMediaSessionBrowserTest,
+                       ActiveWebContentsPauseOthers) {
+  scoped_ptr<MockMediaSessionObserver> media_session_observer(
+      new MockMediaSessionObserver);
+
+  MediaSession* media_session = MediaSession::Get(shell()->web_contents());
+  ASSERT_TRUE(media_session);
+
+  WebContents* other_web_contents = CreateBrowser()->web_contents();
+  MediaSession* other_media_session = MediaSession::Get(other_web_contents);
+  ASSERT_TRUE(other_media_session);
+
+  media_session_observer->StartNewPlayer();
+  media_session->AddPlayer(
+      media_session_observer.get(), 0, MediaSession::Type::Content);
+  EXPECT_TRUE(media_session->IsActive());
+  EXPECT_FALSE(other_media_session->IsActive());
+
+  media_session_observer->StartNewPlayer();
+  other_media_session->AddPlayer(
+      media_session_observer.get(), 1, MediaSession::Type::Content);
+  EXPECT_FALSE(media_session->IsActive());
+  EXPECT_TRUE(other_media_session->IsActive());
+
+  media_session->Stop(MediaSession::SuspendType::UI);
+  other_media_session->Stop(MediaSession::SuspendType::UI);
+}
+
+#endif // !OS_ANDROID