OLD | NEW |
---|---|
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 1 // Copyright 2015 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "content/browser/media/session/media_session_impl.h" | 5 #include "content/browser/media/session/media_session_impl.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 | 8 |
9 #include <list> | 9 #include <list> |
10 #include <vector> | 10 #include <vector> |
(...skipping 15 matching lines...) Expand all Loading... | |
26 using content::WebContents; | 26 using content::WebContents; |
27 using content::MediaSession; | 27 using content::MediaSession; |
28 using content::MediaSessionImpl; | 28 using content::MediaSessionImpl; |
29 using content::MediaSessionObserver; | 29 using content::MediaSessionObserver; |
30 using content::AudioFocusDelegate; | 30 using content::AudioFocusDelegate; |
31 using content::MediaSessionPlayerObserver; | 31 using content::MediaSessionPlayerObserver; |
32 using content::MediaSessionUmaHelper; | 32 using content::MediaSessionUmaHelper; |
33 using content::MockMediaSessionPlayerObserver; | 33 using content::MockMediaSessionPlayerObserver; |
34 | 34 |
35 using ::testing::Expectation; | 35 using ::testing::Expectation; |
36 using ::testing::_; | |
36 | 37 |
37 namespace { | 38 namespace { |
38 | 39 |
39 const double kDefaultVolumeMultiplier = 1.0; | 40 const double kDefaultVolumeMultiplier = 1.0; |
40 const double kDuckingVolumeMultiplier = 0.2; | 41 const double kDuckingVolumeMultiplier = 0.2; |
41 | 42 |
42 class MockAudioFocusDelegate : public AudioFocusDelegate { | 43 class MockAudioFocusDelegate : public AudioFocusDelegate { |
43 public: | 44 public: |
44 bool RequestAudioFocus(content::AudioFocusManager::AudioFocusType) override { | 45 MockAudioFocusDelegate() { |
45 return true; | 46 ON_CALL(*this, RequestAudioFocus(_)).WillByDefault(::testing::Return(true)); |
46 } | 47 } |
47 | 48 |
48 void AbandonAudioFocus() override {} | 49 MOCK_METHOD1(RequestAudioFocus, |
50 bool(content::AudioFocusManager::AudioFocusType)); | |
51 MOCK_METHOD0(AbandonAudioFocus, void()); | |
49 }; | 52 }; |
50 | 53 |
51 class MockMediaSessionObserver : public MediaSessionObserver { | 54 class MockMediaSessionObserver : public MediaSessionObserver { |
52 public: | 55 public: |
53 MockMediaSessionObserver(MediaSession* media_session) | 56 MockMediaSessionObserver(MediaSession* media_session) |
54 : MediaSessionObserver(media_session) {} | 57 : MediaSessionObserver(media_session) {} |
55 | 58 |
56 MOCK_METHOD2(MediaSessionStateChanged, | 59 MOCK_METHOD2(MediaSessionStateChanged, |
57 void(bool is_controllable, bool is_suspended)); | 60 void(bool is_controllable, bool is_suspended)); |
58 MOCK_METHOD0(MediaSessionDestroyed, void()); | 61 MOCK_METHOD0(MediaSessionDestroyed, void()); |
59 }; | 62 }; |
60 | 63 |
61 } // namespace | 64 } // namespace |
62 | 65 |
63 class MediaSessionImplBrowserTest : public content::ContentBrowserTest { | 66 class MediaSessionImplBrowserTest : public content::ContentBrowserTest { |
64 protected: | 67 protected: |
65 MediaSessionImplBrowserTest() = default; | 68 MediaSessionImplBrowserTest() = default; |
66 | 69 |
67 void SetUpOnMainThread() override { | 70 void SetUpOnMainThread() override { |
68 ContentBrowserTest::SetUpOnMainThread(); | 71 ContentBrowserTest::SetUpOnMainThread(); |
69 | 72 |
70 media_session_ = MediaSessionImpl::Get(shell()->web_contents()); | 73 media_session_ = MediaSessionImpl::Get(shell()->web_contents()); |
71 mock_media_session_observer_.reset( | 74 mock_media_session_observer_.reset( |
72 new MockMediaSessionObserver(media_session_)); | 75 new MockMediaSessionObserver(media_session_)); |
76 mock_audio_focus_delegate_ = new MockAudioFocusDelegate(); | |
73 media_session_->SetDelegateForTests( | 77 media_session_->SetDelegateForTests( |
74 std::unique_ptr<AudioFocusDelegate>(new MockAudioFocusDelegate())); | 78 std::unique_ptr<AudioFocusDelegate>(mock_audio_focus_delegate_)); |
dcheng
2016/11/08 06:59:38
Nit: base::WrapUnique
Zhiqiang Zhang (Slow)
2016/11/10 15:07:18
Done.
| |
75 ASSERT_TRUE(media_session_); | 79 ASSERT_TRUE(media_session_); |
76 } | 80 } |
77 | 81 |
78 void TearDownOnMainThread() override { | 82 void TearDownOnMainThread() override { |
79 mock_media_session_observer_.reset(); | 83 mock_media_session_observer_.reset(); |
80 | 84 |
81 media_session_->RemoveAllPlayersForTest(); | 85 media_session_->RemoveAllPlayersForTest(); |
82 media_session_ = nullptr; | 86 media_session_ = nullptr; |
83 | 87 |
84 ContentBrowserTest::TearDownOnMainThread(); | 88 ContentBrowserTest::TearDownOnMainThread(); |
(...skipping 52 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
137 } | 141 } |
138 | 142 |
139 void SystemStartDucking() { media_session_->StartDucking(); } | 143 void SystemStartDucking() { media_session_->StartDucking(); } |
140 | 144 |
141 void SystemStopDucking() { media_session_->StopDucking(); } | 145 void SystemStopDucking() { media_session_->StopDucking(); } |
142 | 146 |
143 MockMediaSessionObserver* mock_media_session_observer() { | 147 MockMediaSessionObserver* mock_media_session_observer() { |
144 return mock_media_session_observer_.get(); | 148 return mock_media_session_observer_.get(); |
145 } | 149 } |
146 | 150 |
151 MockAudioFocusDelegate* mock_audio_focus_delegate() { | |
152 return mock_audio_focus_delegate_; | |
153 } | |
154 | |
147 std::unique_ptr<MediaSessionImpl> CreateDummyMediaSession() { | 155 std::unique_ptr<MediaSessionImpl> CreateDummyMediaSession() { |
148 return std::unique_ptr<MediaSessionImpl>(new MediaSessionImpl(nullptr)); | 156 return std::unique_ptr<MediaSessionImpl>(new MediaSessionImpl(nullptr)); |
149 } | 157 } |
150 | 158 |
151 MediaSessionUmaHelper* GetMediaSessionUMAHelper() { | 159 MediaSessionUmaHelper* GetMediaSessionUMAHelper() { |
152 return media_session_->uma_helper_for_test(); | 160 return media_session_->uma_helper_for_test(); |
153 } | 161 } |
154 | 162 |
155 protected: | 163 protected: |
156 MediaSessionImpl* media_session_; | 164 MediaSessionImpl* media_session_; |
157 std::unique_ptr<MockMediaSessionObserver> mock_media_session_observer_; | 165 std::unique_ptr<MockMediaSessionObserver> mock_media_session_observer_; |
166 MockAudioFocusDelegate* mock_audio_focus_delegate_; | |
158 | 167 |
159 DISALLOW_COPY_AND_ASSIGN(MediaSessionImplBrowserTest); | 168 DISALLOW_COPY_AND_ASSIGN(MediaSessionImplBrowserTest); |
160 }; | 169 }; |
161 | 170 |
162 IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest, | 171 IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest, |
163 PlayersFromSameObserverDoNotStopEachOtherInSameSession) { | 172 PlayersFromSameObserverDoNotStopEachOtherInSameSession) { |
164 std::unique_ptr<MockMediaSessionPlayerObserver> player_observer( | 173 std::unique_ptr<MockMediaSessionPlayerObserver> player_observer( |
165 new MockMediaSessionPlayerObserver); | 174 new MockMediaSessionPlayerObserver); |
166 | 175 |
167 StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent); | 176 StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent); |
(...skipping 713 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
881 | 890 |
882 StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent); | 891 StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent); |
883 UISuspend(); | 892 UISuspend(); |
884 UIResume(); | 893 UIResume(); |
885 | 894 |
886 EXPECT_TRUE(IsControllable()); | 895 EXPECT_TRUE(IsControllable()); |
887 EXPECT_FALSE(IsSuspended()); | 896 EXPECT_FALSE(IsSuspended()); |
888 } | 897 } |
889 | 898 |
890 IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest, | 899 IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest, |
900 ControlsDontShowWhenOneShotIsPresent) { | |
901 EXPECT_CALL(*mock_media_session_observer(), | |
902 MediaSessionStateChanged(false, false)); | |
903 | |
904 std::unique_ptr<MockMediaSessionPlayerObserver> player_observer( | |
dcheng
2016/11/08 06:59:38
Optional nit: auto player_observer = base::MakeUni
Zhiqiang Zhang (Slow)
2016/11/10 15:07:18
Done.
| |
905 new MockMediaSessionPlayerObserver); | |
906 | |
907 StartNewPlayer(player_observer.get(), media::MediaContentType::OneShot); | |
908 | |
909 EXPECT_FALSE(IsControllable()); | |
910 EXPECT_FALSE(IsSuspended()); | |
911 | |
912 StartNewPlayer(player_observer.get(), media::MediaContentType::Transient); | |
913 EXPECT_FALSE(IsControllable()); | |
914 EXPECT_FALSE(IsSuspended()); | |
915 | |
916 StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent); | |
917 EXPECT_FALSE(IsControllable()); | |
918 EXPECT_FALSE(IsSuspended()); | |
919 } | |
920 | |
921 IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest, | |
922 ControlsShowAfterRemoveOneShot) { | |
923 Expectation uncontrollable = EXPECT_CALL( | |
924 *mock_media_session_observer(), MediaSessionStateChanged(false, false)); | |
925 | |
926 EXPECT_CALL(*mock_media_session_observer(), | |
927 MediaSessionStateChanged(true, false)) | |
928 .After(uncontrollable); | |
929 | |
930 std::unique_ptr<MockMediaSessionPlayerObserver> player_observer( | |
931 new MockMediaSessionPlayerObserver); | |
932 | |
933 StartNewPlayer(player_observer.get(), media::MediaContentType::OneShot); | |
934 StartNewPlayer(player_observer.get(), media::MediaContentType::Transient); | |
935 StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent); | |
936 | |
937 RemovePlayer(player_observer.get(), 0); | |
938 | |
939 EXPECT_TRUE(IsControllable()); | |
940 EXPECT_FALSE(IsSuspended()); | |
941 } | |
942 | |
943 IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest, | |
944 DontSuspendWhenOneShotIsPresent) { | |
945 std::unique_ptr<MockMediaSessionPlayerObserver> player_observer( | |
946 new MockMediaSessionPlayerObserver); | |
947 | |
948 StartNewPlayer(player_observer.get(), media::MediaContentType::OneShot); | |
949 StartNewPlayer(player_observer.get(), media::MediaContentType::Transient); | |
950 StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent); | |
951 | |
952 SystemSuspend(false); | |
953 | |
954 EXPECT_FALSE(IsControllable()); | |
955 EXPECT_FALSE(IsSuspended()); | |
956 | |
957 EXPECT_EQ(0, player_observer->received_suspend_calls()); | |
958 } | |
959 | |
960 IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest, | |
891 DontResumeBySystemUISuspendedSessions) { | 961 DontResumeBySystemUISuspendedSessions) { |
892 std::unique_ptr<MockMediaSessionPlayerObserver> player_observer( | 962 std::unique_ptr<MockMediaSessionPlayerObserver> player_observer( |
893 new MockMediaSessionPlayerObserver); | 963 new MockMediaSessionPlayerObserver); |
894 StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent); | 964 StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent); |
895 | 965 |
896 UISuspend(); | 966 UISuspend(); |
897 EXPECT_TRUE(IsControllable()); | 967 EXPECT_TRUE(IsControllable()); |
898 EXPECT_TRUE(IsSuspended()); | 968 EXPECT_TRUE(IsSuspended()); |
899 | 969 |
900 SystemResume(); | 970 SystemResume(); |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
938 | 1008 |
939 SystemSuspend(true); | 1009 SystemSuspend(true); |
940 EXPECT_TRUE(IsControllable()); | 1010 EXPECT_TRUE(IsControllable()); |
941 EXPECT_TRUE(IsSuspended()); | 1011 EXPECT_TRUE(IsSuspended()); |
942 | 1012 |
943 SystemResume(); | 1013 SystemResume(); |
944 EXPECT_TRUE(IsControllable()); | 1014 EXPECT_TRUE(IsControllable()); |
945 EXPECT_FALSE(IsSuspended()); | 1015 EXPECT_FALSE(IsSuspended()); |
946 } | 1016 } |
947 | 1017 |
1018 IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest, OneShotTakesGainFocus) { | |
1019 std::unique_ptr<MockMediaSessionPlayerObserver> player_observer( | |
1020 new MockMediaSessionPlayerObserver); | |
1021 EXPECT_CALL( | |
1022 *mock_audio_focus_delegate(), | |
1023 RequestAudioFocus(content::AudioFocusManager::AudioFocusType::Gain)) | |
1024 .Times(1); | |
1025 EXPECT_CALL(*mock_audio_focus_delegate(), | |
1026 RequestAudioFocus(::testing::Ne( | |
1027 content::AudioFocusManager::AudioFocusType::Gain))) | |
1028 .Times(0); | |
1029 StartNewPlayer(player_observer.get(), media::MediaContentType::OneShot); | |
1030 StartNewPlayer(player_observer.get(), media::MediaContentType::Transient); | |
1031 StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent); | |
1032 } | |
1033 | |
1034 IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest, RemovingOneShotDropsFocus) { | |
1035 std::unique_ptr<MockMediaSessionPlayerObserver> player_observer( | |
1036 new MockMediaSessionPlayerObserver); | |
1037 EXPECT_CALL(*mock_audio_focus_delegate(), AbandonAudioFocus()); | |
1038 StartNewPlayer(player_observer.get(), media::MediaContentType::OneShot); | |
1039 RemovePlayer(player_observer.get(), 0); | |
1040 } | |
1041 | |
1042 IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest, | |
1043 RemovingOneShotWhileStillHavingOtherPlayersKeepsFocus) { | |
1044 std::unique_ptr<MockMediaSessionPlayerObserver> player_observer( | |
1045 new MockMediaSessionPlayerObserver); | |
1046 EXPECT_CALL(*mock_audio_focus_delegate(), AbandonAudioFocus()) | |
1047 .Times(1); // Called in TearDown | |
1048 StartNewPlayer(player_observer.get(), media::MediaContentType::OneShot); | |
1049 StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent); | |
1050 RemovePlayer(player_observer.get(), 0); | |
1051 } | |
1052 | |
948 IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest, | 1053 IN_PROC_BROWSER_TEST_F(MediaSessionImplBrowserTest, |
949 UMA_Suspended_SystemTransient) { | 1054 UMA_Suspended_SystemTransient) { |
950 std::unique_ptr<MockMediaSessionPlayerObserver> player_observer( | 1055 std::unique_ptr<MockMediaSessionPlayerObserver> player_observer( |
951 new MockMediaSessionPlayerObserver); | 1056 new MockMediaSessionPlayerObserver); |
952 base::HistogramTester tester; | 1057 base::HistogramTester tester; |
953 | 1058 |
954 StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent); | 1059 StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent); |
955 SystemSuspend(true); | 1060 SystemSuspend(true); |
956 | 1061 |
957 std::unique_ptr<base::HistogramSamples> samples( | 1062 std::unique_ptr<base::HistogramSamples> samples( |
(...skipping 279 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1237 StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent); | 1342 StartNewPlayer(player_observer.get(), media::MediaContentType::Persistent); |
1238 clock->Advance(base::TimeDelta::FromMilliseconds(1000)); | 1343 clock->Advance(base::TimeDelta::FromMilliseconds(1000)); |
1239 media_session_->Stop(MediaSession::SuspendType::UI); | 1344 media_session_->Stop(MediaSession::SuspendType::UI); |
1240 | 1345 |
1241 std::unique_ptr<base::HistogramSamples> samples( | 1346 std::unique_ptr<base::HistogramSamples> samples( |
1242 tester.GetHistogramSamplesSinceCreation("Media.Session.ActiveTime")); | 1347 tester.GetHistogramSamplesSinceCreation("Media.Session.ActiveTime")); |
1243 EXPECT_EQ(2, samples->TotalCount()); | 1348 EXPECT_EQ(2, samples->TotalCount()); |
1244 EXPECT_EQ(1, samples->GetCount(1000)); | 1349 EXPECT_EQ(1, samples->GetCount(1000)); |
1245 EXPECT_EQ(1, samples->GetCount(10000)); | 1350 EXPECT_EQ(1, samples->GetCount(10000)); |
1246 } | 1351 } |
OLD | NEW |